HackStack

Project Info

Trajectory

Devpost

Inspiration

I spend a lot of time working through ideas in ChatGPT. A conversation may start with one simple question, but after a while it includes different options, changing constraints, rejected suggestions, and eventually a decision. The full transcript is still there, but it becomes difficult to see how the thinking actually changed. Search can find a phrase, and a summary can shorten the conversation, but neither really shows the path from the original question to the final direction. That is why I built Trajectory. I wanted a way to look back at a long conversation and quickly understand what happened, what changed, and what mattered.

What it does

Trajectory is a Chrome side-panel extension that analyzes the ChatGPT conversation currently open in the browser. It organizes the conversation into two views: Arc shows the conversation as a sequence of phases. Findings surfaces patterns, tensions, and decisions that appeared across multiple exchanges. Each finding is connected to the phases and messages that support it. With Show in chat, I can jump from a finding directly to the exact words behind it. The goal is not to ask people to blindly trust an AI-generated summary. Trajectory lets them inspect the evidence for themselves.

How we built it

Trajectory is built as a Manifest V3 Chrome extension using a side panel, background worker, and content script. The content script reads the active ChatGPT conversation from the authenticated browser tab. It traverses the thread, extracts the messages, normalizes them, and creates a fingerprint for the current version of the conversation. The extension checks chrome.storage.local for an existing compatible analysis. When it needs a new one, it sends the normalized transcript to a Node.js and Express backend. The backend uses the OpenAI Responses API with Structured Outputs. GPT-5.6 generates the phases, findings, and source references. Before the result appears in the extension, additional validation checks the schema, speaker roles, message references, finding relationships, and exact source excerpts. The backend never tries to fetch a private ChatGPT URL. It also never receives the user’s ChatGPT cookies or account credentials. Analysis only starts when the user requests it, OpenAI requests use store: false, and an updated conversation cannot reuse an outdated result. I used Codex throughout development to inspect the codebase, implement focused changes, reproduce issues, write tests, and run the verification loop. The product decisions came from my own testing and critique, while Codex helped me turn those decisions into working code much faster.

Challenges we ran into

One of the first challenges was extracting the complete conversation. ChatGPT can virtualize parts of the interface, so the messages currently visible on screen may not be the full thread. I needed controlled traversal, completeness checks, stable local message identifiers, and transcript fingerprints. Another challenge was getting the analysis to understand who actually made a decision. ChatGPT may suggest an idea, but that does not mean the user accepted it. Trajectory had to distinguish between a suggestion, rejection, acceptance, implementation, reconsideration, and an unresolved idea. Grounding was another major problem. Some early findings sounded convincing but pointed to the wrong message. I changed the system so an evidence excerpt must be verified against the referenced source before Trajectory can display or open it. The product also became too complicated at several points. Early versions included message scores, charts, fixed perspectives, correction controls, and several overlapping analysis layers. They looked impressive, but they made the conversation harder to understand. I kept removing features until the product had two clear ideas: Arc and Findings. There was also the practical challenge of fitting meaningful analysis into a narrow Chrome side panel without horizontal scrolling, clipped text, or confusing navigation.

Accomplishments we're proud of

I am proud that Trajectory does more than produce another summary. It reconstructs how a conversation developed and surfaces patterns that may be difficult to notice while the discussion is still happening. The part I am most proud of is Show in chat. I can open a finding, inspect one of its supporting exchanges, and jump directly to the exact words behind it without losing my place in Trajectory. I also built deterministic validation around the model output, transcript-aware cache invalidation, responsive side-panel layouts, clear separation between real and prepared data, and a sanitized judge demo that can run without an OpenAI key or private ChatGPT account. The product went through many different versions, but its value can now be explained simply: A long conversation becomes a clear Arc, useful Findings, and evidence you can verify.

What we learned

The biggest lesson was that a better summary was not enough. The more interesting problem was helping people understand how their own thinking developed over time. I also learned that AI-generated analysis becomes much more trustworthy when the user can inspect the exact messages supporting it. Another important lesson was to keep user agency clear. Trajectory should explain the reasoning and decisions already present in a conversation. It should not act as though ChatGPT made those decisions for the user. Finally, I learned that removing features can improve a product more than adding them. The biggest improvements came from deleting scores, fixed lenses, duplicated analysis, and unnecessary navigation.

What's next

The next step is making extraction more resilient when ChatGPT changes its interface, especially for very long conversations and responses that are still streaming. I also want to preserve more of the original content, including formatting, code, and eventually images. Longer term, Trajectory could support projects that span multiple conversations, cloud synchronization, and other AI conversation platforms. Before making the analysis service broadly available, I would also add stronger authentication, quotas, distributed rate limiting, monitoring, and budget controls.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only
  • CSSIn code
  • ExpressIn code
  • HTMLIn code
  • JavaScriptIn code
  • OpenAIIn code
  • ReactIn code
  • TypeScriptIn code
  • Node.jsClaimed

7 of 8 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

914 KB

Source files

98

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

0 stars