panopticon-cli 0.4.31 → 0.4.33

package/scripts/record-cost-event.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 // scripts/record-cost-event.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, openSync, readSync, fstatSync, closeSync } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, openSync, readSync, fstatSync, closeSync } from "fs";
+import { execFileSync } from "child_process";
+import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/lib/cost.ts
@@ -22,6 +23,7 @@ var BIN_DIR = join(PANOPTICON_HOME, "bin");
 var BACKUPS_DIR = join(PANOPTICON_HOME, "backups");
 var COSTS_DIR = join(PANOPTICON_HOME, "costs");
 var HEARTBEATS_DIR = join(PANOPTICON_HOME, "heartbeats");
+var ARCHIVES_DIR = join(PANOPTICON_HOME, "archives");
 var TRAEFIK_DIR = join(PANOPTICON_HOME, "traefik");
 var TRAEFIK_DYNAMIC_DIR = join(TRAEFIK_DIR, "dynamic");
 var TRAEFIK_CERTS_DIR = join(TRAEFIK_DIR, "certs");
@@ -29,36 +31,16 @@ var CERTS_DIR = join(PANOPTICON_HOME, "certs");
 var CONFIG_FILE = join(CONFIG_DIR, "config.toml");
 var SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
 var CLAUDE_DIR = join(homedir(), ".claude");
-var CODEX_DIR = join(homedir(), ".codex");
-var CURSOR_DIR = join(homedir(), ".cursor");
-var GEMINI_DIR = join(homedir(), ".gemini");
-var OPENCODE_DIR = join(homedir(), ".opencode");
-var SYNC_TARGETS = {
-  claude: {
-    skills: join(CLAUDE_DIR, "skills"),
-    commands: join(CLAUDE_DIR, "commands"),
-    agents: join(CLAUDE_DIR, "agents")
-  },
-  codex: {
-    skills: join(CODEX_DIR, "skills"),
-    commands: join(CODEX_DIR, "commands"),
-    agents: join(CODEX_DIR, "agents")
-  },
-  cursor: {
-    skills: join(CURSOR_DIR, "skills"),
-    commands: join(CURSOR_DIR, "commands"),
-    agents: join(CURSOR_DIR, "agents")
-  },
-  gemini: {
-    skills: join(GEMINI_DIR, "skills"),
-    commands: join(GEMINI_DIR, "commands"),
-    agents: join(GEMINI_DIR, "agents")
-  },
-  opencode: {
-    skills: join(OPENCODE_DIR, "skills"),
-    commands: join(OPENCODE_DIR, "commands"),
-    agents: join(OPENCODE_DIR, "agents")
-  }
+var LEGACY_RUNTIME_DIRS = {
+  codex: join(homedir(), ".codex"),
+  cursor: join(homedir(), ".cursor"),
+  gemini: join(homedir(), ".gemini"),
+  opencode: join(homedir(), ".opencode")
+};
+var SYNC_TARGET = {
+  skills: join(CLAUDE_DIR, "skills"),
+  commands: join(CLAUDE_DIR, "commands"),
+  agents: join(CLAUDE_DIR, "agents")
 };
 var TEMPLATES_DIR = join(PANOPTICON_HOME, "templates");
 var CLAUDE_MD_TEMPLATES = join(TEMPLATES_DIR, "claude-md", "sections");
@@ -75,6 +57,15 @@ var SOURCE_TRAEFIK_TEMPLATES = join(SOURCE_TEMPLATES_DIR, "traefik");
 var SOURCE_SCRIPTS_DIR = join(packageRoot, "scripts");
 var SOURCE_SKILLS_DIR = join(packageRoot, "skills");
 var SOURCE_DEV_SKILLS_DIR = join(packageRoot, "dev-skills");
+var SOURCE_AGENTS_DIR = join(packageRoot, "agents");
+var SOURCE_RULES_DIR = join(packageRoot, "rules");
+var CACHE_AGENTS_DIR = join(PANOPTICON_HOME, "agent-definitions");
+var CACHE_RULES_DIR = join(PANOPTICON_HOME, "rules");
+var CACHE_MANIFEST = join(PANOPTICON_HOME, ".manifest.json");
+var DOCS_DIR = join(PANOPTICON_HOME, "docs");
+var PRDS_DIR = join(DOCS_DIR, "prds");
+var PRD_DRAFTS_DIR = join(PRDS_DIR, "drafts");
+var PRD_PUBLISHED_DIR = join(PRDS_DIR, "published");
 
 // src/lib/cost.ts
 var DEFAULT_PRICING = [
@@ -162,26 +153,118 @@ function appendCostEvent(event2) {
   appendFileSync(getEventsFile(), line, "utf-8");
 }
 
+// src/lib/tldr-daemon.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { existsSync as existsSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { join as join4 } from "path";
+function getTldrMetrics(workspacePath, sinceCheckpoint = false) {
+  const tldrDir = join4(workspacePath, ".tldr");
+  const interceptionsLog = join4(tldrDir, "interceptions.log");
+  const bypassesLog = join4(tldrDir, "bypasses.log");
+  const checkpointFile = join4(tldrDir, "metrics-checkpoint.json");
+  let interceptionsStartLine = 0;
+  let bypassesStartLine = 0;
+  if (sinceCheckpoint && existsSync2(checkpointFile)) {
+    try {
+      const checkpoint = JSON.parse(readFileSync2(checkpointFile, "utf-8"));
+      interceptionsStartLine = checkpoint.interceptionsLine || 0;
+      bypassesStartLine = checkpoint.bypassesLine || 0;
+    } catch {
+    }
+  }
+  const allInterceptionLines = existsSync2(interceptionsLog) ? readFileSync2(interceptionsLog, "utf-8").split("\n").filter((l) => l.trim()) : [];
+  const newInterceptions = allInterceptionLines.slice(interceptionsStartLine);
+  let estimatedTokensSaved = 0;
+  const filesAnalyzed = [];
+  for (const line of newInterceptions) {
+    const parts = line.trim().split(" ");
+    if (parts.length >= 3) {
+      const fileSizeBytes = parseInt(parts[1], 10) || 0;
+      const relPath = parts.slice(2).join(" ");
+      const fullTokens = Math.round(fileSizeBytes / 4);
+      estimatedTokensSaved += Math.max(0, fullTokens - 1e3);
+      if (relPath && !filesAnalyzed.includes(relPath)) {
+        filesAnalyzed.push(relPath);
+      }
+    }
+  }
+  const allBypassLines = existsSync2(bypassesLog) ? readFileSync2(bypassesLog, "utf-8").split("\n").filter((l) => l.trim()) : [];
+  const newBypasses = allBypassLines.slice(bypassesStartLine);
+  const bypassReasons = {};
+  for (const line of newBypasses) {
+    const parts = line.trim().split(" ");
+    if (parts.length >= 2) {
+      const reason = parts[1];
+      bypassReasons[reason] = (bypassReasons[reason] || 0) + 1;
+    }
+  }
+  return {
+    interceptions: newInterceptions.length,
+    bypasses: newBypasses.length,
+    estimatedTokensSaved,
+    filesAnalyzed,
+    bypassReasons
+  };
+}
+function captureTldrMetrics(workspacePath) {
+  const tldrDir = join4(workspacePath, ".tldr");
+  if (!existsSync2(tldrDir)) {
+    return null;
+  }
+  const metrics = getTldrMetrics(workspacePath, true);
+  const interceptionsLog = join4(tldrDir, "interceptions.log");
+  const bypassesLog = join4(tldrDir, "bypasses.log");
+  const checkpointFile = join4(tldrDir, "metrics-checkpoint.json");
+  const interceptionsTotal = existsSync2(interceptionsLog) ? readFileSync2(interceptionsLog, "utf-8").split("\n").filter((l) => l.trim()).length : 0;
+  const bypassesTotal = existsSync2(bypassesLog) ? readFileSync2(bypassesLog, "utf-8").split("\n").filter((l) => l.trim()).length : 0;
+  const checkpoint = {
+    interceptionsLine: interceptionsTotal,
+    bypassesLine: bypassesTotal,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    writeFileSync2(checkpointFile, JSON.stringify(checkpoint, null, 2), "utf-8");
+  } catch {
+  }
+  return metrics;
+}
+var execAsync = promisify(exec);
+var TLDR_STATE_DIR = join4(PANOPTICON_HOME, "tldr");
+
 // scripts/record-cost-event.ts
 var event;
 try {
-  const input = readFileSync2(0, "utf-8");
+  const input = readFileSync3(0, "utf-8");
   event = JSON.parse(input);
 } catch {
   process.exit(0);
 }
 var transcriptPath = event?.transcript_path;
-if (!transcriptPath || !existsSync2(transcriptPath)) {
+if (!transcriptPath || !existsSync3(transcriptPath)) {
   process.exit(0);
 }
 var sessionId = event?.session_id || "unknown";
-var stateDir = join4(process.env.HOME || homedir3(), ".panopticon", "costs", "state");
-mkdirSync2(stateDir, { recursive: true });
-var stateFile = join4(stateDir, `${sessionId}.offset`);
+var stateDir = join5(process.env.HOME || homedir3(), ".panopticon", "costs", "state");
+mkdirSync3(stateDir, { recursive: true });
+var stateFile = join5(stateDir, `${sessionId}.offset`);
 var lastOffset = 0;
-if (existsSync2(stateFile)) {
+if (existsSync3(stateFile)) {
   try {
-    lastOffset = parseInt(readFileSync2(stateFile, "utf-8").trim(), 10) || 0;
+    lastOffset = parseInt(readFileSync3(stateFile, "utf-8").trim(), 10) || 0;
+  } catch {
+  }
+}
+var seenFile = join5(stateDir, `${sessionId}.seen`);
+var seenRequestIds = /* @__PURE__ */ new Set();
+if (existsSync3(seenFile)) {
+  try {
+    const seenContent = readFileSync3(seenFile, "utf-8").trim();
+    if (seenContent) {
+      for (const id of seenContent.split("\n")) {
+        if (id.trim()) seenRequestIds.add(id.trim());
+      }
+    }
   } catch {
   }
 }
@@ -194,7 +277,7 @@ try {
 var stat = fstatSync(fd);
 if (stat.size <= lastOffset) {
   closeSync(fd);
-  writeFileSync2(stateFile, String(stat.size), "utf-8");
+  writeFileSync3(stateFile, String(stat.size), "utf-8");
   process.exit(0);
 }
 var bytesToRead = stat.size - lastOffset;
@@ -204,8 +287,38 @@ closeSync(fd);
 var newContent = buffer.toString("utf-8");
 var lines = newContent.split("\n");
 var agentId = process.env.PANOPTICON_AGENT_ID || "unattributed";
-var issueId = process.env.PANOPTICON_ISSUE_ID || "UNKNOWN";
+var issueId = process.env.PANOPTICON_ISSUE_ID || "";
 var sessionType = process.env.PANOPTICON_SESSION_TYPE || "implementation";
+if (!issueId || issueId === "UNKNOWN") {
+  try {
+    const branch = execFileSync("git", ["branch", "--show-current"], {
+      encoding: "utf-8",
+      timeout: 2e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branchMatch = branch.match(/(pan|min|aud)[-](\d+)/i);
+    if (branchMatch) {
+      issueId = `${branchMatch[1].toUpperCase()}-${branchMatch[2]}`;
+    }
+  } catch {
+  }
+}
+if (!issueId) {
+  issueId = "UNKNOWN";
+}
+var tldrMetrics = null;
+try {
+  const workspaceRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    encoding: "utf-8",
+    timeout: 2e3,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+  if (workspaceRoot) {
+    tldrMetrics = captureTldrMetrics(workspaceRoot);
+  }
+} catch {
+}
+var tldrAttachedToFirstEvent = false;
 for (const line of lines) {
   if (!line.trim()) continue;
   try {
@@ -213,6 +326,13 @@ for (const line of lines) {
     if (entry.type !== "assistant" || !entry.message?.usage) {
       continue;
     }
+    const requestId = entry.requestId;
+    if (requestId) {
+      if (seenRequestIds.has(requestId)) {
+        continue;
+      }
+      seenRequestIds.add(requestId);
+    }
     const usage = entry.message.usage;
     const model = entry.message.model || "claude-sonnet-4";
     const inputTokens = usage.input_tokens || 0;
@@ -237,6 +357,15 @@ for (const line of lines) {
       cacheWriteTokens,
       cacheTTL: "5m"
     }, pricing);
+    const tldrFields = tldrMetrics && !tldrAttachedToFirstEvent && tldrMetrics.interceptions + tldrMetrics.bypasses > 0 ? {
+      tldrInterceptions: tldrMetrics.interceptions,
+      tldrBypasses: tldrMetrics.bypasses,
+      tldrTokensSaved: tldrMetrics.estimatedTokensSaved,
+      tldrBypassReasons: Object.keys(tldrMetrics.bypassReasons).length > 0 ? tldrMetrics.bypassReasons : void 0
+    } : {};
+    if (tldrMetrics && !tldrAttachedToFirstEvent) {
+      tldrAttachedToFirstEvent = true;
+    }
     appendCostEvent({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "cost",
@@ -249,10 +378,15 @@ for (const line of lines) {
       output: outputTokens,
       cacheRead: cacheReadTokens,
       cacheWrite: cacheWriteTokens,
-      cost
+      cost,
+      ...requestId ? { requestId } : {},
+      ...tldrFields
     });
   } catch {
   }
 }
-writeFileSync2(stateFile, String(stat.size), "utf-8");
+writeFileSync3(stateFile, String(stat.size), "utf-8");
+if (seenRequestIds.size > 0) {
+  writeFileSync3(seenFile, Array.from(seenRequestIds).join("\n") + "\n", "utf-8");
+}
 process.exit(0);

package/scripts/record-cost-event.ts

@@ -12,10 +12,12 @@
  */
 
 import { readFileSync, existsSync, writeFileSync, mkdirSync, openSync, readSync, fstatSync, closeSync } from 'fs';
+import { execFileSync } from 'child_process';
 import { join } from 'path';
 import { homedir } from 'os';
 import { calculateCost, getPricing, AIProvider } from '../src/lib/cost.js';
 import { appendCostEvent } from '../src/lib/costs/events.js';
+import { captureTldrMetrics, type TldrSessionMetrics } from '../src/lib/tldr-daemon.js';
 
 // ============== Types ==============
 
@@ -73,6 +75,21 @@ if (existsSync(stateFile)) {
   } catch { /* start from 0 */ }
 }
 
+// Load persisted seen requestIds to guard against crash-before-write duplicates (PAN-238)
+// Claude Code's transcript can have multiple entries per requestId — we emit exactly one event per requestId.
+const seenFile = join(stateDir, `${sessionId}.seen`);
+const seenRequestIds = new Set<string>();
+if (existsSync(seenFile)) {
+  try {
+    const seenContent = readFileSync(seenFile, 'utf-8').trim();
+    if (seenContent) {
+      for (const id of seenContent.split('\n')) {
+        if (id.trim()) seenRequestIds.add(id.trim());
+      }
+    }
+  } catch { /* start fresh */ }
+}
+
 // Read only NEW content from the transcript (efficient for large files)
 let fd: number;
 try {
@@ -97,12 +114,49 @@ closeSync(fd);
 const newContent = buffer.toString('utf-8');
 const lines = newContent.split('\n');
 
-// Get agent/issue context from environment
+// Get agent/issue context from environment, with git branch fallback
 const agentId: string = process.env.PANOPTICON_AGENT_ID || 'unattributed';
-const issueId: string = process.env.PANOPTICON_ISSUE_ID || 'UNKNOWN';
+let issueId: string = process.env.PANOPTICON_ISSUE_ID || '';
 const sessionType: string = process.env.PANOPTICON_SESSION_TYPE || 'implementation';
 
+// Infer issue ID from git branch if not set (covers ad-hoc Claude sessions)
+if (!issueId || issueId === 'UNKNOWN') {
+  try {
+    const branch = execFileSync('git', ['branch', '--show-current'], {
+      encoding: 'utf-8',
+      timeout: 2000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    const branchMatch = branch.match(/(pan|min|aud)[-](\d+)/i);
+    if (branchMatch) {
+      issueId = `${branchMatch[1].toUpperCase()}-${branchMatch[2]}`;
+    }
+  } catch {
+    // Git not available or not in a repo — that's fine
+  }
+}
+
+// Final fallback
+if (!issueId) {
+  issueId = 'UNKNOWN';
+}
+
+// Capture TLDR metrics for this batch (PAN-236)
+// Find workspace root via git (same process already used for branch detection above)
+let tldrMetrics: TldrSessionMetrics | null = null;
+try {
+  const workspaceRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf-8',
+    timeout: 2000,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+  if (workspaceRoot) {
+    tldrMetrics = captureTldrMetrics(workspaceRoot);
+  }
+} catch { /* git not available or no workspace — skip TLDR metrics */ }
+
 // Process new transcript lines looking for assistant messages with usage
+let tldrAttachedToFirstEvent = false;
 for (const line of lines) {
   if (!line.trim()) continue;
 
@@ -114,6 +168,15 @@ for (const line of lines) {
       continue;
     }
 
+    // Skip already-seen requestIds — transcript has multiple entries per API request (PAN-238)
+    const requestId = entry.requestId;
+    if (requestId) {
+      if (seenRequestIds.has(requestId)) {
+        continue; // Duplicate entry for this request — already emitted a cost event
+      }
+      seenRequestIds.add(requestId);
+    }
+
     const usage = entry.message.usage;
     const model: string = entry.message.model || 'claude-sonnet-4';
 
@@ -147,6 +210,22 @@ for (const line of lines) {
       cacheTTL: '5m',
     }, pricing);
 
+    // Attach TLDR metrics to the first event in each batch (delta since last batch)
+    const tldrFields = tldrMetrics && !tldrAttachedToFirstEvent && tldrMetrics.interceptions + tldrMetrics.bypasses > 0
+      ? {
+          tldrInterceptions: tldrMetrics.interceptions,
+          tldrBypasses: tldrMetrics.bypasses,
+          tldrTokensSaved: tldrMetrics.estimatedTokensSaved,
+          tldrBypassReasons: Object.keys(tldrMetrics.bypassReasons).length > 0
+            ? tldrMetrics.bypassReasons
+            : undefined,
+        }
+      : {};
+
+    if (tldrMetrics && !tldrAttachedToFirstEvent) {
+      tldrAttachedToFirstEvent = true;
+    }
+
     // Record the cost event
     appendCostEvent({
       ts: new Date().toISOString(),
@@ -161,13 +240,18 @@ for (const line of lines) {
       cacheRead: cacheReadTokens,
       cacheWrite: cacheWriteTokens,
       cost,
+      ...(requestId ? { requestId } : {}),
+      ...tldrFields,
     });
   } catch {
     // Skip malformed lines silently
   }
 }
 
-// Save new byte offset for next invocation
+// Save new byte offset and seen requestIds for next invocation
 writeFileSync(stateFile, String(stat.size), 'utf-8');
+if (seenRequestIds.size > 0) {
+  writeFileSync(seenFile, Array.from(seenRequestIds).join('\n') + '\n', 'utf-8');
+}
 
 process.exit(0);

package/scripts/statusline.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# Claude Code status line — all available info + plan usage limits
+# JSON is piped via stdin on each update
+
+input=$(cat)
+
+# Single jq call to extract all fields at once
+eval "$(echo "$input" | jq -r '
+  @sh "model=\(.model.display_name // "")",
+  @sh "model_id=\(.model.id // "")",
+  @sh "current_dir=\(.workspace.current_dir // "")",
+  @sh "project_dir=\(.workspace.project_dir // "")",
+  @sh "cost=\(.cost.total_cost_usd // 0)",
+  @sh "lines_added=\(.cost.total_lines_added // 0)",
+  @sh "lines_removed=\(.cost.total_lines_removed // 0)",
+  @sh "ctx_used_pct=\(.context_window.used_percentage // 0)",
+  @sh "ctx_size=\(.context_window.context_window_size // 0)",
+  @sh "ctx_in=\(.context_window.current_usage.input_tokens // 0)",
+  @sh "ctx_out=\(.context_window.current_usage.output_tokens // 0)"
+' 2>/dev/null)"
+
+# ANSI colors
+RST='\033[0m'; DIM='\033[2m'
+CYN='\033[36m'; GRN='\033[32m'; YLW='\033[33m'
+MAG='\033[35m'; RED='\033[31m'; WHT='\033[37m'
+
+# Helper: format token count
+fmt() {
+  local n=${1:-0}
+  if (( n >= 1000000 )); then printf "%.1fM" "$(echo "scale=1;$n/1000000" | bc)"
+  elif (( n >= 1000 )); then printf "%.1fk" "$(echo "scale=1;$n/1000" | bc)"
+  else echo "$n"; fi
+}
+
+# Helper: color a percentage (green < 50, yellow < 80, red >= 80)
+pct_color() {
+  local pct_int=${1%.*}
+  if (( ${pct_int:-0} >= 80 )); then echo "$RED"
+  elif (( ${pct_int:-0} >= 50 )); then echo "$YLW"
+  else echo "$GRN"; fi
+}
+
+# Helper: format time remaining from ISO timestamp
+time_remaining() {
+  local reset_at="$1"
+  [ -z "$reset_at" ] || [ "$reset_at" = "null" ] && return
+  local reset_epoch now_epoch diff_s hours mins
+  reset_epoch=$(date -d "$reset_at" +%s 2>/dev/null) || return
+  now_epoch=$(date +%s)
+  diff_s=$(( reset_epoch - now_epoch ))
+  (( diff_s <= 0 )) && { echo "now"; return; }
+  hours=$(( diff_s / 3600 ))
+  mins=$(( (diff_s % 3600) / 60 ))
+  if (( hours > 0 )); then echo "${hours}h${mins}m"
+  else echo "${mins}m"; fi
+}
+
+# --- Usage limits (cached for 60s) ---
+CACHE_FILE="/tmp/.claude-usage-cache-$(id -u)"
+CACHE_TTL=60
+usage_5h="" usage_7d="" reset_5h="" reset_7d=""
+
+fetch_usage() {
+  local creds_file="$HOME/.claude/.credentials.json"
+  [ -f "$creds_file" ] || return
+  local token
+  token=$(jq -r '.claudeAiOauth.accessToken // empty' "$creds_file" 2>/dev/null)
+  [ -z "$token" ] && return
+  local response
+  response=$(curl -sf --max-time 3 \
+    -H "Accept: application/json" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer $token" \
+    -H "anthropic-beta: oauth-2025-04-20" \
+    "https://api.anthropic.com/api/oauth/usage" 2>/dev/null) || return
+  echo "$response" > "$CACHE_FILE"
+}
+
+# Use cache if fresh, otherwise fetch in background
+if [ -f "$CACHE_FILE" ]; then
+  cache_age=$(( $(date +%s) - $(stat -c %Y "$CACHE_FILE" 2>/dev/null || echo 0) ))
+  if (( cache_age > CACHE_TTL )); then
+    # Fetch in background so we don't block the statusline
+    fetch_usage &
+  fi
+else
+  # First run — fetch synchronously (one-time cost)
+  fetch_usage
+fi
+
+# Read cached data
+if [ -f "$CACHE_FILE" ]; then
+  eval "$(jq -r '
+    @sh "usage_5h=\(.five_hour.utilization // "")",
+    @sh "reset_5h=\(.five_hour.resets_at // "")",
+    @sh "usage_7d=\(.seven_day.utilization // "")",
+    @sh "reset_7d=\(.seven_day.resets_at // "")"
+  ' "$CACHE_FILE" 2>/dev/null)"
+fi
+
+# Git branch (fast — reads file directly, no subprocess)
+git_branch=""
+dir="${current_dir:-.}"
+while [ "$dir" != "/" ]; do
+  if [ -f "$dir/.git/HEAD" ]; then
+    ref=$(< "$dir/.git/HEAD")
+    git_branch="${ref#ref: refs/heads/}"
+    break
+  fi
+  dir=$(dirname "$dir")
+done
+
+# Context % color
+ctx_color=$(pct_color "$ctx_used_pct")
+
+# Cost formatting
+cost_fmt=$(printf '$%.4f' "${cost:-0}")
+
+# Line 1: model | dir | git branch
+line1=""
+[ -n "$model" ] && line1+=$(printf "%b%s%b" "$MAG" "$model" "$RST")
+[ -n "$model_id" ] && line1+=$(printf " %b(%s)%b" "$DIM" "$model_id" "$RST")
+if [ -n "$current_dir" ]; then
+  short_dir="${current_dir/#$HOME/~}"
+  line1+=$(printf "  %b%s%b" "$CYN" "$short_dir" "$RST")
+fi
+[ -n "$git_branch" ] && line1+=$(printf "  %b%b%s%b" "$DIM" "$GRN" "$git_branch" "$RST")
+
+# Line 2: context usage | cost | lines changed
+line2=""
+line2+=$(printf "%bctx%b %b%.0f%%%b" "$DIM" "$RST" "$ctx_color" "$ctx_used_pct" "$RST")
+line2+=$(printf "  %b%s%b/%b%s%b" "$WHT" "$(fmt "$ctx_in")" "$RST" "$DIM" "$(fmt "$ctx_size")" "$RST")
+line2+=$(printf "  %bout%b %s" "$DIM" "$RST" "$(fmt "$ctx_out")")
+line2+=$(printf "  %bcost%b %b%s%b" "$DIM" "$RST" "$YLW" "$cost_fmt" "$RST")
+if (( lines_added > 0 || lines_removed > 0 )); then
+  line2+=$(printf "  %b+%d%b/%b-%d%b" "$GRN" "$lines_added" "$RST" "$RED" "$lines_removed" "$RST")
+fi
+
+# Line 3: plan usage limits (5h + 7d)
+line3=""
+if [ -n "$usage_5h" ]; then
+  u5_color=$(pct_color "$usage_5h")
+  u5_reset=$(time_remaining "$reset_5h")
+  line3+=$(printf "%b5h%b %b%.0f%%%b" "$DIM" "$RST" "$u5_color" "$usage_5h" "$RST")
+  [ -n "$u5_reset" ] && line3+=$(printf " %b(%s)%b" "$DIM" "$u5_reset" "$RST")
+fi
+if [ -n "$usage_7d" ]; then
+  u7_color=$(pct_color "$usage_7d")
+  u7_reset=$(time_remaining "$reset_7d")
+  [ -n "$line3" ] && line3+="  "
+  line3+=$(printf "%b7d%b %b%.0f%%%b" "$DIM" "$RST" "$u7_color" "$usage_7d" "$RST")
+  [ -n "$u7_reset" ] && line3+=$(printf " %b(%s)%b" "$DIM" "$u7_reset" "$RST")
+fi
+
+# Write context % to agent dir for dashboard monitoring (non-blocking)
+if [ -n "$PANOPTICON_AGENT_ID" ] && [ -n "$ctx_used_pct" ]; then
+  CTX_DIR="$HOME/.panopticon/agents/$PANOPTICON_AGENT_ID"
+  if [ -d "$CTX_DIR" ]; then
+    printf '%.0f' "$ctx_used_pct" > "$CTX_DIR/context-pct" 2>/dev/null || true
+    # Capture initial context % (first time only)
+    if [ ! -f "$CTX_DIR/initial-context-pct" ]; then
+      printf '%.0f' "$ctx_used_pct" > "$CTX_DIR/initial-context-pct" 2>/dev/null || true
+    fi
+  fi
+fi
+
+printf "%b\n" "$line1"
+printf "%b\n" "$line2"
+[ -n "$line3" ] && printf "%b\n" "$line3"

package/scripts/stop-hook

@@ -26,17 +26,20 @@ fi
 STATE_DIR="$HOME/.panopticon/agents/$AGENT_ID"
 mkdir -p "$STATE_DIR"
 
-# Write state to file (atomic write via temp file)
-TEMP_FILE="$STATE_DIR/state.json.tmp"
-jq -n \
-  --arg timestamp "$(date -Iseconds)" \
-  --arg state "idle" \
-  '{
-    state: $state,
-    lastActivity: $timestamp
-  }' > "$TEMP_FILE" 2>/dev/null || true
-
-mv "$TEMP_FILE" "$STATE_DIR/state.json" 2>/dev/null || true
+# Update runtime state in runtime.json (NOT state.json — state.json holds AgentState config
+# like workspace, runtime, model which must not be overwritten by hooks)
+RUNTIME_FILE="$STATE_DIR/runtime.json"
+TEMP_FILE="$RUNTIME_FILE.tmp"
+if [ -f "$RUNTIME_FILE" ]; then
+  # Merge with existing runtime state (preserves contextPercent, sessionId, etc.)
+  jq --arg ts "$(date -Iseconds)" \
+    '.state = "idle" | .lastActivity = $ts | del(.currentTool)' \
+    "$RUNTIME_FILE" > "$TEMP_FILE" 2>/dev/null && mv "$TEMP_FILE" "$RUNTIME_FILE" 2>/dev/null || true
+else
+  # Create initial runtime state
+  jq -n --arg ts "$(date -Iseconds)" \
+    '{state: "idle", lastActivity: $ts}' > "$TEMP_FILE" 2>/dev/null && mv "$TEMP_FILE" "$RUNTIME_FILE" 2>/dev/null || true
+fi
 
 # Optionally send heartbeat to API server (non-blocking)
 # Only if dashboard is running