cc-sessions 1.1.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d599c44925b47fb2fd595e9956d6591eebd6d20491fbfcf9dabe0fd15713c36c
-  data.tar.gz: d33291906f06251ab048ecddb2e814d5344897222d0f08feb12a2ecdf0e57414
+  metadata.gz: 605f4de2854d8c09e7930c20cb0bce3f3b511d6dc4d7f7e87258d1eb9082108f
+  data.tar.gz: c87c3a2b615a1631c5932154055b49d8bebec23663031dd1ffb446fe79477cef
 SHA512:
-  metadata.gz: ca6d6a84a451646a729dbe14657b692991e2299429f4c96133b5136e188601812b64e6302873612e095ee132da743d6ee741bb8cf17b828fa0ca3c8bb1375fb8
-  data.tar.gz: 5ea42920ca5c79ab283409c538cedfe1f35e99858d59c8b23d507ba6730a1a4ee7d3fd67881ac3dd7e7a222b7c25a432f4c9259cf3a339e2481a6c33efcbd41b
+  metadata.gz: 1f9d6e2c15ff339679c7a65fe43354b2ee4518c8ebe78af68092492244c35e82f4afeac6a119e36914ba63e4734283e188b28b7d65e3fa77cebb3f51e5b056f6
+  data.tar.gz: 776a04d367ad4c6e169ebc58819a1cf62baa835f32f9fd9bd680a16d04fbabe65f5fe07b70f251d7221421be944a5e8226b489cd2099f625926243a1505bcba0

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.3.0] - 2026-02-27
+
+### Added
+- Running session indicator (green `●`) in `cc -l` interactive list
+- Resume breadcrumbs to track session continuations across context resets
+- `CC_SESSION_ID` and `CC_RESUME_TAGS` env vars passed to resumed sessions
+- `exclude_id` support in session detection for sibling session discovery
+
+### Changed
+- `cc-bookmark` now checks env vars first for reliable session identification
+- `/bm?` auto-migrates bookmark to new session ID after context reset
+
+## [1.2.0] - 2026-02-19
+
+### Added
+- Session ID-based bookmarks (v2 format) for reliable session resume
+- Auto-migration from v1 path-based bookmarks to v2 session IDs
+- OSC 7 escape sequence on session resume for wezterm CWD tracking
+- Reorder bookmarks with J/K (Shift+j/k) in interactive list
+- `--resume <session_id>` used for direct session resume
+
+### Changed
+- Bookmarks now keyed by session UUID instead of directory path
+- `cc-bookmark` updated to detect and store session IDs
+- Fallback to `path:<dir>` key when session ID unavailable
+
 ## [1.1.4] - 2025-02-10
 
 ### Fixed

data/README.md

@@ -18,6 +18,7 @@ meaningful names and quickly resume them.
 - **Check bookmark** with `/bm?` to see current tags
 - **Resume sessions** with `cc tag` from anywhere
 - **Interactive list** with `cc -l` (arrow keys or j/k to navigate)
+- **Running indicator** shows green `●` next to active sessions in `cc -l`
 - **Delete bookmarks** with `d` in list or `cc -d tag`
 - **Auto-install** the `/bm` command and permission on first run
 - **Zero dependencies** - pure Ruby

data/bin/cc

@@ -17,6 +17,7 @@
 require 'json'
 require 'fileutils'
 require 'io/console'
+require 'set'
 
 # Simple ANSI helpers
 def cyan(s)  = "\e[36m#{s}\e[0m"
@@ -32,12 +33,11 @@ COMMAND_SOURCE = File.expand_path('../commands/bm.md', __dir__)
 COMMAND_DEST = File.expand_path('~/.claude/commands/bm.md')
 SETTINGS_FILE = File.expand_path('~/.claude/settings.json')
 BM_PERMISSION = 'Bash(cc-bookmark:*)'
+CLAUDE_PROJECTS = File.expand_path('~/.claude/projects')
 
 def ensure_setup
-  # Create config directory
   FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
 
-  # Install /bm command if not present
   unless File.exist?(COMMAND_DEST)
     if File.exist?(COMMAND_SOURCE)
       FileUtils.mkdir_p(File.dirname(COMMAND_DEST))
@@ -48,7 +48,6 @@ def ensure_setup
     end
   end
 
-  # Add auto-accept permission for /bm command
   ensure_permission
 end
 
@@ -70,84 +69,86 @@ def ensure_permission
     puts
   end
 rescue JSON::ParserError
-  # If settings.json is malformed, skip permission setup
   warn "Warning: Could not parse ~/.claude/settings.json - skipping permission setup"
 end
 
-def load_bookmarks
-  return {} unless File.exist?(BOOKMARKS_FILE)
-  JSON.parse(File.read(BOOKMARKS_FILE))
-rescue JSON::ParserError
-  {}
-end
-
-CLAUDE_PROJECTS = File.expand_path('~/.claude/projects')
-
 def resolve_session_dir(cwd)
-  # Find the original session directory by checking ~/.claude/projects/
-  # Claude encodes project paths as /foo/bar -> -foo-bar
   path = cwd
   loop do
     encoded = path.gsub('/', '-')
     return path if Dir.exist?(File.join(CLAUDE_PROJECTS, encoded))
     parent = File.dirname(path)
-    break if parent == path  # reached root
+    break if parent == path
     path = parent
   end
-  cwd  # fallback to cwd if no project dir found
+  cwd
 end
 
-def find_tags_for_path(path, bookmarks)
-  bookmarks[path] || []
-end
-
-def show_current_sessions
-  # Find running claude processes
-  pids = `pgrep -x claude 2>/dev/null`.split.map(&:to_i)
-
-  if pids.empty?
-    puts "No Claude Code sessions currently running."
-    return
-  end
+def detect_session_id(session_dir)
+  encoded = session_dir.gsub('/', '-')
+  project_dir = File.join(CLAUDE_PROJECTS, encoded)
+  return nil unless Dir.exist?(project_dir)
 
-  bookmarks = load_bookmarks
+  newest = Dir.glob(File.join(project_dir, '*.jsonl'))
+               .select { |f| File.file?(f) }
+               .max_by { |f| File.mtime(f) }
+  return nil unless newest
 
-  puts "Running sessions:\n\n"
+  File.basename(newest, '.jsonl')
+end
 
-  pids.each do |pid|
-    cwd_link = "/proc/#{pid}/cwd"
-    next unless File.exist?(cwd_link)
+def load_bookmarks
+  unless File.exist?(BOOKMARKS_FILE)
+    return { 'version' => 2, 'sessions' => {} }
+  end
 
-    begin
-      cwd = File.readlink(cwd_link)
-      session_dir = resolve_session_dir(cwd)
-      tags = find_tags_for_path(session_dir, bookmarks)
-      tag_str = tags.empty? ? dim('(no tags)') : green(tags.join(', '))
+  data = JSON.parse(File.read(BOOKMARKS_FILE))
+  if data['version']
+    data
+  else
+    migrate_bookmarks(data)
+  end
+rescue JSON::ParserError
+  { 'version' => 2, 'sessions' => {} }
+end
 
-      puts "  PID #{cyan(pid.to_s)}: #{session_dir}"
-      puts "         Tags: #{tag_str}"
-      puts
-    rescue Errno::EACCES
-      puts "  PID #{cyan(pid.to_s)}: #{dim('(permission denied)')}"
-      puts
-    end
+def migrate_bookmarks(old_data)
+  sessions = {}
+  old_data.each do |path, tags|
+    sid = detect_session_id(path)
+    key = sid || "path:#{path}"
+    sessions[key] = { 'path' => path, 'tags' => tags }
   end
+  new_data = { 'version' => 2, 'sessions' => sessions }
+  save_bookmarks(new_data)
+  new_data
+end
+
+def save_bookmarks(bookmarks)
+  FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+  File.write(BOOKMARKS_FILE, JSON.pretty_generate(bookmarks))
 end
 
 def find_session_by_tag(tag)
   bookmarks = load_bookmarks
-  bookmarks.each do |path, tags|
-    return path if tags.include?(tag)
+  bookmarks['sessions'].each do |id, entry|
+    if entry['tags'].include?(tag)
+      return { id: id, path: entry['path'] }
+    end
   end
   nil
 end
 
+def find_tags_for_path(path, bookmarks)
+  bookmarks['sessions'].each_value do |entry|
+    return entry['tags'] if entry['path'] == path
+  end
+  []
+end
+
 def session_exists_in_dir?(dir)
-  # Check for .claude directory with session files
   claude_dir = File.join(dir, '.claude')
   return false unless Dir.exist?(claude_dir)
-
-  # Look for conversation files or other session indicators
   Dir.glob(File.join(claude_dir, '**/*')).any? { |f| File.file?(f) }
 end
 
@@ -155,32 +156,30 @@ def read_key
   input = $stdin.getch
   if input == "\e"
     begin
-      input << $stdin.read_nonblock(3)
+      input << $stdin.read_nonblock(5)
     rescue IO::WaitReadable
     end
   end
   case input
-  when "\e[A", "k" then :up
-  when "\e[B", "j" then :down
-  when "\r", "\n"  then :enter
-  when "q", "\e"   then :quit
-  when "d"         then :delete
+  when "\e[A", "k"      then :up
+  when "\e[B", "j"      then :down
+  when "\e[1;2A", "K"   then :move_up
+  when "\e[1;2B", "J"   then :move_down
+  when "\r", "\n"       then :enter
+  when "q", "\e"        then :quit
+  when "d"              then :delete
   else nil
   end
 end
 
-def save_bookmarks(bookmarks)
-  File.write(BOOKMARKS_FILE, JSON.pretty_generate(bookmarks))
-end
-
 def delete_bookmark_by_tag(tag)
   bookmarks = load_bookmarks
-  path = find_session_by_tag(tag)
+  match = find_session_by_tag(tag)
 
-  if path
-    bookmarks.delete(path)
+  if match
+    bookmarks['sessions'].delete(match[:id])
     save_bookmarks(bookmarks)
-    puts "Deleted bookmark: #{path}"
+    puts "Deleted bookmark: #{match[:path]}"
     puts "  (was tagged: #{tag})"
   else
     puts "No session found with tag '#{tag}'"
@@ -188,44 +187,64 @@ def delete_bookmark_by_tag(tag)
   end
 end
 
+def running_session_dirs
+  pids = `pgrep -x claude 2>/dev/null`.split.map(&:to_i)
+  dirs = Set.new
+  pids.each do |pid|
+    cwd_link = "/proc/#{pid}/cwd"
+    next unless File.exist?(cwd_link)
+    begin
+      dirs << resolve_session_dir(File.readlink(cwd_link))
+    rescue Errno::EACCES
+    end
+  end
+  dirs
+end
+
 def list_bookmarks
   bookmarks = load_bookmarks
 
-  if bookmarks.empty?
+  if bookmarks['sessions'].empty?
     puts "No bookmarked sessions."
     puts
     puts "To bookmark a session, use '/bm tag1 tag2' in Claude Code."
     return
   end
 
-  items = bookmarks.map do |path, tags|
-    { path: path, tags: tags, exists: Dir.exist?(path) }
+  running = running_session_dirs
+
+  items = bookmarks['sessions'].map do |id, entry|
+    { id: id, path: entry['path'], tags: entry['tags'], exists: Dir.exist?(entry['path']),
+      running: running.include?(entry['path']) }
   end
 
   index = 0
-  puts "Select session (↑/↓/j/k move, Enter select, d delete, q quit):\n\n"
+  puts "Select session (\u2191/\u2193/j/k move, J/K reorder, Enter select, d delete, q quit):\n\n"
 
-  # Hide cursor
   print "\e[?25l"
 
   begin
     loop do
-      # Render list
       items.each_with_index do |item, i|
         print clear_line
         tag_str = cyan(item[:tags].join(', '))
         path_str = dim(item[:path])
-        missing = item[:exists] ? '' : red(' [NOT FOUND]')
-        line = "#{tag_str} → #{path_str}#{missing}"
+        status = if !item[:exists]
+                   red(' [NOT FOUND]')
+                 elsif item[:running]
+                   green(' ●')
+                 else
+                   ''
+                 end
+        line = "#{tag_str} \u2192 #{path_str}#{status}"
 
         if i == index
-          puts "▸ #{line}"
+          puts "\u25b8 #{line}"
         else
           puts "  #{line}"
         end
       end
 
-      # Move cursor back to start
       print "\e[#{items.size}A"
 
       key = read_key
@@ -234,27 +253,35 @@ def list_bookmarks
         index = (index - 1) % items.size
       when :down
         index = (index + 1) % items.size
+      when :move_up
+        if index > 0
+          items[index], items[index - 1] = items[index - 1], items[index]
+          index -= 1
+          rebuild_and_save(items)
+        end
+      when :move_down
+        if index < items.size - 1
+          items[index], items[index + 1] = items[index + 1], items[index]
+          index += 1
+          rebuild_and_save(items)
+        end
       when :delete
-        # Show confirmation
         old_size = items.size
-        print "\e[#{old_size}B"  # Move below list
+        print "\e[#{old_size}B"
         print clear_line
         print "Delete '#{items[index][:tags].join(', ')}'? (y/n) "
         confirm = $stdin.getch
         if confirm.downcase == 'y'
-          bookmarks.delete(items[index][:path])
-          save_bookmarks(bookmarks)
-          items.delete_at(index)
+          deleted = items.delete_at(index)
+          rebuild_and_save(items)
           index = [index, items.size - 1].min
           if items.empty?
-            # Clear list and confirmation line
             print "\e[#{old_size}A"
             (old_size + 1).times { print clear_line; puts }
             print "\e[#{old_size + 1}A"
             puts "All bookmarks deleted."
             return
           end
-          # Clear old list (one more line than new size)
           print clear_line
           print "\e[#{old_size}A"
           (old_size).times { print clear_line; puts }
@@ -264,30 +291,65 @@ def list_bookmarks
           print "\e[#{old_size}A"
         end
       when :enter
-        # Clear the menu
         (items.size).times { print clear_line; puts }
         print "\e[#{items.size}A"
 
         if items[index][:exists]
-          print "\e[?25h"  # Show cursor before exec
-          resume_session(items[index][:path])
+          print "\e[?25h"
+          resume_session(items[index][:id], items[index][:path])
         else
           puts red("Directory not found: #{items[index][:path]}")
         end
         return
       when :quit
-        # Clear the menu
         (items.size).times { print clear_line; puts }
         print "\e[#{items.size}A"
         return
       end
     end
   ensure
-    # Always show cursor
     print "\e[?25h"
   end
 end
 
+def rebuild_and_save(items)
+  sessions = {}
+  items.each { |item| sessions[item[:id]] = { 'path' => item[:path], 'tags' => item[:tags] } }
+  save_bookmarks({ 'version' => 2, 'sessions' => sessions })
+end
+
+def show_current_sessions
+  pids = `pgrep -x claude 2>/dev/null`.split.map(&:to_i)
+
+  if pids.empty?
+    puts "No Claude Code sessions currently running."
+    return
+  end
+
+  bookmarks = load_bookmarks
+
+  puts "Running sessions:\n\n"
+
+  pids.each do |pid|
+    cwd_link = "/proc/#{pid}/cwd"
+    next unless File.exist?(cwd_link)
+
+    begin
+      cwd = File.readlink(cwd_link)
+      session_dir = resolve_session_dir(cwd)
+      tags = find_tags_for_path(session_dir, bookmarks)
+      tag_str = tags.empty? ? dim('(no tags)') : green(tags.join(', '))
+
+      puts "  PID #{cyan(pid.to_s)}: #{session_dir}"
+      puts "         Tags: #{tag_str}"
+      puts
+    rescue Errno::EACCES
+      puts "  PID #{cyan(pid.to_s)}: #{dim('(permission denied)')}"
+      puts
+    end
+  end
+end
+
 def show_help
   puts <<~HELP
     CC - Claude Code Session Manager
@@ -322,20 +384,45 @@ def show_help
   HELP
 end
 
-def resume_session(path)
+def resume_session(session_id, path)
   unless Dir.exist?(path)
     puts "Error: Directory not found: #{path}"
     exit 1
   end
 
+  # Save resume breadcrumb so cc-bookmark can track session continuations
+  # (when context resets, Claude creates a new session ID)
+  bookmarks = load_bookmarks
+  entry = bookmarks['sessions'][session_id]
+  if entry && !session_id.start_with?('path:')
+    resume_dir = File.join(CONFIG_DIR, 'resumed')
+    FileUtils.mkdir_p(resume_dir)
+    File.write(File.join(resume_dir, "#{session_id}.json"), entry['tags'].to_json)
+  end
+
   Dir.chdir(path) do
+    # Emit OSC 7 so wezterm knows the new cwd (for Alt+n, etc.)
+    host = `hostname`.strip
+    print "\033]7;file://#{host}#{path}\007"
     puts "Resuming session in: #{path}"
-    # Use -c to continue most recent session in this directory (no picker)
-    exec('claude', '-c')
+
+    # Export session info so cc-bookmark/hooks can reliably identify this session
+    ENV['CC_SESSION_ID'] = session_id
+    tags = entry ? entry['tags'].join(',') : ''
+    ENV['CC_RESUME_TAGS'] = tags unless tags.empty?
+
+    if session_id.start_with?('path:')
+      exec('claude', '-c')
+    else
+      exec('claude', '--resume', session_id)
+    end
   end
 end
 
 def continue_or_start
+  # Emit OSC 7 so wezterm knows the cwd
+  host = `hostname`.strip
+  print "\033]7;file://#{host}#{Dir.pwd}\007"
   if session_exists_in_dir?(Dir.pwd)
     exec('claude', '-c')
   else
@@ -365,19 +452,19 @@ when nil
   continue_or_start
 else
   tag = ARGV[0]
-  path = find_session_by_tag(tag)
+  match = find_session_by_tag(tag)
 
-  if path
-    resume_session(path)
+  if match
+    resume_session(match[:id], match[:path])
   else
     puts "No session found with tag '#{tag}'"
     puts
     puts "Available tags:"
     bookmarks = load_bookmarks
-    if bookmarks.empty?
+    if bookmarks['sessions'].empty?
       puts "  (none - use '/bm tag1 tag2' in Claude Code to bookmark)"
     else
-      all_tags = bookmarks.values.flatten.uniq.sort
+      all_tags = bookmarks['sessions'].values.flat_map { |e| e['tags'] }.uniq.sort
       all_tags.each { |t| puts "  #{t}" }
     end
     exit 1

data/bin/cc-bookmark

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 # CC-Bookmark - Helper script for /bm command
-# Bookmarks the current directory with tags
+# Bookmarks the current directory with tags, keyed by session ID
 
 require 'json'
 require 'fileutils'
@@ -10,10 +10,9 @@ require 'fileutils'
 CONFIG_DIR = File.expand_path('~/.cc-sessions')
 BOOKMARKS_FILE = File.join(CONFIG_DIR, 'bookmarks.json')
 CLAUDE_PROJECTS = File.expand_path('~/.claude/projects')
+RESUME_DIR = File.join(CONFIG_DIR, 'resumed')
 
 def resolve_session_dir(cwd)
-  # Find the original session directory by checking ~/.claude/projects/
-  # Claude encodes project paths as /foo/bar -> -foo-bar
   path = cwd
   loop do
     encoded = path.gsub('/', '-')
@@ -25,26 +24,156 @@ def resolve_session_dir(cwd)
   cwd
 end
 
-FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+def detect_session_id(session_dir, exclude_id: nil)
+  encoded = session_dir.gsub('/', '-')
+  project_dir = File.join(CLAUDE_PROJECTS, encoded)
+  return nil unless Dir.exist?(project_dir)
+
+  candidates = Dir.glob(File.join(project_dir, '*.jsonl'))
+                   .select { |f| File.file?(f) }
+  candidates.reject! { |f| File.basename(f, '.jsonl') == exclude_id } if exclude_id
+
+  newest = candidates.max_by { |f| File.mtime(f) }
+  return nil unless newest
+
+  File.basename(newest, '.jsonl')
+end
+
+# Find all session IDs in the same project directory
+def sibling_session_ids(session_dir)
+  encoded = session_dir.gsub('/', '-')
+  project_dir = File.join(CLAUDE_PROJECTS, encoded)
+  return [] unless Dir.exist?(project_dir)
+
+  Dir.glob(File.join(project_dir, '*.jsonl'))
+     .select { |f| File.file?(f) }
+     .map { |f| File.basename(f, '.jsonl') }
+end
+
+# Check resume breadcrumbs left by `cc` to find tags for a continued session.
+# When `cc <tag>` resumes a session that later gets a new ID (context reset),
+# the breadcrumb links the old session ID to its tags.
+def find_resume_breadcrumb(session_dir, current_id, bookmarks)
+  return nil unless Dir.exist?(RESUME_DIR)
 
-bookmarks = if File.exist?(BOOKMARKS_FILE)
-              JSON.parse(File.read(BOOKMARKS_FILE))
-            else
-              {}
-            end
+  siblings = sibling_session_ids(session_dir)
+  siblings.each do |sid|
+    next if sid == current_id
+    breadcrumb = File.join(RESUME_DIR, "#{sid}.json")
+    next unless File.exist?(breadcrumb)
 
+    tags = JSON.parse(File.read(breadcrumb))
+    return [sid, tags] if tags.is_a?(Array)
+  end
+  nil
+rescue
+  nil
+end
+
+def load_bookmarks
+  return { 'version' => 2, 'sessions' => {} } unless File.exist?(BOOKMARKS_FILE)
+
+  data = JSON.parse(File.read(BOOKMARKS_FILE))
+  if data['version']
+    data
+  else
+    migrate_bookmarks(data)
+  end
+rescue JSON::ParserError
+  { 'version' => 2, 'sessions' => {} }
+end
+
+def migrate_bookmarks(old_data)
+  sessions = {}
+  old_data.each do |path, tags|
+    sid = detect_session_id(path)
+    key = sid || "path:#{path}"
+    sessions[key] = { 'path' => path, 'tags' => tags }
+  end
+  new_data = { 'version' => 2, 'sessions' => sessions }
+  save_bookmarks(new_data)
+  new_data
+end
+
+def save_bookmarks(bookmarks)
+  FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+  File.write(BOOKMARKS_FILE, JSON.pretty_generate(bookmarks))
+end
+
+FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+
+bookmarks = load_bookmarks
 cwd = resolve_session_dir(Dir.pwd)
+original_id = ENV['CC_SESSION_ID']  # Set by `cc` wrapper — reliable
+session_id = detect_session_id(cwd) # Fallback — picks newest .jsonl
 tags = ARGV
 
 if tags.empty?
-  if bookmarks[cwd]
-    puts "Current bookmark: #{bookmarks[cwd].join(', ')}"
+  # Query mode: show tags for current session
+  # Priority: check the known original session ID first (from env var)
+  if original_id
+    entry = bookmarks['sessions'][original_id]
+    if entry
+      # Session ID hasn't changed, or bookmark is still on the original ID
+      puts "Current bookmark: #{entry['tags'].join(', ')}"
+    else
+      # Session ID changed (compaction/context reset).
+      # The bookmark is on the original ID but CC created a new session.
+      # Check if we have tags from env var or breadcrumb.
+      resume_tags = ENV['CC_RESUME_TAGS']&.split(',')
+      breadcrumb_file = File.join(RESUME_DIR, "#{original_id}.json")
+      if resume_tags.nil? && File.exist?(breadcrumb_file)
+        resume_tags = JSON.parse(File.read(breadcrumb_file)) rescue nil
+      end
+
+      if resume_tags
+        # Find the NEW session ID (newest .jsonl excluding the original)
+        new_id = detect_session_id(cwd, exclude_id: original_id)
+        if new_id
+          # Don't overwrite if the target session already has a bookmark
+          existing = bookmarks['sessions'][new_id]
+          if existing
+            puts "Current bookmark: #{existing['tags'].join(', ')}"
+          else
+            bookmarks['sessions'][new_id] = { 'path' => cwd, 'tags' => resume_tags }
+            save_bookmarks(bookmarks)
+            FileUtils.rm_f(breadcrumb_file)
+            puts "Current bookmark: #{resume_tags.join(', ')}"
+          end
+        else
+          puts "No bookmark for this session. Usage: /bm tag1 tag2 ..."
+        end
+      else
+        puts "No bookmark for this session. Usage: /bm tag1 tag2 ..."
+      end
+    end
+  elsif session_id
+    entry = bookmarks['sessions'][session_id]
+    if entry
+      puts "Current bookmark: #{entry['tags'].join(', ')}"
+    else
+      # Fallback: check resume breadcrumbs (legacy behavior, no env var)
+      match = find_resume_breadcrumb(cwd, session_id, bookmarks)
+      if match
+        old_id, old_tags = match
+        bookmarks['sessions'].delete(old_id)
+        bookmarks['sessions'][session_id] = { 'path' => cwd, 'tags' => old_tags }
+        save_bookmarks(bookmarks)
+        FileUtils.rm_f(File.join(RESUME_DIR, "#{old_id}.json"))
+        puts "Current bookmark: #{old_tags.join(', ')}"
+      else
+        puts "No bookmark for this session. Usage: /bm tag1 tag2 ..."
+      end
+    end
   else
-    puts "No bookmark for this directory. Usage: /bm tag1 tag2 ..."
+    puts "Could not detect session ID. Usage: /bm tag1 tag2 ..."
   end
 else
-  bookmarks[cwd] = tags
-  File.write(BOOKMARKS_FILE, JSON.pretty_generate(bookmarks))
+  # Bookmark mode: set tags for current session
+  # Prefer env var session ID, then detected, then path-based
+  key = original_id || session_id || "path:#{cwd}"
+  bookmarks['sessions'][key] = { 'path' => cwd, 'tags' => tags }
+  save_bookmarks(bookmarks)
   puts "Bookmarked: #{cwd}"
   puts "Tags: #{tags.join(', ')}"
   puts ""

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: cc-sessions
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-10 00:00:00.000000000 Z
+date: 2026-02-27 00:00:00.000000000 Z
 dependencies: []
-description: A simple tool for bookmarking and resuming Claude Code sessions. Tag
+description: 'A simple tool for bookmarking and resuming Claude Code sessions. Tag
   sessions with meaningful names using /bm inside Claude Code, then quickly resume
-  them with 'cc <tag>' from anywhere.
+  them with ''cc <tag>'' from anywhere. v1.3.0: Running session indicator, resume
+  breadcrumbs, env-var session tracking.'
 email:
 - g@isene.com
 executables: