Support adding "Tags" or "Bookmarks" within a single conversation for quick navigation

[Kyvrel]

Is your feature request related to a problem? Please describe.
I often find myself having very long conversations that cover multiple distinct topics or distinct phases of coding (e.g., "Requirement Analysis," "Database Design," "Bug Fixing").

Currently, when I need to review or study these long conversations later, it is very difficult to locate specific topics. I have to scroll up and down repeatedly to find the exact part where a specific topic was discussed.

Describe the solution you'd like
I would like to request a feature that allows users to add Tags, Labels, or Bookmarks to specific messages within a chat thread.

Ideally, it would work like this:

1. Tagging: Right-click or hover over a message to add a custom tag (e.g., "Login Logic," "API Error Fix").
2. Navigation: Have a sidebar or a dropdown menu that lists all the tags in the current conversation.
3. Jumping: Clicking on a tag in the list immediately scrolls the view to that specific message.

Describe alternatives you've considered
Currently, I have to use the browser's "Find" (Cmd+F) feature to search for keywords, but this is inefficient if I don't remember the exact wording I used.

Additional context
This feature would be extremely helpful for users who use the tool for deep learning and reviewing complex coding sessions. It acts like a "Table of Contents" for a long conversation.

Thanks for your hard work on this project!

[daaain]

Hey @Kyvrel,

Currently, all the library outputs are static files. The interactive features in the HTML page (like filtering, timeline, etc) are all client side and don't have any persistence layer.

The only solution I can think of is maybe using browser localStorage, but even that might not be fully supported for opening HTML files with file:// protocol.

I've been planning for a while to migrate the JSON cache to SQLite which could provide the perfect storage backend for this, but the library would probably still also need to add a web server to host the HTML files as I don't think there's a way to access other files or localhost otherwise.

I think the feature would be useful, but we need to find the best way to store these.

[neonwatty]

• Agree! I think a Sqlite cache would definitely be a great choice to include these requested features (I also want them!)
• Submitted a short PR for this with basic tests to move cache from JSON --> Sqlite. Would be happy to break up into smaller PRs if helpful. Most everything is adjustments to claude_code_log/cache.py - then some basic tests.
• Then would be happy to help add tags / toc - as I want these features as well!
• Why not add an (optional) web server? Would be happy to contribute! I think this would be a great enhancement.

[cboos]

I was thinking that you could even use Claude Code to generate such annotations...

Prototyping:

jq -r 'select(.type == "user") | 
     {uuid, text: (.message.content | 
       if type == "string" then . 
       elif type == "array" then [.[] | select(.type == "text").text] | join("\n")
       else null end)} | 
     select(.text != null and .text != "")' \
  test/test_data/real_projects/-src-deep-manifest/a7da6a22-facc-4fcd-8bab-f83c87862004.jsonl | \
claude --model haiku -p 'This is JSONL stream of uuid/text from a Claude Code conversation log;
please let it pass through, make it compact as in JSONL (one dict per line), but replace "text" with:
1) "keywords", containing the 2-3 salient one-word keywords you can associate to each message,
2) "phase": characterize what this user was doing, one of:
   - "Specifying",
   - "Implementing",
   - "Revising",
   - "Troubleshooting",
   - "Reviewing",
   - "Testing",
   - "Other" (or "Other (...)" where ... is a suggestion)' | tee annotations.jsonl
```json
{"uuid": "0a6c5e29-9865-43a3-8048-a870f38d14e1", "keywords": ["system", "caveat", "local"], "phase": "Other (meta-instruction)"}
{"uuid": "fbfaa419-c032-467f-a791-7b0ac66539a6", "keywords": ["context", "command", "tool"], "phase": "Other (system command)"}
{"uuid": "9fd2eb85-0e4d-4a69-b3ec-8a7ae504bd06", "keywords": ["context", "tokens", "usage"], "phase": "Reviewing"}
{"uuid": "92757a7c-5fef-4e3f-8f26-4cd4c3069187", "keywords": ["system", "caveat", "local"], "phase": "Other (meta-instruction)"}
{"uuid": "200652a8-ed8f-40ca-9239-5a661fa2c9be", "keywords": ["model", "command", "switch"], "phase": "Other (system command)"}
{"uuid": "f880c35d-8afe-4cfb-82bf-37c39f423457", "keywords": ["model", "opus", "set"], "phase": "Other (system command)"}
{"uuid": "7b67d97e-aa0a-40e4-a140-6236076f0354", "keywords": ["git", "commit", "changes"], "phase": "Reviewing"}
{"uuid": "51703481-d802-4036-ad03-f2f2c84de966", "keywords": ["tests", "validation", "documentation"], "phase": "Reviewing"}
{"uuid": "416cb2ac-f89a-48c0-8000-9605b8b4b3af", "keywords": ["commit", "milestone", "snapshot"], "phase": "Reviewing"}
{"uuid": "5afedbcd-99e3-42e2-95bb-cd138e0d70e0", "keywords": ["tar", "archive", "feature"], "phase": "Specifying"}
{"uuid": "08aae69a-9ae3-40be-9b85-63e3370aeed3", "keywords": ["error", "reporting", "manifest"], "phase": "Specifying"}
{"uuid": "10b9632d-3499-42d4-b89d-bb969d1ba6b4", "keywords": ["interrupted", "tool", "use"], "phase": "Other (interrupted)"}
{"uuid": "069e61c7-b74e-4d73-85dc-20c4cfca01c3", "keywords": ["tar", "commit", "sequence"], "phase": "Specifying"}
{"uuid": "0c8c6a73-588d-4cf9-9cb7-b22bd370af8c", "keywords": ["acknowledgement", "thanks", "complete"], "phase": "Other (closing)"}
```

We could do the jq part (e.g., claude-code-log --export user). And instead of leaving the annotation.jsonl on the filesystem, we could replace the tee with a claude-code-log --import phase,keywords, to either modify the session in place, or to use this SQLite backend you proposed... but I'm not sure if this really better than using annotation files.

I see such an external annotation.jsonl file as a more flexible solution. You could vary your prompts over time, it won't "stick" to the session and become a maintenance problem (how to remove some tags/add some tags, if you were using SQLite for that).

For example, if you think that there were too many tags in the above, you could iterate:

claude-code-log --export user | claude --model haiku -p '
This is JSONL stream of uuid/text from a Claude Code conversation log;
please let it pass through, make it compact as in JSONL (one dict per line), but replace "text" with:
1) "keywords", containing the 2-3 salient one-word keywords you can associate to each message (no more than 20 tags overall),
2) phase": characterize what this user was doing, one of:
   - "Specifying",
   - "Implementing",
   - "Revising",
   - "Troubleshooting",
   - "Reviewing",
   - "Testing",
   - "Other" (or "Other (...)" where ... is a suggestion)
' | tee annotations.jsonl
```jsonl
{"uuid":"0a6c5e29-9865-43a3-8048-a870f38d14e1","keywords":["caveat","system"],"phase":"Other (system message)"}
{"uuid":"fbfaa419-c032-467f-a791-7b0ac66539a6","keywords":["context","command"],"phase":"Other (checking context)"}
{"uuid":"9fd2eb85-0e4d-4a69-b3ec-8a7ae504bd06","keywords":["tokens","usage"],"phase":"Reviewing"}
{"uuid":"92757a7c-5fef-4e3f-8f26-4cd4c3069187","keywords":["caveat","system"],"phase":"Other (system message)"}
{"uuid":"200652a8-ed8f-40ca-9239-5a661fa2c9be","keywords":["model","command"],"phase":"Other (model selection)"}
{"uuid":"f880c35d-8afe-4cfb-82bf-37c39f423457","keywords":["opus","model"],"phase":"Other (model set)"}
{"uuid":"7b67d97e-aa0a-40e4-a140-6236076f0354","keywords":["commit","changes"],"phase":"Implementing"}
{"uuid":"51703481-d802-4036-ad03-f2f2c84de966","keywords":["tests","status"],"phase":"Reviewing"}
{"uuid":"416cb2ac-f89a-48c0-8000-9605b8b4b3af","keywords":["milestone","commit"],"phase":"Implementing"}
{"uuid":"5afedbcd-99e3-42e2-95bb-cd138e0d70e0","keywords":["tar","archives"],"phase":"Specifying"}
{"uuid":"08aae69a-9ae3-40be-9b85-63e3370aeed3","keywords":["errors","manifest"],"phase":"Specifying"}
{"uuid":"10b9632d-3499-42d4-b89d-bb969d1ba6b4","keywords":["interrupt","tool"],"phase":"Other (interrupted)"}
{"uuid":"069e61c7-b74e-4d73-85dc-20c4cfca01c3","keywords":["commit","tar"],"phase":"Implementing"}
{"uuid":"0c8c6a73-588d-4cf9-9cb7-b22bd370af8c","keywords":["gratitude","complete"],"phase":"Other (acknowledgment)"}
```

And of course, using Claude Code wouldn't be the only way to "annotate": you could simply do some grep/sed to flag some user matching keywords or patterns. Also, you could have different prompts or keywords for tagging the "assistant" or "tool" messages. My point is that such possibility to do automatic annotations would probably be more useful on long sessions with thousands of messages than having the possibility to add annotations manually (that could also be useful, of course).

Finally, when rendering, you could add the different annotation files you have prepared (--annotate file1.jsonl --annotate --file2.json).