teamai-cli 0.23.0-beta.6 → 0.23.0-beta.7

package/dist/index.js

@@ -747,7 +747,18 @@ var init_types = __esm({
       "instead",
       "don't",
       "that's not",
-      "not what"
+      "not what",
+      // Japanese: "that's wrong" / "not that" / "redo" / "you got it wrong" / "on your own" / "put it back".
+      "\u9055\u3046",
+      "\u3061\u304C\u3046",
+      "\u305D\u3046\u3058\u3083\u306A",
+      "\u305D\u3046\u3067\u306F\u306A",
+      "\u3084\u308A\u76F4",
+      "\u3084\u308A\u306A\u304A\u3057",
+      "\u9593\u9055\u3063\u3066",
+      "\u9593\u9055\u3048",
+      "\u52DD\u624B\u306B",
+      "\u623B\u3057\u3066"
     ];
     INTERVENTION_SCAN_MAX_BYTES = 50 * 1024 * 1024;
     TRANSCRIPT_INTERRUPT_PREFIX = "[Request interrupted by user";
@@ -6562,22 +6573,32 @@ async function readLastAssistantOutput(transcriptPath) {
   }
 }
 async function scanTranscriptStop(transcriptPath, opts) {
+  if (path20.basename(transcriptPath) === "index.json") {
+    const cb = await scanCodebuddyIndex(transcriptPath, opts?.frictionOnly ?? false);
+    if (cb) return cb;
+  }
+  const initial = await scanJsonlTranscriptOnce(transcriptPath);
+  if (opts?.frictionOnly || !isCodexTool(opts?.tool)) return initial.result;
+  const flushedSnapshot = await waitForCodexUsageFlush(transcriptPath, initial.codexSnapshot);
+  return flushedSnapshot ? { ...initial.result, tokens: flushedSnapshot.tokens, tokenScope: flushedSnapshot.scope } : initial.result;
+}
+async function scanJsonlTranscriptOnce(transcriptPath) {
   let interrupt = 0;
   let toolReject = 0;
   let toolError = 0;
   let prompts = 0;
   const tokens = emptyTokenUsage();
+  let codexSessionSnapshot = null;
+  let codexTranscriptSnapshot = null;
   const countedUsageKeys = /* @__PURE__ */ new Set();
-  if (path20.basename(transcriptPath) === "index.json") {
-    const cb = await scanCodebuddyIndex(transcriptPath, opts?.frictionOnly ?? false);
-    if (cb) return cb;
-  }
   try {
     const stat8 = await fs9.promises.stat(transcriptPath);
-    if (stat8.size === 0) return { interrupt, toolReject, toolError, tokens, prompts };
+    if (stat8.size === 0) {
+      return { result: { interrupt, toolReject, toolError, tokens, prompts }, codexSnapshot: null };
+    }
     if (stat8.size > INTERVENTION_SCAN_MAX_BYTES) {
       log.warn(`dashboard: transcript too large to scan (${stat8.size} bytes)`);
-      return { interrupt, toolReject, toolError, tokens, prompts };
+      return { result: { interrupt, toolReject, toolError, tokens, prompts }, codexSnapshot: null };
     }
     const rl = readline2.createInterface({
       input: fs9.createReadStream(transcriptPath, { encoding: "utf-8" }),
@@ -6585,13 +6606,19 @@ async function scanTranscriptStop(transcriptPath, opts) {
     });
     for await (const line of rl) {
       const trimmed = line.trim();
-      if (!trimmed || !trimmed.includes('"user"') && !trimmed.includes('"assistant"')) continue;
+      if (!trimmed || !trimmed.includes('"user"') && !trimmed.includes('"assistant"') && !trimmed.includes('"token_usage_record"') && !trimmed.includes('"token_count"')) continue;
       let entry;
       try {
         entry = JSON.parse(trimmed);
       } catch {
         continue;
       }
+      const codexUsage = parseCodexCumulativeUsage(entry);
+      if (codexUsage) {
+        if (codexUsage.scope === "session") codexSessionSnapshot = codexUsage;
+        else codexTranscriptSnapshot = codexUsage;
+        continue;
+      }
       if (entry.type === "assistant") {
         const usage = entry.message?.usage;
         const dedupKey2 = typeof entry.message?.id === "string" ? entry.message.id : typeof entry.requestId === "string" ? entry.requestId : void 0;
@@ -6638,7 +6665,97 @@ async function scanTranscriptStop(transcriptPath, opts) {
   } catch (e) {
     log.warn(`dashboard: failed to scan transcript: ${e.message}`);
   }
-  return { interrupt, toolReject, toolError, tokens, prompts };
+  const codexSnapshot = codexSessionSnapshot ?? codexTranscriptSnapshot;
+  const result = {
+    interrupt,
+    toolReject,
+    toolError,
+    tokens: codexSnapshot?.tokens ?? tokens,
+    prompts,
+    ...codexSnapshot ? { tokenScope: codexSnapshot.scope } : {}
+  };
+  return { result, codexSnapshot };
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function codexUsageToTokenUsage(usage) {
+  const inclusiveInput = toNum(usage.input_tokens);
+  const cacheRead = toNum(usage.cached_input_tokens);
+  const cacheCreation = toNum(usage.cache_write_input_tokens);
+  return {
+    input: Math.max(0, inclusiveInput - cacheRead - cacheCreation),
+    output: toNum(usage.output_tokens),
+    cacheRead,
+    cacheCreation
+  };
+}
+function parseCodexCumulativeUsage(entry) {
+  const payload = asRecord(entry.payload);
+  if (entry.type === "token_usage_record") {
+    const usage = asRecord(payload?.thread_token_usage);
+    return usage ? { tokens: codexUsageToTokenUsage(usage), scope: "session" } : null;
+  }
+  if (entry.type === "event_msg" && payload?.type === "token_count") {
+    const usage = asRecord(asRecord(payload.info)?.total_token_usage);
+    return usage ? { tokens: codexUsageToTokenUsage(usage), scope: "transcript" } : null;
+  }
+  return null;
+}
+function isCodexTool(tool) {
+  return typeof tool === "string" && tool.toLowerCase().includes("codex");
+}
+function codexSnapshotEquals(a, b) {
+  return a !== null && a.scope === b.scope && a.tokens.input === b.tokens.input && a.tokens.output === b.tokens.output && a.tokens.cacheRead === b.tokens.cacheRead && a.tokens.cacheCreation === b.tokens.cacheCreation;
+}
+function preferCodexSnapshot(current, observed) {
+  if (current?.scope === "session" && observed.scope === "transcript") return current;
+  return observed;
+}
+async function readLatestCodexUsageFromTail(transcriptPath) {
+  try {
+    const stat8 = await fs9.promises.stat(transcriptPath);
+    if (stat8.size === 0) return null;
+    const readSize = Math.min(stat8.size, CODEX_USAGE_TAIL_BYTES);
+    const offset = stat8.size - readSize;
+    const fh = await fs9.promises.open(transcriptPath, "r");
+    try {
+      const buffer = Buffer.alloc(readSize);
+      await fh.read(buffer, 0, readSize, offset);
+      const lines = buffer.toString("utf-8").split("\n");
+      if (offset > 0) lines.shift();
+      let latestSession = null;
+      let latestTranscript = null;
+      for (const line of lines) {
+        if (!line.includes('"token_usage_record"') && !line.includes('"token_count"')) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const snapshot = parseCodexCumulativeUsage(parsed);
+          if (snapshot?.scope === "session") latestSession = snapshot;
+          else if (snapshot) latestTranscript = snapshot;
+        } catch {
+        }
+      }
+      return latestSession ?? latestTranscript;
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return null;
+  }
+}
+async function waitForCodexUsageFlush(transcriptPath, initial) {
+  let latest = initial;
+  for (let attempt = 1; attempt < CODEX_USAGE_MAX_ATTEMPTS; attempt++) {
+    await new Promise((resolve) => setTimeout(resolve, CODEX_USAGE_RETRY_MS));
+    const observed = await readLatestCodexUsageFromTail(transcriptPath);
+    if (!observed) continue;
+    latest = preferCodexSnapshot(latest, observed);
+    if (!codexSnapshotEquals(initial, latest) && (initial !== null || totalTokenCount(latest.tokens) > 0)) {
+      return latest;
+    }
+  }
+  return latest;
 }
 async function readCodebuddyIndexOnce(transcriptPath) {
   try {
@@ -6834,7 +6951,7 @@ async function parseHookEvent(raw, tool) {
     if (output) {
       event.stoppedOutput = output;
     }
-    const scan = await scanTranscriptStop(hookData.transcript_path);
+    const scan = await scanTranscriptStop(hookData.transcript_path, { tool });
     if (scan.interrupt > 0 || scan.toolReject > 0 || scan.toolError > 0) {
       event.interventions = {
         interrupt: scan.interrupt,
@@ -6844,6 +6961,7 @@ async function parseHookEvent(raw, tool) {
     }
     if (scan.tokens.input > 0 || scan.tokens.output > 0 || scan.tokens.cacheRead > 0 || scan.tokens.cacheCreation > 0) {
       event.tokens = scan.tokens;
+      if (scan.tokenScope) event.tokenScope = scan.tokenScope;
     }
     if (scan.prompts > 0) {
       event.prompts = scan.prompts;
@@ -6984,11 +7102,23 @@ function rebuildSessions(events) {
   });
   return result;
 }
+function setLatestTokenSnapshot(snapshots, key, event) {
+  if (!event.tokens) return;
+  const current = snapshots.get(key);
+  const candidateTime = Date.parse(event.timestamp);
+  const currentTime = current ? Date.parse(current.timestamp) : Number.NaN;
+  if (!current || !Number.isFinite(candidateTime) || !Number.isFinite(currentTime) || candidateTime >= currentTime) {
+    snapshots.set(key, { timestamp: event.timestamp, tokens: event.tokens });
+  }
+}
 function aggregateSessionMetrics(events) {
   const map = /* @__PURE__ */ new Map();
   const lastStopAt = /* @__PURE__ */ new Map();
   const submitCount = /* @__PURE__ */ new Map();
   const stopPrompts = /* @__PURE__ */ new Map();
+  const unscopedTokens = /* @__PURE__ */ new Map();
+  const sessionTokens = /* @__PURE__ */ new Map();
+  const transcriptTokens = /* @__PURE__ */ new Map();
   for (const event of events) {
     let m = map.get(event.sessionId);
     if (!m) {
@@ -7001,7 +7131,18 @@ function aggregateSessionMetrics(events) {
         m.toolReject = event.interventions.toolReject;
       }
       if (event.tokens) {
-        m.tokens = { ...event.tokens };
+        if (event.tokenScope === "session") {
+          setLatestTokenSnapshot(sessionTokens, event.sessionId, event);
+        } else if (event.tokenScope === "transcript" && event.transcriptPath) {
+          let segments = transcriptTokens.get(event.sessionId);
+          if (!segments) {
+            segments = /* @__PURE__ */ new Map();
+            transcriptTokens.set(event.sessionId, segments);
+          }
+          setLatestTokenSnapshot(segments, event.transcriptPath, event);
+        } else {
+          setLatestTokenSnapshot(unscopedTokens, event.sessionId, event);
+        }
       }
       if (typeof event.prompts === "number") {
         stopPrompts.set(event.sessionId, event.prompts);
@@ -7020,6 +7161,18 @@ function aggregateSessionMetrics(events) {
     }
   }
   for (const [sid, m] of map) {
+    const sessionSnapshot = sessionTokens.get(sid);
+    const segments = transcriptTokens.get(sid);
+    if (sessionSnapshot) {
+      m.tokens = { ...sessionSnapshot.tokens };
+    } else if (segments && segments.size > 0) {
+      let total = emptyTokenUsage();
+      for (const segment of segments.values()) total = addTokenUsage(total, segment.tokens);
+      m.tokens = total;
+    } else {
+      const unscoped = unscopedTokens.get(sid);
+      if (unscoped) m.tokens = { ...unscoped.tokens };
+    }
     m.prompts = Math.max(submitCount.get(sid) ?? 0, stopPrompts.get(sid) ?? 0);
   }
   return map;
@@ -7062,7 +7215,7 @@ async function dashboardReport(toolArg) {
   compactEvents().catch(() => {
   });
 }
-var TRANSCRIPT_TAIL_BYTES, STOPPED_OUTPUT_MAX_CHARS, CODEBUDDY_USAGE_MAX_ATTEMPTS, CODEBUDDY_USAGE_RETRY_MS, CODEBUDDY_BLOB_MAX_COUNT, CODEBUDDY_REJECT_MARKER;
+var TRANSCRIPT_TAIL_BYTES, STOPPED_OUTPUT_MAX_CHARS, CODEX_USAGE_TAIL_BYTES, CODEX_USAGE_MAX_ATTEMPTS, CODEX_USAGE_RETRY_MS, CODEBUDDY_USAGE_MAX_ATTEMPTS, CODEBUDDY_USAGE_RETRY_MS, CODEBUDDY_BLOB_MAX_COUNT, CODEBUDDY_REJECT_MARKER;
 var init_dashboard_collector = __esm({
   "src/dashboard-collector.ts"() {
     "use strict";
@@ -7077,6 +7230,9 @@ var init_dashboard_collector = __esm({
     init_home();
     TRANSCRIPT_TAIL_BYTES = 10240;
     STOPPED_OUTPUT_MAX_CHARS = 500;
+    CODEX_USAGE_TAIL_BYTES = 256 * 1024;
+    CODEX_USAGE_MAX_ATTEMPTS = 8;
+    CODEX_USAGE_RETRY_MS = 250;
     CODEBUDDY_USAGE_MAX_ATTEMPTS = 8;
     CODEBUDDY_USAGE_RETRY_MS = 250;
     CODEBUDDY_BLOB_MAX_COUNT = 2e3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamai-cli",
-  "version": "0.23.0-beta.6",
+  "version": "0.23.0-beta.7",
   "description": "TeamAI — Make Every Team AI Native (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {