@axplusb/kepler 2.2.0 → 2.3.1

package/src/terminal/repl.mjs

@@ -23,6 +23,7 @@ import { calculateCost, formatCostValue, formatTokens, costToCredits, formatCred
 import { TarangStreamClient, EVENT_TYPES } from '../core/stream-client.mjs';
 import { JsonlWriter } from '../core/jsonl-writer.mjs';
 import { createToolExecutor } from '../core/tool-executor.mjs';
+import { buildWorkScope } from '../core/work-scope.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { runPreflight } from '../onboarding/preflight.mjs';
@@ -47,7 +48,8 @@ import { loadProjectContext } from '../core/project-context-loader.mjs';
 import { buildContextEnvelope } from '../core/context-envelope.mjs';
 import { buildResumeHistory, combineResumeSummaries, getRecentSessions, getSessionDetail, getTranscriptProjectRoots } from '../core/local-store.mjs';
 import { decideResumeMode, projectedTokensForChoice, formatTokens as formatCtxTokens } from '../core/resume-mode.mjs';
-import { appendTask, ensureTaskFiles, loadTaskBoard, taskCounts, TASK_FILES } from '../core/tasks.mjs';
+import { appendTask, ensureTaskFiles, loadTaskBoard, moveTask, removeTask, taskCounts, TASK_FILES, updateTask } from '../core/tasks.mjs';
+import { applyCompactSummary, localCompactSummary, parseCompactTailCount, prepareCompactHistory } from '../core/compact-history.mjs';
 import { toolDisplayLabel, toolDisplaySummary } from './tool-display.mjs';
 import { createOrbit } from '../state/orbit.mjs';
 import { attachOrbit, unmount as unmountStatusBar } from '../ui/status-bar.mjs';
@@ -195,6 +197,18 @@ function formatResumeCheckpointStatus(session) {
   return c.dim(` · summarized${pct}`);
 }
 
+function formatResumeContextStatus(session) {
+  const full = formatCtxTokens(session?.contextTokens || 0);
+  const marker = session?.resumeSummary;
+  if (!marker || !Number(marker.sourceMessageCount)) {
+    return c.dim(`${full.padStart(5, ' ')} ctx`);
+  }
+  const resumable = formatCtxTokens(projectedTokensForChoice('checkpoint-full', session.contextTokens || 0, {
+    resumeSummary: marker,
+  }));
+  return c.dim(`${resumable.padStart(5, ' ')} resumable · ${full} full`) + formatResumeCheckpointStatus(session);
+}
+
 function formatRelativeTime(iso) {
   if (!iso) return '';
   const t = Date.parse(iso);
@@ -249,7 +263,7 @@ async function pickResumableSession(resumable, ctx) {
         const ago = formatRelativeTime(s.updatedAt || s.startedAt).padEnd(9, ' ').slice(0, 9);
         const status = endStatusMarker(s.endStatus);
         const msgs = String(s.messageCount).padStart(3, ' ') + ' msgs';
-        const ctx = c.dim(`${formatCtxTokens(s.contextTokens).padStart(5, ' ')} ctx`) + formatResumeCheckpointStatus(s);
+        const ctx = formatResumeContextStatus(s);
         const cost = formatSessionCost(s.costUsd);
         const partial = s.partial ? c.yellow(' ⚠partial') : '';
         const instr = oneLineInstruction(s.instruction, 48);
@@ -307,8 +321,14 @@ async function chooseThresholdMode(ctx, decision) {
   if (rl) rl.pause();
 
   const canFull = decision.mode !== 'no-full-allowed';
+  const hasCheckpoint = Boolean(decision.resumeSummary?.sourceMessageCount);
+  const firstOption = canFull
+    ? { key: 'f', value: 'full', label: 'full transcript', enabled: true }
+    : hasCheckpoint
+      ? { key: 'f', value: 'checkpoint-full', label: 'checkpointed transcript', enabled: true }
+      : { key: 'f', value: 'full', label: 'full transcript', enabled: false };
   const options = [
-    { key: 'f', value: 'full',    label: 'full transcript', enabled: canFull },
+    firstOption,
     { key: 's', value: 'summary', label: 'summary only',    enabled: true },
     { key: '1', value: 'tail-10', label: 'summary + last 10 turns', enabled: true },
     { key: '2', value: 'tail-20', label: 'summary + last 20 turns', enabled: true },
@@ -327,7 +347,8 @@ async function chooseThresholdMode(ctx, decision) {
       const projected = formatCtxTokens(decision.projected);
       const win = formatCtxTokens(decision.windowSize);
       const lines = [];
-      lines.push(`  This session would use  ${c.brand(`${projected} / ${win}`)} tokens  (${pct}%)`);
+      const rawLabel = hasCheckpoint ? 'Raw full transcript would use' : 'This session would use';
+      lines.push(`  ${rawLabel}  ${c.brand(`${projected} / ${win}`)} tokens  (${pct}%)`);
       if (decision.resumeSummary?.sourceMessageCount) {
         const covered = Number(decision.resumeSummary.sourceMessageCount) || 0;
         const full = Number(decision.resumeSummary.fullMessageCount) || 0;
@@ -336,14 +357,18 @@ async function chooseThresholdMode(ctx, decision) {
       }
       lines.push(canFull
         ? `  ${c.yellow('⚠')} ${c.dim('close to the highWatermark — consider a leaner mode:')}`
-        : `  ${c.red('⛔')} ${c.dim('over hardCap — full mode disabled:')}`);
+        : hasCheckpoint
+          ? `  ${c.yellow('⚠')} ${c.dim('raw full is over hardCap — checkpoint/tail modes are available:')}`
+          : `  ${c.red('⛔')} ${c.dim('over hardCap — full mode disabled:')}`);
       lines.push('');
       for (let i = 0; i < options.length; i++) {
         const o = options[i];
         const disabled = !o.enabled;
         const marker = i === selected && !disabled ? c.brand('▸') : ' ';
         const keyTag = c.dim('[') + (disabled ? c.dim(o.key) : c.brand(o.key)) + c.dim(']');
-        const proj = formatCtxTokens(projectedTokensForChoice(o.value, decision.projected));
+        const proj = formatCtxTokens(projectedTokensForChoice(o.value, decision.projected, {
+          resumeSummary: decision.resumeSummary,
+        }));
         const label = disabled ? c.dim(o.label) : (i === selected ? c.brand(o.label) : o.label);
         const projCol = c.dim(`${proj.padStart(5, ' ')} ctx`);
         const suffix = disabled ? c.dim('  (over hardCap)') : '';
@@ -388,6 +413,7 @@ async function chooseThresholdMode(ctx, decision) {
 }
 
 function resumeModeLabel(mode = 'full') {
+  if (mode === 'checkpoint-full') return 'checkpointed transcript';
   if (mode === 'summary') return 'summary only';
   const tailTurns = resumeTailTurnCount(mode);
   if (tailTurns) return `summary + last ${tailTurns} turns`;
@@ -433,7 +459,7 @@ async function previewResumeSession(session, ctx) {
       if (scrollOffset > maxOffset) scrollOffset = maxOffset;
 
       const lines = [];
-      lines.push(`  ${c.bold('Preview:')} ${c.brand(session.project || '(unknown)')}  ${c.dim('Mode:')} ${c.brand(resumeModeLabel(mode))}  ${c.dim(formatCtxTokens(projectedTokensForChoice(mode, session.contextTokens)) + ' ctx')}`);
+      lines.push(`  ${c.bold('Preview:')} ${c.brand(session.project || '(unknown)')}  ${c.dim('Mode:')} ${c.brand(resumeModeLabel(mode))}  ${c.dim(formatCtxTokens(projectedTokensForChoice(mode, session.contextTokens, { resumeSummary: session.resumeSummary })) + ' ctx')}`);
       lines.push(`  ${c.dim('─'.repeat(60))}`);
       for (let i = scrollOffset; i < Math.min(scrollOffset + rows, totalLines); i++) {
         lines.push(fitAnsiLine(`  ${c.dim(contentLines[i] || '')}`, cols - 1));
@@ -459,7 +485,7 @@ async function previewResumeSession(session, ctx) {
       if (key === '') { scrollOffset += 1; render(); return; }
       if (key === '[5~') { scrollOffset = Math.max(0, scrollOffset - 10); render(); return; }
       if (key === '[6~') { scrollOffset += 10; render(); return; }
-      if (low === 'f') { mode = 'full'; history = rich(); scrollOffset = 0; render(); return; }
+      if (low === 'f') { mode = session.resumeSummary?.sourceMessageCount ? 'checkpoint-full' : 'full'; history = rich(); scrollOffset = 0; render(); return; }
       if (low === 's') { mode = 'summary'; history = rich(); scrollOffset = 0; render(); return; }
       if (low === '1') { mode = 'tail-10'; history = rich(); scrollOffset = 0; render(); return; }
       if (low === '2') { mode = 'tail-20'; history = rich(); scrollOffset = 0; render(); return; }
@@ -658,6 +684,120 @@ async function summarizeResumeTranscript({
   }
 }
 
+async function compactCurrentSession(ctx, rest = '') {
+  const tailCount = parseCompactTailCount(rest, 8);
+  const preparedLive = prepareCompactHistory({
+    agentHistory: session.agentHistory,
+    tailCount,
+  });
+  if (!preparedLive.ok) {
+    process.stderr.write(`  ${c.gray(`Nothing to compact — ${preparedLive.reason}.`)}\n`);
+    return;
+  }
+
+  const progress = startResumeProgress('compact');
+  progress.update('preparing compact summary', 18);
+  let sourceMessages = preparedLive.sourceMessages;
+  let priorSummary = preparedLive.previousSummary || '';
+  let previousSourceMessageCount = 0;
+  let fullMessageCount = preparedLive.beforeCount;
+  let projectPath = safeCwd();
+  let sourceFrom = 'live';
+  let summaryWarning = '';
+
+  try {
+    if (session.id && ctx.jsonlWriter?.flush) {
+      progress.update('reading transcript checkpoint', 28);
+      await ctx.jsonlWriter.flush();
+      const detail = await getSessionDetail(session.id, { filePath: ctx.jsonlWriter.transcriptPath });
+      if (detail) {
+        const richHistory = buildResumeHistory({ ...detail, recapTailTurns: 8 }, `tail-${tailCount}`);
+        if (richHistory.sourceMessages?.length) {
+          sourceMessages = richHistory.sourceMessages;
+          priorSummary = richHistory.priorSummary || '';
+          previousSourceMessageCount = richHistory.summaryCheckpointMessageCount || 0;
+          fullMessageCount = richHistory.fullMessageCount || sourceMessages.length;
+          projectPath = detail.meta?.project || safeCwd();
+          sourceFrom = 'transcript';
+        } else if (richHistory.priorSummary) {
+          priorSummary = richHistory.priorSummary;
+          previousSourceMessageCount = richHistory.summaryCheckpointMessageCount || 0;
+          fullMessageCount = richHistory.fullMessageCount || preparedLive.beforeCount;
+        }
+      }
+    }
+
+    if (!sourceMessages.length) {
+      progress.stop();
+      process.stderr.write(`  ${c.gray('Nothing new to compact.')}\n`);
+      return;
+    }
+
+    progress.update('summarizing compacted history', 46);
+    const backendSummary = await summarizeResumeTranscript({
+      auth: ctx.auth,
+      toolExecutor: ctx.toolExecutor,
+      sessionId: session.id,
+      projectPath,
+      messages: sourceMessages,
+    });
+    let summarySource = backendSummary?.summary ? (backendSummary.source || 'backend') : 'local fallback';
+    let deltaSummary = backendSummary?.summary || '';
+    if (!deltaSummary) {
+      summaryWarning = backendSummary?.reason || 'backend summary unavailable';
+      deltaSummary = localCompactSummary(sourceMessages);
+    }
+    const summary = combineResumeSummaries(priorSummary, deltaSummary);
+
+    progress.update('rewriting live context', 74);
+    const applied = applyCompactSummary({
+      prepared: { ...preparedLive, sourceMessages },
+      summary,
+      sessionId: session.id,
+      cwd: projectPath,
+      originalRequest: session.history.find(m => m.role === 'user')?.content || session.lastTask || '',
+      previousSourceMessageCount,
+    });
+    session.agentHistory = applied.agentHistory;
+    session.compactSummary = summary;
+    session.compactSourceMessageCount = applied.sourceMessageCount;
+
+    if (ctx.jsonlWriter) {
+      progress.update('writing summary checkpoint', 88);
+      ctx.jsonlWriter.writeKeplerEvent({
+        type: 'resume_summary',
+        data: {
+          session_id: session.id || null,
+          mode: 'compact',
+          mode_label: '/compact',
+          summary,
+          summary_source: summarySource,
+          summary_warning: summaryWarning || null,
+          source: sourceFrom,
+          source_message_count: applied.sourceMessageCount,
+          previous_source_message_count: previousSourceMessageCount,
+          full_message_count: fullMessageCount,
+          retained_tail_messages: applied.retainedCount,
+          live_before_messages: applied.beforeCount,
+          live_after_messages: applied.afterCount,
+        },
+      });
+      await ctx.jsonlWriter.flush?.();
+    }
+
+    progress.stop();
+    process.stderr.write(
+      `  ${c.green('✓')} ${c.dim(`Compacted context: ${applied.beforeCount} → ${applied.afterCount} live messages · retained ${applied.retainedCount} · summary ${summarySource}`)}\n`
+    );
+    if (summaryWarning) {
+      process.stderr.write(`  ${c.yellow('⚠')} ${c.dim(`backend summary unavailable — used local summary (${summaryWarning})`)}\n`);
+    }
+  } catch (err) {
+    progress.stop();
+    process.stderr.write(`  ${c.red(`Compact failed: ${err?.message || String(err)}`)}\n`);
+  }
+}
+
 function resumeTailTurnCount(mode = '') {
   const match = String(mode || '').match(/^tail-(\d+)$/);
   if (!match) return null;
@@ -1121,12 +1261,26 @@ function printBanner(auth) {
  * Left side: last-turn summary (tools, time, cost)
  * Right side: session totals (ctx%, tokens)
  */
+function computeCacheTotals() {
+  let read = 0;
+  let write = 0;
+  for (const b of session.costBreakdown) {
+    read += b.cache_read_tokens || 0;
+    write += b.cache_creation_tokens || 0;
+  }
+  const denom = session.inputTokens + read;
+  const hitRate = denom > 0 ? Math.round((read / denom) * 100) : 0;
+  return { read, write, hitRate };
+}
+
 function buildContextStrip() {
   const totalTokens = session.inputTokens + session.outputTokens;
   const elapsed = formatElapsed(session.startTime);
+  const cache = computeCacheTotals();
 
   const right = [
     c.dim(`${formatTokens(totalTokens)} tok`),
+    ...(cache.read > 0 ? [c.dim(`cache ${cache.hitRate}%`)] : []),
     c.dim(elapsed),
   ].join(c.dim(' · '));
 
@@ -1209,10 +1363,12 @@ function updateStatusBar() {
 // buffered head as a regular two-line shape first so the interleaving
 // content lands below it.
 let _pendingHead = null; // { callId, head, indent }
+let _lastRenderedBlock = null; // 'tool' | 'content' | null
 
 function flushPendingHead() {
   if (!_pendingHead) return;
-  process.stderr.write(`\n${_pendingHead.head}\n`);
+  process.stderr.write(`${_pendingHead.head}\n`);
+  _lastRenderedBlock = 'tool';
   _pendingHead = null;
 }
 
@@ -1297,7 +1453,8 @@ function renderToolResult(data, eventType = 'tool_result') {
     const cols = process.stderr.columns || 120;
     const combined = `${_pendingHead.head}  ${outcome}`;
     if (stripAnsi(combined).length <= cols) {
-      process.stderr.write(`\n${combined}\n`);
+      process.stderr.write(`${combined}\n`);
+      _lastRenderedBlock = 'tool';
       _pendingHead = null;
       return;
     }
@@ -1311,6 +1468,7 @@ function renderToolResult(data, eventType = 'tool_result') {
 
   // Two-line shape: gutter under the (already-printed or just-flushed) head.
   process.stderr.write(`${gutter}${outcome}\n`);
+  _lastRenderedBlock = 'tool';
 
   // Lint warnings stay visible alongside writes.
   if (hasLint) {
@@ -1433,6 +1591,7 @@ function startContentStream() {
   _streamedPartialText = '';
   _renderedToolResults.clear();
   _renderedContentThisTurn = false;
+  _lastRenderedBlock = null;
   stopSpinner();
 }
 
@@ -1457,12 +1616,14 @@ function flushContent() {
   // Any buffered tool head needs to land BEFORE this content so the order
   // is preserved on screen.
   flushPendingHead();
+  if (_lastRenderedBlock === 'tool') process.stderr.write('\n');
   const rendered = renderMarkdown(_streamBuffer);
   for (const line of rendered.split('\n')) {
     process.stdout.write(`  ${line}\n`);
   }
   _streamBuffer = '';
   _renderedContentThisTurn = true;
+  _lastRenderedBlock = 'content';
 }
 
 // ── Event Renderer ──
@@ -1514,11 +1675,13 @@ function renderEvent(event) {
         }
       }
       if (text) {
+        if (_lastRenderedBlock === 'tool') process.stderr.write('\n');
         const rendered = renderMarkdown(text);
         for (const line of rendered.split('\n')) {
           process.stdout.write(`  ${line}\n`);
         }
         _renderedContentThisTurn = true;
+        _lastRenderedBlock = 'content';
       }
       break;
     }
@@ -1968,7 +2131,7 @@ function renderPlanOverview({ ctx, mode = 'overview' } = {}) {
   }
 
   renderTaskBoard(board, { showDone: mode === 'status' });
-  process.stderr.write(`\n  ${c.dim('Update: /tasks add <text> · /tasks active|blocked|done <text>')}\n\n`);
+  process.stderr.write(`\n  ${c.dim('Update: /tasks add <text> · /tasks move active 1 done · /tasks edit active 1 <text>')}\n\n`);
 }
 
 function refreshTaskContext(ctx) {
@@ -1987,7 +2150,7 @@ function handleTasksCommand(rest, ctx) {
     process.stderr.write(`\n  ${c.bold('Tasks')}\n`);
     process.stderr.write(`  ${c.dim('─'.repeat(60))}\n`);
     renderTaskBoard(board, { showDone: true });
-    process.stderr.write(`\n  ${c.dim('Update: /tasks add <text> · /tasks active|backlog|blocked|done <text>')}\n\n`);
+    process.stderr.write(`\n  ${c.dim('Update: /tasks add <text> · /tasks move active 1 done · /tasks edit active 1 <text>')}\n\n`);
     return;
   }
 
@@ -1998,6 +2161,60 @@ function handleTasksCommand(rest, ctx) {
 
   const parts = raw.split(/\s+/);
   let verb = (parts.shift() || '').toLowerCase();
+
+  if (verb === 'move') {
+    try {
+      const [from, index, to, ...textParts] = parts;
+      const result = moveTask({ cwd: safeCwd(), from, index, to, text: textParts.join(' ') || undefined });
+      refreshTaskContext(ctx);
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`moved ${result.from} #${result.index} → ${result.to}`)} ${result.text}\n`);
+    } catch (err) {
+      process.stderr.write(`  ${c.red(err.message || String(err))}\n`);
+      process.stderr.write(`  ${c.gray('Usage: /tasks move <active|backlog|blocked|done> <number> <active|backlog|blocked|done> [new text]')}\n`);
+    }
+    return;
+  }
+
+  if (verb === 'edit' || verb === 'rename') {
+    try {
+      const [list, index, ...textParts] = parts;
+      const result = updateTask({ cwd: safeCwd(), list, index, text: textParts.join(' ') });
+      refreshTaskContext(ctx);
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`updated ${result.list} #${result.index}`)} ${result.text}\n`);
+    } catch (err) {
+      process.stderr.write(`  ${c.red(err.message || String(err))}\n`);
+      process.stderr.write(`  ${c.gray('Usage: /tasks edit <active|backlog|blocked|done> <number> <new text>')}\n`);
+    }
+    return;
+  }
+
+  if (verb === 'remove' || verb === 'rm' || verb === 'delete') {
+    try {
+      const [list, index] = parts;
+      const result = removeTask({ cwd: safeCwd(), list, index });
+      refreshTaskContext(ctx);
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`removed ${result.list} #${result.index}`)} ${result.task.text}\n`);
+    } catch (err) {
+      process.stderr.write(`  ${c.red(err.message || String(err))}\n`);
+      process.stderr.write(`  ${c.gray('Usage: /tasks remove <active|backlog|blocked|done> <number>')}\n`);
+    }
+    return;
+  }
+
+  if (verb === 'finish' || verb === 'complete' || verb === 'block' || verb === 'unblock') {
+    try {
+      const [from, index, ...textParts] = parts;
+      const to = verb === 'block' ? 'blocked' : verb === 'unblock' ? 'active' : 'done';
+      const result = moveTask({ cwd: safeCwd(), from, index, to, text: textParts.join(' ') || undefined });
+      refreshTaskContext(ctx);
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`moved ${result.from} #${result.index} → ${result.to}`)} ${result.text}\n`);
+    } catch (err) {
+      process.stderr.write(`  ${c.red(err.message || String(err))}\n`);
+      process.stderr.write(`  ${c.gray(`Usage: /tasks ${verb} <active|backlog|blocked|done> <number> [new text]`)}\n`);
+    }
+    return;
+  }
+
   let list = 'backlog';
   if (verb === 'add' || verb === 'new') {
     const maybeList = (parts[0] || '').toLowerCase();
@@ -2192,6 +2409,15 @@ async function handleCommand(input, ctx) {
       }
       process.stderr.write(`  ${c.dim('CWD')}          ${safeCwd()}\n`);
 
+      // Cache — PRD-071 §1.2. Only surface when we have data; a fresh session
+      // shows nothing rather than a misleading "0%".
+      const cache = computeCacheTotals();
+      if (cache.read > 0 || cache.write > 0) {
+        const readLabel = formatTokens(cache.read);
+        const writeLabel = formatTokens(cache.write);
+        process.stderr.write(`  ${c.dim('Cache')}        ${cache.hitRate}% hit ${c.dim('·')} ${readLabel} read ${c.dim('·')} ${writeLabel} write\n`);
+      }
+
       // Permissions
       process.stderr.write(`\n  ${c.bold('Permissions')}\n`);
       process.stderr.write(`  ${c.dim('─'.repeat(44))}\n`);
@@ -2498,10 +2724,7 @@ async function handleCommand(input, ctx) {
     }
 
     case '/compact': {
-      const before = session.agentHistory.length || session.history.length;
-      if (before <= 4) { process.stderr.write(`  ${c.gray('Nothing to compact.')}\n`); return; }
-      session.agentHistory.splice(2, session.agentHistory.length - 6);
-      process.stderr.write(`  ${c.gray(`Compacted agent context: ${before} → ${session.agentHistory.length} messages`)}\n`);
+      await compactCurrentSession(ctx, rest);
       return;
     }
 
@@ -3358,6 +3581,7 @@ export async function startTerminalRepl() {
       if (approval.trustStore) approval.trustStore.policy = effectivePolicy.policy;
       hookRunner.reload();
       latestProjectContext = loadProjectContext({ cwd: safeCwd(), previous: latestProjectContext });
+      const projectResources = toolExecutor.getProjectResources();
       const promptHook = await hookRunner.run('UserPromptSubmit', {
         input: { prompt: input },
         turnId: String(session.turns),
@@ -3379,7 +3603,7 @@ export async function startTerminalRepl() {
         effectivePolicy,
         projectContext: latestProjectContext,
         activeHints: [...hookHints, ...rejectionHints],
-        projectResources: toolExecutor.getProjectResources(),
+        projectResources,
         agentContext: toolExecutor.getAgentContext(),
       });
       ctx.effectivePolicy = effectivePolicy;
@@ -3387,6 +3611,14 @@ export async function startTerminalRepl() {
       ctx.latestEnvelope = latestEnvelope;
       Object.assign(execContext, latestEnvelope);
       if (skipPerms) execContext.freeswim = true;
+      // PRD-071: seed work_scope from CLI so the backend has a byte-stable
+      // scope block from turn 1. Uses projectResources already gathered by
+      // the envelope above.
+      execContext.work_scope = buildWorkScope({
+        instruction: input,
+        cwd: safeCwd(),
+        projectResources,
+      });
       for (const file of latestProjectContext.changed || []) {
         if (effectivePolicy.policy.context?.showReloadNotice) {
           process.stderr.write(`  ${c.dim(`[Context] ${file.label} updated — re-read`)}\n`);

package/src/ui/commands.mjs

@@ -7,12 +7,10 @@
 
 import { SessionManager } from '../core/session.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
-import { PromptCache } from '../core/cache.mjs';
 import { readEnv, listEnvVars } from '../config/env.mjs';
 import * as telemetry from '../telemetry/index.mjs';
 
 const checkpoints = new CheckpointManager();
-const promptCache = new PromptCache();
 let sessionManager = null;
 
 function getSession() {
@@ -399,11 +397,14 @@ export const COMMANDS = {
     '/extra-usage': {
         description: 'Show detailed usage stats',
         handler(args, state) {
-            const cacheStats = promptCache.getStats();
             const telemetryStats = telemetry.getStats();
+            const cacheRead = state.tokenUsage.cache_read || 0;
+            const cacheWrite = state.tokenUsage.cache_creation || 0;
+            const denom = state.tokenUsage.input + cacheRead;
+            const rate = denom > 0 ? Math.round((cacheRead / denom) * 100) : 0;
             return [
                 `Tokens: in=${state.tokenUsage.input}, out=${state.tokenUsage.output}`,
-                `Cache: hits=${cacheStats.cacheHits}, misses=${cacheStats.cacheMisses}, rate=${cacheStats.hitRate}`,
+                `Cache: read=${cacheRead}, write=${cacheWrite}, hit-rate=${rate}%`,
                 `Telemetry: ${telemetryStats.totalEvents} events`,
             ].join('\n');
         },