@sagentlab/navarch-runtime 0.1.30 → 0.1.32

package/dist/adapters/claude.cjs

@@ -93,7 +93,13 @@ function attachUsage(result) {
     if (!parsed)
         return result;
     const usage = (0, exit_conditions_cjs_1.extractUsageFromClaudeJson)(parsed);
-    return { ...result, tokensIn: usage.tokensIn, tokensOut: usage.tokensOut, costUsd: usage.costUsd };
+    return {
+        ...result,
+        tokensIn: usage.tokensIn,
+        tokensOut: usage.tokensOut,
+        cacheHitTokensIn: usage.cacheHitTokensIn,
+        costUsd: usage.costUsd,
+    };
 }
 async function runOnHost(options, args) {
     return new Promise((resolve) => {

package/dist/adapters/codex.cjs

@@ -156,6 +156,7 @@ function attachUsage(result, model) {
         // measured zero — leave the fields unset so aggregation skips them.
         ...(usage.tokensIn !== undefined ? { tokensIn: usage.tokensIn } : {}),
         ...(usage.tokensOut !== undefined ? { tokensOut: usage.tokensOut } : {}),
+        ...(usage.cacheHitTokensIn !== undefined ? { cacheHitTokensIn: usage.cacheHitTokensIn } : {}),
         ...(costUsd !== undefined ? { costUsd } : {}),
         ...(reportText !== undefined ? { reportText } : {}),
     };

package/dist/adapters/opencode.cjs

@@ -123,6 +123,7 @@ function attachOpenCodeOutput(result) {
         return result;
     let tokensIn;
     let tokensOut;
+    let cacheHitTokensIn;
     let costUsd;
     let finalMessageId;
     const textByMessage = new Map();
@@ -144,6 +145,9 @@ function attachOpenCodeOutput(result) {
         const cost = nonNegativeMetric(part.cost);
         if (input !== undefined || cacheRead !== undefined || cacheWrite !== undefined) {
             tokensIn = (tokensIn ?? 0) + (input ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+            // Cache reads are the "hit" component of tokensIn; cache writes count
+            // as misses (AdapterResult.cacheHitTokensIn semantics).
+            cacheHitTokensIn = (cacheHitTokensIn ?? 0) + (cacheRead ?? 0);
         }
         if (output !== undefined)
             tokensOut = (tokensOut ?? 0) + output;
@@ -157,6 +161,7 @@ function attachOpenCodeOutput(result) {
         ...result,
         ...(tokensIn !== undefined ? { tokensIn } : {}),
         ...(tokensOut !== undefined ? { tokensOut } : {}),
+        ...(cacheHitTokensIn !== undefined ? { cacheHitTokensIn } : {}),
         ...(costUsd !== undefined ? { costUsd } : {}),
         ...(reportText ? { reportText } : {}),
     };

package/dist/exit-conditions.cjs

@@ -52,6 +52,8 @@ function parseClaudeJsonResult(stdout) {
  * no cache breakdown, so the components are folded together here rather
  * than dropped). Cost prefers `total_cost_usd` (the field name used in
  * multi-turn/agentic CLI output) and falls back to `cost_usd`.
+ * `cacheHitTokensIn` is the cache-read component of that sum -- cache writes
+ * count as misses, matching sessions.cache_miss_input_tokens semantics.
  */
 function extractUsageFromClaudeJson(parsed) {
     const usage = parsed.usage ?? {};
@@ -60,7 +62,7 @@ function extractUsageFromClaudeJson(parsed) {
         (usage.cache_read_input_tokens ?? 0);
     const tokensOut = usage.output_tokens ?? 0;
     const costUsd = parsed.total_cost_usd ?? parsed.cost_usd ?? 0;
-    return { tokensIn, tokensOut, costUsd };
+    return { tokensIn, tokensOut, cacheHitTokensIn: usage.cache_read_input_tokens ?? 0, costUsd };
 }
 /**
  * Best-effort line-by-line parse of `codex exec --json` stdout into the
@@ -105,15 +107,21 @@ function parseCodexJsonEvents(stdout) {
 function extractUsageFromCodexEvents(events) {
     let turnTokensIn = 0;
     let turnTokensOut = 0;
+    let turnCacheHit = 0;
     let sawTurnUsage = false;
     let legacyTokensIn;
     let legacyTokensOut;
+    let legacyCacheHit;
     let costUsd;
     for (const event of events) {
         if (event.type === "turn.completed" && event.usage) {
             sawTurnUsage = true;
             turnTokensIn += event.usage.input_tokens ?? 0;
             turnTokensOut += event.usage.output_tokens ?? 0;
+            // cached_input_tokens is a component of input_tokens in the verified
+            // stream (see codex-pricing.cts priceUsage) -- same inclusive
+            // semantics as AdapterResult.cacheHitTokensIn.
+            turnCacheHit += event.usage.cached_input_tokens ?? 0;
             if (typeof event.usage.total_cost_usd === "number") {
                 costUsd = (costUsd ?? 0) + event.usage.total_cost_usd;
             }
@@ -124,6 +132,9 @@ function extractUsageFromCodexEvents(events) {
                 ? (nested.input_tokens ?? 0)
                 : (event.msg.input_tokens ?? 0) + (event.msg.cached_input_tokens ?? 0);
             legacyTokensOut = nested?.output_tokens ?? event.msg.output_tokens ?? 0;
+            legacyCacheHit = nested
+                ? (nested.cached_input_tokens ?? 0)
+                : (event.msg.cached_input_tokens ?? 0);
             if (typeof nested?.total_cost_usd === "number")
                 costUsd = nested.total_cost_usd;
         }
@@ -132,6 +143,7 @@ function extractUsageFromCodexEvents(events) {
             if (total) {
                 legacyTokensIn = total.input_tokens ?? 0;
                 legacyTokensOut = total.output_tokens ?? 0;
+                legacyCacheHit = total.cached_input_tokens ?? 0;
                 if (typeof total.total_cost_usd === "number")
                     costUsd = total.total_cost_usd;
             }
@@ -140,9 +152,24 @@ function extractUsageFromCodexEvents(events) {
             costUsd = event.msg.total_cost_usd;
         }
     }
-    if (sawTurnUsage)
-        return { tokensIn: turnTokensIn, tokensOut: turnTokensOut, costUsd };
-    return { tokensIn: legacyTokensIn, tokensOut: legacyTokensOut, costUsd };
+    if (sawTurnUsage) {
+        return {
+            tokensIn: turnTokensIn,
+            tokensOut: turnTokensOut,
+            // Clamp like codex-pricing.cts: a malformed event must not report more
+            // cache reads than input tokens.
+            cacheHitTokensIn: Math.min(turnCacheHit, turnTokensIn),
+            costUsd,
+        };
+    }
+    return {
+        tokensIn: legacyTokensIn,
+        tokensOut: legacyTokensOut,
+        ...(legacyTokensIn !== undefined && legacyCacheHit !== undefined
+            ? { cacheHitTokensIn: Math.min(legacyCacheHit, legacyTokensIn) }
+            : {}),
+        costUsd,
+    };
 }
 /** The last completed agent message, with legacy `msg.agent_message` fallback. */
 function extractFinalMessageFromCodexEvents(events) {

package/dist/prompt.cjs

@@ -36,7 +36,8 @@ function renderPrompt(task, bundle) {
     if (bundle.depends_on_reports.length > 0) {
         sections.push("## Prior task reports (depends_on)");
         for (const report of bundle.depends_on_reports) {
-            sections.push(`- ${report.task_id}: ${report.report_summary ?? report.summary}`);
+            const source = report.github_issue_url ? ` (${report.github_issue_url})` : "";
+            sections.push(`- ${report.task_id}${source}: ${report.report_summary ?? report.summary}`);
         }
     }
     sections.push("## Playbook");

package/dist/session.cjs

@@ -400,6 +400,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 ...turnResult,
                 tokensIn: sumReportedUsage(attempts, "tokensIn"),
                 tokensOut: sumReportedUsage(attempts, "tokensOut"),
+                cacheHitTokensIn: sumReportedUsage(attempts, "cacheHitTokensIn"),
                 costUsd: sumReportedUsage(attempts, "costUsd"),
             };
             const mapping = (0, exit_conditions_cjs_1.mapExitCondition)({
@@ -468,6 +469,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     ...(result.tokensIn !== undefined ? { tokens_in: result.tokensIn } : {}),
                     ...(result.tokensOut !== undefined ? { tokens_out: result.tokensOut } : {}),
                     ...(result.costUsd !== undefined ? { cost_usd: result.costUsd } : {}),
+                    ...cacheSplitFields(result.tokensIn, result.cacheHitTokensIn),
                 },
                 transcript_url: transcriptUrl,
                 exit_status: mapping.exitStatus,
@@ -593,6 +595,21 @@ function adapterCommand(config, runtime) {
             return { bin: config.opencodeBin, extraArgs: config.opencodeExtraArgs };
     }
 }
+/**
+ * The wire-shape prompt-cache split derived from adapter usage, or {} when no
+ * attempt reported a cache breakdown. The control plane persists the split
+ * only when hit + miss equals tokens_in (dispatch-service.ts
+ * byoCacheSplitOrNull), so the miss half is derived from the same summed
+ * total rather than reported independently. An attempt that reported tokens
+ * without a breakdown (plain-text fallback) inflates the miss half -- those
+ * tokens are "uncached or unknown", never fabricated hits.
+ */
+function cacheSplitFields(tokensIn, cacheHitTokensIn) {
+    if (tokensIn === undefined || cacheHitTokensIn === undefined)
+        return {};
+    const hit = Math.min(cacheHitTokensIn, tokensIn);
+    return { cache_hit_input_tokens: hit, cache_miss_input_tokens: tokensIn - hit };
+}
 function sumReportedUsage(attempts, key) {
     const reported = attempts.flatMap((attempt) => {
         const value = attempt[key];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through Claude Code, Codex, Gemini, or OpenCode.",
   "type": "commonjs",
   "license": "MIT",