@use-aistack/cli 0.12.2 → 0.13.0

package/dist/index.js

@@ -348,7 +348,7 @@ function apiEquivalentCost(modelKey, t, atMs) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.12.2" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.13.0" : "0.0.0-dev";
 
 // src/api.ts
 var BASE_URL = process.env.AISTACK_URL || "https://aistack.to";
@@ -976,11 +976,11 @@ function readText(path7) {
     return null;
   }
 }
-function readParsed(path7, parse) {
+function readParsed(path7, parse2) {
   const raw = readText(path7);
   if (raw === null) return null;
   try {
-    return parse(raw);
+    return parse2(raw);
   } catch {
     return null;
   }
@@ -2408,8 +2408,9 @@ async function hasRecentFile(roots, matches, sinceMs, opts = {}) {
 }
 
 // ../workflow-rules/src/daily.ts
-var WORKFLOW_AGGREGATES_V2 = "workflow-aggregates/v2";
+var WORKFLOW_AGGREGATES_V3 = "workflow-aggregates/v3";
 var LOG_BUCKETS_V1 = "log-buckets/v1";
+var LOG_BUCKETS_V2 = "log-buckets/v2";
 var EMPTY_PHASE_TOTALS = Object.freeze({
   scout: 0,
   build: 0,
@@ -2463,6 +2464,10 @@ function medianBucket(buckets) {
   }
   return sorted[sorted.length - 1]?.bucket;
 }
+function logBucketV2(value) {
+  if (!(value >= 1)) return 0;
+  return Math.floor(2 * Math.log2(value)) + 1;
+}
 function median(values) {
   if (values.length === 0) return void 0;
   const sorted = [...values].sort((a, b) => a - b);
@@ -2505,6 +2510,52 @@ function foldModels(rows) {
     (row) => ({ ...row })
   ).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
 }
+function foldCountBuckets(rows, field) {
+  return sumBy(
+    rows,
+    (row) => String(row.bucket),
+    (into, from) => {
+      into[field] += from[field];
+    },
+    (row) => ({ ...row })
+  ).sort((a, b) => a.bucket - b.bucket);
+}
+function foldContextDays(days) {
+  const versions = [...new Set(days.map((d) => d.bucketRuleVersion))].sort().join(" \xB7 ");
+  const windows = days.map((d) => d.window).filter((w) => w !== void 0);
+  const window = windows[windows.length - 1];
+  return {
+    bucketRuleVersion: versions,
+    calls: {
+      main: foldCountBuckets(
+        days.flatMap((d) => d.calls.main),
+        "calls"
+      ),
+      subagents: foldCountBuckets(
+        days.flatMap((d) => d.calls.subagents),
+        "calls"
+      )
+    },
+    firstCalls: {
+      main: foldCountBuckets(
+        days.flatMap((d) => d.firstCalls.main),
+        "sessions"
+      )
+    },
+    firstCallHarnessTokens: days.reduce(
+      (sum, d) => sum + d.firstCallHarnessTokens,
+      0
+    ),
+    firstCallInstructionsTokens: days.reduce(
+      (sum, d) => sum + d.firstCallInstructionsTokens,
+      0
+    ),
+    firstCallCount: days.reduce((sum, d) => sum + d.firstCallCount, 0),
+    maxContext: Math.max(0, ...days.map((d) => d.maxContext)),
+    compactions: days.reduce((sum, d) => sum + d.compactions, 0),
+    ...window === void 0 ? {} : { window }
+  };
+}
 function foldLengths(rows) {
   return sumBy(
     rows,
@@ -2641,6 +2692,8 @@ function foldHarnessDays(days) {
       0
     );
   }
+  const contexts = days.flatMap((day) => day.context ? [day.context] : []);
+  if (contexts.length > 0) out.context = foldContextDays(contexts);
   return out;
 }
 var MAX_CHANGED_LINES_PER_COMMIT = 4096;
@@ -2690,8 +2743,9 @@ function foldGitDays(days) {
 }
 function foldWorkflowDays(days, options) {
   if (days.length === 0) return void 0;
+  const dated = [...days].sort((a, b) => a.date.localeCompare(b.date));
   const byHarness = /* @__PURE__ */ new Map();
-  for (const day of days) {
+  for (const day of dated) {
     for (const harness of day.harnesses) {
       const held = byHarness.get(harness.harness) ?? [];
       held.push(harness);
@@ -3863,7 +3917,7 @@ function buildSyncBody(built, syncConfig, autoSync, trigger = "manual", measured
 }
 
 // src/workflow/reducer.ts
-var WORKFLOW_AGGREGATE_VERSION = WORKFLOW_AGGREGATES_V2;
+var WORKFLOW_AGGREGATE_VERSION = WORKFLOW_AGGREGATES_V3;
 function createWorkflowLocalSources() {
   return { projectWorkspaces: /* @__PURE__ */ new Set(), activeProjectDays: /* @__PURE__ */ new Map() };
 }
@@ -3879,6 +3933,11 @@ var bump2 = (map, key2, amount = 1) => {
   map.set(key2, (map.get(key2) ?? 0) + amount);
 };
 var utcDateOf2 = (ms) => new Date(ms).toISOString().slice(0, 10);
+function asBuckets(map, field) {
+  return [...map].map(
+    ([bucket, count]) => ({ bucket, [field]: count })
+  ).sort((a, b) => a.bucket - b.bucket);
+}
 var PHASE_RANK = {
   verify: 4,
   handoff: 3,
@@ -3976,13 +4035,25 @@ function dayState() {
     questions: { asked: 0, turns: 0 },
     hasQuestions: false,
     webSearches: 0,
-    hasWebSearches: false
+    hasWebSearches: false,
+    context: {
+      calls: { main: /* @__PURE__ */ new Map(), subagents: /* @__PURE__ */ new Map() },
+      firstCalls: /* @__PURE__ */ new Map(),
+      firstCallHarnessTokens: 0,
+      firstCallInstructionsTokens: 0,
+      firstCallCount: 0,
+      maxContext: 0,
+      compactions: 0,
+      window: void 0
+    },
+    hasContext: false
   };
 }
 function createHarnessWorkflowReducer(harness, localSources = createWorkflowLocalSources()) {
   const sessions = /* @__PURE__ */ new Map();
   const eventCells = /* @__PURE__ */ new Map();
   const webSearchesByDate = /* @__PURE__ */ new Map();
+  const compactionsByDate = /* @__PURE__ */ new Map();
   const eventDates = /* @__PURE__ */ new Set();
   let finished;
   const getSession = (key2) => {
@@ -4023,22 +4094,39 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
       } else if (observation.type === "response") {
         const responseId = observation.responseId ?? `anonymous:${state.nextAnonymousResponse++}`;
         const duration = finiteNonnegative(observation.durationSec);
+        const contextTokens = finiteNonnegative(observation.contextTokens);
+        const contextWindow = finiteNonnegative(observation.contextWindow);
         const response = {
+          tsMs: observation.tsMs,
           ...observation.model ? { model: observation.model } : {},
           ...observation.thinkingTokens !== void 0 ? { thinkingTokens: finiteNonnegative(observation.thinkingTokens) } : {},
           ...observation.responseTokens !== void 0 ? { responseTokens: finiteNonnegative(observation.responseTokens) } : {},
           ...observation.routingTokens !== void 0 ? { routingTokens: finiteNonnegative(observation.routingTokens) } : {},
           ...observation.effort ? { effort: observation.effort } : {},
-          ...duration > 0 ? { durationSec: duration } : {}
+          ...duration > 0 ? { durationSec: duration } : {},
+          ...observation.contextTokens !== void 0 ? { contextTokens } : {},
+          ...contextWindow > 0 ? { contextWindow } : {},
+          ...observation.firstCall ? {
+            firstCall: {
+              harnessTokens: finiteNonnegative(
+                observation.firstCall.harnessTokens
+              ),
+              instructionsTokens: finiteNonnegative(
+                observation.firstCall.instructionsTokens
+              )
+            }
+          } : {}
         };
         const existing = state.responses.get(responseId);
         const magnitude = (value) => value.routingTokens ?? (value.thinkingTokens ?? 0) + (value.responseTokens ?? 0);
         if (!existing || magnitude(response) > magnitude(existing)) {
           state.responses.set(responseId, response);
         }
-      } else {
+      } else if (observation.type === "turn") {
         const turnId = observation.turnId ?? `anonymous:${state.nextAnonymousTurn++}`;
         state.turns.set(turnId, observation.questionBack);
+      } else {
+        bump2(compactionsByDate, date);
       }
     },
     finish() {
@@ -4144,6 +4232,33 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
             Boolean
           ).length;
         }
+        for (const response of responses) {
+          if (response.contextTokens === void 0) continue;
+          day.hasContext = true;
+          const context = day.context;
+          bump2(context.calls[routing], logBucketV2(response.contextTokens));
+          context.maxContext = Math.max(
+            context.maxContext,
+            response.contextTokens
+          );
+          if (response.contextWindow !== void 0 && (context.window === void 0 || response.tsMs >= context.window.tsMs)) {
+            context.window = {
+              tsMs: response.tsMs,
+              window: response.contextWindow
+            };
+          }
+          if (response.firstCall && routing === "main") {
+            bump2(context.firstCalls, logBucketV2(response.contextTokens));
+            context.firstCallHarnessTokens += response.firstCall.harnessTokens;
+            context.firstCallInstructionsTokens += response.firstCall.instructionsTokens;
+            context.firstCallCount++;
+          }
+        }
+      }
+      for (const [date, compactions] of compactionsByDate) {
+        const day = dayOf(date);
+        day.hasContext = true;
+        day.context.compactions += compactions;
       }
       for (const date of eventDates) {
         const day = dayOf(date);
@@ -4276,12 +4391,34 @@ function createHarnessWorkflowReducer(harness, localSources = createWorkflowLoca
             }
           } : {},
           ...day.hasQuestions ? { questions: day.questions } : {},
-          ...day.hasWebSearches ? { webSearches: day.webSearches } : {}
+          ...day.hasWebSearches ? { webSearches: day.webSearches } : {},
+          ...day.hasContext ? {
+            context: {
+              bucketRuleVersion: LOG_BUCKETS_V2,
+              calls: {
+                main: asBuckets(day.context.calls.main, "calls"),
+                subagents: asBuckets(
+                  day.context.calls.subagents,
+                  "calls"
+                )
+              },
+              firstCalls: {
+                main: asBuckets(day.context.firstCalls, "sessions")
+              },
+              firstCallHarnessTokens: day.context.firstCallHarnessTokens,
+              firstCallInstructionsTokens: day.context.firstCallInstructionsTokens,
+              firstCallCount: day.context.firstCallCount,
+              maxContext: day.context.maxContext,
+              compactions: day.context.compactions,
+              ...day.context.window ? { window: day.context.window.window } : {}
+            }
+          } : {}
         }))
       };
       sessions.clear();
       eventCells.clear();
       webSearchesByDate.clear();
+      compactionsByDate.clear();
       eventDates.clear();
       return finished;
     }
@@ -4295,9 +4432,30 @@ function createAggregate2() {
     workflow: createHarnessWorkflowReducer("claude-code", workflowLocal),
     workflowLocal,
     workflowSeenCalls: /* @__PURE__ */ new Set(),
-    workflowSeenTurns: /* @__PURE__ */ new Set()
+    workflowSeenTurns: /* @__PURE__ */ new Set(),
+    contextFirstCall: /* @__PURE__ */ new Map()
   });
 }
+function workflowSessionKey(rec) {
+  const baseSession = asStr(rec.sessionId);
+  if (!baseSession) return null;
+  if (rec.isSidechain !== true) return baseSession;
+  return `${baseSession}:agent:${asStr(rec.agentId) ?? "unknown"}`;
+}
+function isApiCall(rec) {
+  if (asStr(rec.type) !== "assistant") return false;
+  const msg = asObj(rec.message);
+  if (!msg || !asObj(msg.usage)) return false;
+  return !(asName(msg.model) ?? "").startsWith("<");
+}
+function noteRecordBeforeWindow(agg, raw) {
+  const rec = asObj(raw);
+  if (!rec || !isApiCall(rec)) return;
+  const session = workflowSessionKey(rec);
+  if (session && !agg.contextFirstCall.has(session)) {
+    agg.contextFirstCall.set(session, null);
+  }
+}
 function projectWorkspaceDirectory(raw) {
   const rec = asObj(raw);
   return rec ? asStr(rec.cwd) : null;
@@ -4330,7 +4488,25 @@ function ingestRecord(agg, raw, ctx) {
     ingestClaudeWorkflow(agg, rec, ctx, tsMs);
     ingestAssistant(agg, rec, tsMs);
   } else if (type === "user") ingestUser(agg, rec);
-  else if (type === "system") ingestClaudeTurnDuration(agg, rec, ctx, tsMs);
+  else if (type === "system") {
+    ingestClaudeTurnDuration(agg, rec, ctx, tsMs);
+    ingestClaudeCompaction(agg, rec, ctx, tsMs);
+  }
+}
+function ingestClaudeCompaction(agg, rec, ctx, tsMs) {
+  if (tsMs === null || asStr(rec.subtype) !== "compact_boundary") return;
+  const session = workflowSessionKey(rec);
+  if (!session) return;
+  agg.workflow.ingest({
+    type: "compaction",
+    session,
+    projectWorkspace: projectWorkspaceDirectory(rec) ?? ctx.projectDir,
+    tsMs,
+    ...rec.isSidechain === true ? { sidechain: true } : {}
+  });
+}
+function contextOf(counts) {
+  return counts.input + counts.cacheWrite5m + counts.cacheWrite1h + counts.cacheWriteUnsplit + counts.cacheRead;
 }
 function ingestClaudeTurnDuration(agg, rec, ctx, tsMs) {
   if (tsMs === null || asStr(rec.subtype) !== "turn_duration" || asNum(rec.durationMs) <= 0) {
@@ -4362,6 +4538,24 @@ function ingestClaudeWorkflow(agg, rec, ctx, tsMs) {
   const messageId = asStr(msg.id);
   const newTurn = messageId ? !agg.workflowSeenTurns.has(messageId) : true;
   if (messageId) agg.workflowSeenTurns.add(messageId);
+  let context = null;
+  if (counts && isApiCall(rec)) {
+    const held = agg.contextFirstCall.get(session);
+    let first = false;
+    if (held === void 0) {
+      agg.contextFirstCall.set(session, messageId);
+      first = true;
+    } else if (held !== null && held === messageId) first = true;
+    context = {
+      contextTokens: contextOf(counts),
+      ...first ? {
+        firstCall: {
+          harnessTokens: counts.cacheRead,
+          instructionsTokens: contextOf(counts) - counts.cacheRead
+        }
+      } : {}
+    };
+  }
   agg.workflow.ingest({
     type: "response",
     session,
@@ -4373,7 +4567,8 @@ function ingestClaudeWorkflow(agg, rec, ctx, tsMs) {
     ...asName(msg.model) ? { model: asName(msg.model) } : {},
     ...counts ? { responseTokens: counts.output } : {},
     ...counts ? { routingTokens: countsTotal(counts) } : {},
-    ...asStr(rec.effort) ?? asStr(msg.effort) ? { effort: asStr(rec.effort) ?? asStr(msg.effort) } : {}
+    ...asStr(rec.effort) ?? asStr(msg.effort) ? { effort: asStr(rec.effort) ?? asStr(msg.effort) } : {},
+    ...context ?? {}
   });
   const tools = [];
   for (const rawBlock of asArr(msg.content)) {
@@ -4751,7 +4946,10 @@ async function ingestFile(agg, file, projectDir, projectWorkspaces, sinceMs) {
     }
     if (sinceMs !== void 0) {
       const ts = rec && typeof rec === "object" && "timestamp" in rec && typeof rec.timestamp === "string" ? Date.parse(rec.timestamp) : Number.NaN;
-      if (Number.isNaN(ts) || ts < sinceMs) continue;
+      if (Number.isNaN(ts) || ts < sinceMs) {
+        noteRecordBeforeWindow(agg, rec);
+        continue;
+      }
     }
     ingestRecord(agg, rec, { projectDir: projectWorkspace });
   }
@@ -4803,7 +5001,33 @@ function createFileState() {
     responseIndex: 0,
     currentQuestionBack: false,
     counted: false,
-    metaTsMs: null
+    metaTsMs: null,
+    forked: false,
+    sawResponse: false
+  };
+}
+function genuineDelta(payload, state, tsMs) {
+  if (asStr(payload.type) !== "token_count") return null;
+  const info = asObj(payload.info);
+  const last = info ? asObj(info.last_token_usage) : null;
+  if (!last) return null;
+  const inputTotal = asNum(last.input_tokens);
+  const cached = Math.min(asNum(last.cached_input_tokens), inputTotal);
+  const counts = {
+    input: inputTotal - cached,
+    output: asNum(last.output_tokens),
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheWriteUnsplit: 0,
+    cacheRead: cached
+  };
+  if (countsTotal(counts) === 0) return null;
+  if (tsMs !== null && state.metaTsMs !== null && tsMs - state.metaTsMs < FORK_REPLAY_WINDOW_MS)
+    return null;
+  return {
+    counts,
+    last,
+    contextWindow: info ? asNum(info.model_context_window) : 0
   };
 }
 var FORK_REPLAY_WINDOW_MS = 500;
@@ -4825,11 +5049,17 @@ function ingestLine(agg, raw, state, sinceMs) {
     state.cliVersion = asStr(payload.cli_version) ?? state.cliVersion;
     state.cwd = asStr(payload.cwd) ?? state.cwd;
     state.metaTsMs = tsMs ?? state.metaTsMs;
+    state.forked = payload.forked_from_id !== void 0 && payload.forked_from_id !== null;
   } else if (type === "turn_context" && payload) {
     const model = asName(payload.model);
     if (model) state.modelKey = normalizeModel(model);
     state.effort = asStr(payload.effort) ?? state.effort;
   }
+  let firstCall = false;
+  if (type === "event_msg" && payload && genuineDelta(payload, state, tsMs)) {
+    firstCall = !state.sawResponse;
+    state.sawResponse = true;
+  }
   if (!inWindow) return;
   if (tsMs !== null && timestamp) {
     agg.activeDays.add(timestamp.slice(0, 10));
@@ -4838,9 +5068,18 @@ function ingestLine(agg, raw, state, sinceMs) {
   }
   noteActivity(agg, state, tsMs);
   noteProjectDay(agg, state.cwd ?? "(unknown)", tsMs);
-  if (type === "event_msg" && payload) ingestEvent(agg, payload, state, tsMs);
+  if (type === "event_msg" && payload)
+    ingestEvent(agg, payload, state, tsMs, firstCall);
   else if (type === "response_item" && payload)
     ingestItem(agg, payload, state, tsMs);
+  else if (type === "compacted" && tsMs !== null && state.sessionId) {
+    agg.workflow.ingest({
+      type: "compaction",
+      session: state.sessionId,
+      projectWorkspace: state.cwd ?? void 0,
+      tsMs
+    });
+  }
 }
 function noteActivity(agg, state, tsMs) {
   if (state.sessionId) noteSessionStart(agg, state.sessionId, tsMs);
@@ -4850,25 +5089,11 @@ function noteActivity(agg, state, tsMs) {
   if (state.cliVersion) agg.ccVersions.add(cleanName(state.cliVersion));
   agg.projectDirs.add(state.cwd ?? "(unknown)");
 }
-function ingestEvent(agg, payload, state, tsMs) {
-  if (asStr(payload.type) !== "token_count") return;
-  const info = asObj(payload.info);
-  const last = info ? asObj(info.last_token_usage) : null;
-  if (!last) return;
-  const inputTotal = asNum(last.input_tokens);
-  const cached = Math.min(asNum(last.cached_input_tokens), inputTotal);
-  const counts = {
-    input: inputTotal - cached,
-    output: asNum(last.output_tokens),
-    cacheWrite5m: 0,
-    cacheWrite1h: 0,
-    cacheWriteUnsplit: 0,
-    cacheRead: cached
-  };
+function ingestEvent(agg, payload, state, tsMs, firstCall) {
+  const delta = genuineDelta(payload, state, tsMs);
+  if (!delta) return;
+  const { counts, last, contextWindow } = delta;
   const total = countsTotal(counts);
-  if (total === 0) return;
-  if (tsMs !== null && state.metaTsMs !== null && tsMs - state.metaTsMs < FORK_REPLAY_WINDOW_MS)
-    return;
   if (state.modelKey === null) return;
   if (tsMs === null) agg.untimestampedResponses++;
   agg.distinctResponses++;
@@ -4894,7 +5119,20 @@ function ingestEvent(agg, payload, state, tsMs) {
       responseTokens: counts.output,
       routingTokens: total,
       thinkingTokens: asNum(last.reasoning_output_tokens),
-      ...state.effort ? { effort: state.effort } : {}
+      ...state.effort ? { effort: state.effort } : {},
+      // The context at this call is `input_tokens` (cached is a subset).
+      // On the first call the cached part is the harness (base
+      // instructions and tool specs, cached by an earlier session) and
+      // the fresh part is the instructions: AGENTS.md, environment,
+      // skills and the first prompt. Same method as Claude Code (#358).
+      contextTokens: counts.input + counts.cacheRead,
+      ...contextWindow > 0 ? { contextWindow } : {},
+      ...firstCall && !state.forked ? {
+        firstCall: {
+          harnessTokens: counts.cacheRead,
+          instructionsTokens: counts.input
+        }
+      } : {}
     });
     agg.workflow.ingest({
       type: "turn",
@@ -6476,6 +6714,7 @@ import { createHash } from "node:crypto";
 import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { dirname as dirname5, join as join8 } from "node:path";
+import { parse } from "smol-toml";
 function codexHome2() {
   return process.env.CODEX_HOME || join8(homedir11(), ".codex");
 }
@@ -6558,15 +6797,59 @@ function codexAutoSyncHookInstalled(file = codexHooksFile()) {
   if (!Array.isArray(sessionStart)) return false;
   return sessionStart.some((m) => (m.hooks ?? []).some((h) => isOurs(h)));
 }
-function codexHookTrusted(configFile = codexConfigFile()) {
-  let text;
+function codexHookTrusted(configFile = codexConfigFile(), hooksFile = codexHooksFile()) {
   try {
-    text = readFileSync9(configFile, "utf-8");
+    const config = parse(readFileSync9(configFile, "utf-8"));
+    const read = readHooksJson(hooksFile);
+    if ("error" in read) return null;
+    const sessionStart = read.settings.hooks?.SessionStart;
+    if (!Array.isArray(sessionStart)) return false;
+    const matches = [];
+    for (const [groupIndex, group] of sessionStart.entries()) {
+      for (const [handlerIndex, handler] of (group.hooks ?? []).entries()) {
+        if (!isOurs(handler) || typeof handler.command !== "string") continue;
+        const normalizedHandler = {
+          type: "command",
+          command: handler.command,
+          timeout: typeof handler.timeout === "number" ? Math.max(1, handler.timeout) : 600,
+          async: handler.async === true
+        };
+        if (typeof handler.statusMessage === "string") {
+          normalizedHandler.statusMessage = handler.statusMessage;
+        }
+        if (typeof handler.additionalContextLimit === "number" && handler.additionalContextLimit !== 2500) {
+          normalizedHandler.additionalContextLimit = handler.additionalContextLimit;
+        }
+        const identity = {
+          event_name: "session_start",
+          hooks: [normalizedHandler]
+        };
+        if (typeof group.matcher === "string") identity.matcher = group.matcher;
+        const currentHash = `sha256:${createHash("sha256").update(JSON.stringify(canonicalJson2(identity))).digest("hex")}`;
+        const key2 = `${hooksFile}:session_start:${groupIndex}:${handlerIndex}`;
+        matches.push(config.hooks?.state?.[key2]?.trusted_hash === currentHash);
+      }
+    }
+    return matches.length > 0 && matches.every(Boolean);
   } catch {
     return null;
   }
-  const hash = createHash("sha256").update(CODEX_HOOK_COMMAND).digest("hex");
-  return text.includes(hash);
+}
+function canonicalJson2(value) {
+  if (Array.isArray(value)) return value.map(canonicalJson2);
+  if (value && typeof value === "object") {
+    const sorted = {};
+    for (const [key2, child] of Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    )) {
+      sorted[key2] = canonicalJson2(child);
+    }
+    return sorted;
+  }
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return value;
+  }
+  throw new TypeError("hook identity is not JSON-serializable");
 }
 
 // src/autosync/optin.ts
@@ -6679,7 +6962,9 @@ async function enableAutoSync(frequencyHours = DEFAULT_FREQUENCY_HOURS, deps = {
   if (names.has(CODEX_HARNESS_NAME)) {
     const codexResult = (deps.installCodexHook ?? installCodexAutoSyncHook)();
     if (!codexResult.ok) return codexResult;
-    trustLine = codexResult.message;
+    if ((deps.codexHookTrustedImpl ?? codexHookTrusted)() !== true) {
+      trustLine = codexResult.message;
+    }
   }
   saveSettings(
     {
@@ -7387,7 +7672,7 @@ function buildWorkflowExtraction(harnessWorkflows, git, utcOffsetMinutes = machi
     ])
   ].sort();
   return {
-    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    aggregateVersion: WORKFLOW_AGGREGATES_V3,
     utcOffsetMinutes,
     days: dates.map((date) => {
       const projects = projectDays.get(date)?.size;
@@ -7430,6 +7715,15 @@ function totalUSD(payload) {
   }
   return any ? sum : null;
 }
+function tokenBreakdown(payload) {
+  let fresh = 0;
+  let cached = 0;
+  for (const model of payload.models) {
+    fresh += model.tokens.input + model.tokens.output + model.tokens.cacheWrite;
+    cached += model.tokens.cacheRead;
+  }
+  return fresh + cached === payload.activity.totalTokens ? { fresh, cached } : null;
+}
 function withheldCount(payload) {
   const w = payload.inventory.withheld;
   return w.builtinTools + w.mcpServers + w.skills + w.subagents + w.slashCommands;
@@ -7539,10 +7833,15 @@ function payloadBlock(payload, width, ownWindow, stats) {
   const label = `${harnessLabel2(payload.harness.name)}${payload.harness.version ? ` ${payload.harness.version}` : ""}`;
   const days = payload.activity.activeDayDates.length;
   const usd = totalUSD(payload);
+  const breakdown = tokenBreakdown(payload);
   const totals = [
     `${payload.activity.sessions} session${payload.activity.sessions === 1 ? "" : "s"}`,
     `${days} active day${days === 1 ? "" : "s"}`,
-    `${fmtTokens(payload.activity.totalTokens)} tokens`
+    `${fmtTokens(payload.activity.totalTokens)} tokens processed`,
+    ...breakdown ? [
+      `${fmtTokens(breakdown.fresh)} fresh`,
+      `${fmtTokens(breakdown.cached)} cached`
+    ] : []
   ];
   out.push(`${label.toUpperCase()} ${payload.activity.sessions}`);
   if (payload.activity.totalTokens === 0) {
@@ -7629,7 +7928,7 @@ var PHASE_ORDER = ["scout", "build", "verify", "handoff", "unknown"];
 function workflowBlock(workflowDays, utcOffsetMinutes, host) {
   const out = [];
   const folded = foldWorkflowDays(workflowDays, {
-    aggregateVersion: WORKFLOW_AGGREGATES_V2,
+    aggregateVersion: WORKFLOW_AGGREGATES_V3,
     utcOffsetMinutes
   });
   const harnesses = folded?.harnesses ?? [];
@@ -7639,7 +7938,7 @@ function workflowBlock(workflowDays, utcOffsetMinutes, host) {
     ...new Set(withPlaybook.map((h) => h.phase?.ruleVersion ?? ""))
   ].filter(Boolean);
   out.push(
-    `workflow  ${harnesses.length} harness${harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${WORKFLOW_AGGREGATES_V2}`
+    `workflow  ${harnesses.length} harness${harnesses.length === 1 ? "" : "es"} \xB7 ${sessions} sessions \xB7 ${WORKFLOW_AGGREGATES_V3}`
   );
   const first = folded?.dates[0];
   const last = folded?.dates.at(-1);