@jentrix/runner 0.5.19 → 0.5.21

package/README.md

@@ -132,10 +132,10 @@ Setup:
 
 | Context loaded up front | Bytes | ≈ Tokens |
 | --- | --- | --- |
-| MCP agent — all 242 tool definitions | 374 KB | ~101k |
+| MCP agent — all 242 tool definitions | 375 KB | ~101k |
 | CLI agent — `CLI_STANDUP_SYSTEM_PROMPT` only | 2 KB | ~510 |
 
-That is a **~198× smaller** Jentrix-specific up-front context.
+That is a **~199× smaller** Jentrix-specific up-front context.
 <!-- END GENERATED: mcp-tool-count:agent-token-cost -->
 
 Reproduce the two numbers directly:

package/dist/chunk-UN63BYMS.js

@@ -0,0 +1,7 @@
+// lib/version.ts
+var RUNNER_VERSION = "0.5.21";
+
+export {
+  RUNNER_VERSION
+};
+//# sourceMappingURL=chunk-UN63BYMS.js.map

package/dist/{chunk-HJ2AADN6.js.map → chunk-UN63BYMS.js.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../lib/version.ts"],
-  "sourcesContent": ["export const RUNNER_VERSION = \"0.5.19\";\n"],
+  "sourcesContent": ["export const RUNNER_VERSION = \"0.5.21\";\n"],
   "mappings": ";AAAO,IAAM,iBAAiB;",
   "names": []
 }

package/dist/runner-cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   RUNNER_VERSION
-} from "./chunk-HJ2AADN6.js";
+} from "./chunk-UN63BYMS.js";
 
 // runner-cli.ts
 import { fileURLToPath } from "node:url";
@@ -219,7 +219,7 @@ async function main(args = process.argv.slice(2)) {
     return runConfiguredRunner(args.includes("--once"));
   }
   if (command === "session-run" && (args.includes("--plan-stdin") || args.includes("--plan-file"))) {
-    const { runSessionHost } = await import("./session-host-NJF6CRET.js");
+    const { runSessionHost } = await import("./session-host-L6XF4T2P.js");
     let raw;
     const planFile = valueAfter(args, "--plan-file");
     if (planFile) {

package/dist/{session-host-NJF6CRET.js → session-host-L6XF4T2P.js}

@@ -1,6 +1,6 @@
 import {
   RUNNER_VERSION
-} from "./chunk-HJ2AADN6.js";
+} from "./chunk-UN63BYMS.js";
 import {
   appendHookEvent,
   readHookLines,
@@ -180,6 +180,126 @@ function serializeSessionEvent(event) {
 `;
 }
 
+// lib/session-skeleton.ts
+var SKELETON_VERSION = 1;
+var MAX_SKELETON_BYTES = 32 * 1024;
+var MAX_DISTINCT_TOOLS = 100;
+var MAX_TRACKED_FILES = 300;
+var MAX_HOURLY_BUCKETS = 500;
+var MAX_PATH_CHARS = 300;
+var PATH_KEYS = ["file_path", "path", "notebook_path", "filePath"];
+function pathOf(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed || /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) return null;
+  return trimmed.slice(0, MAX_PATH_CHARS);
+}
+var SessionSkeleton = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  provider;
+  turns = 0;
+  firstEventAt = null;
+  lastEventAt = null;
+  eventCounts = /* @__PURE__ */ new Map();
+  toolCounts = /* @__PURE__ */ new Map();
+  files = /* @__PURE__ */ new Set();
+  filesOverflow = 0;
+  hourly = /* @__PURE__ */ new Map();
+  coalesced = false;
+  get observedAnything() {
+    return this.firstEventAt !== null;
+  }
+  /** Feed one REDACTED observed event. Pure accumulation, never throws. */
+  observe(event) {
+    this.eventCounts.set(
+      event.kind,
+      (this.eventCounts.get(event.kind) ?? 0) + 1
+    );
+    if (event.kind === "user_message") this.turns += 1;
+    if (this.firstEventAt === null) this.firstEventAt = event.at;
+    this.lastEventAt = event.at;
+    const hour = event.at.slice(0, 13);
+    if (this.hourly.has(hour) || this.hourly.size < MAX_HOURLY_BUCKETS) {
+      this.hourly.set(hour, (this.hourly.get(hour) ?? 0) + 1);
+    } else {
+      this.coalesced = true;
+    }
+    const payload = event.payload ?? {};
+    if (event.kind === "tool_call") {
+      const name = typeof payload.name === "string" && payload.name.trim() ? payload.name.trim().slice(0, 120) : "(unnamed)";
+      if (this.toolCounts.has(name) || this.toolCounts.size < MAX_DISTINCT_TOOLS) {
+        this.toolCounts.set(name, (this.toolCounts.get(name) ?? 0) + 1);
+      } else {
+        this.coalesced = true;
+        this.toolCounts.set(
+          "(other)",
+          (this.toolCounts.get("(other)") ?? 0) + 1
+        );
+      }
+      const input = payload.input;
+      if (input && typeof input === "object" && !Array.isArray(input)) {
+        for (const key of PATH_KEYS) {
+          const path = pathOf(input[key]);
+          if (path) this.touch(path);
+        }
+      }
+    }
+    if (event.kind === "file_change") {
+      const changes = payload.changes;
+      if (Array.isArray(changes)) {
+        for (const change of changes) {
+          const path = pathOf(change?.path);
+          if (path) this.touch(path);
+        }
+      } else if (changes && typeof changes === "object") {
+        for (const key of Object.keys(changes)) {
+          const path = pathOf(key);
+          if (path) this.touch(path);
+        }
+      }
+    }
+  }
+  touch(path) {
+    if (this.files.has(path)) return;
+    if (this.files.size >= MAX_TRACKED_FILES) {
+      this.filesOverflow += 1;
+      this.coalesced = true;
+      return;
+    }
+    this.files.add(path);
+  }
+  /** The bounded v1 JSON. ≤ 32 KB serialized — file-list tail drops first. */
+  snapshot() {
+    const build = (paths2, listTruncated2) => ({
+      version: SKELETON_VERSION,
+      provider: this.provider,
+      turns: this.turns,
+      firstEventAt: this.firstEventAt,
+      lastEventAt: this.lastEventAt,
+      eventCounts: Object.fromEntries(this.eventCounts),
+      toolCounts: Object.fromEntries(this.toolCounts),
+      filesTouched: {
+        total: this.files.size + this.filesOverflow,
+        paths: paths2,
+        ...listTruncated2 ? { listTruncated: true } : {}
+      },
+      hourlyBuckets: Object.fromEntries(this.hourly),
+      ...this.coalesced || listTruncated2 ? { truncated: true } : {}
+    });
+    let paths = [...this.files];
+    let listTruncated = this.filesOverflow > 0;
+    let skeleton = build(paths, listTruncated);
+    while (Buffer.byteLength(JSON.stringify(skeleton), "utf8") > MAX_SKELETON_BYTES && paths.length > 0) {
+      paths = paths.slice(0, Math.max(0, Math.floor(paths.length / 2)));
+      listTruncated = true;
+      skeleton = build(paths, listTruncated);
+    }
+    return skeleton;
+  }
+};
+
 // lib/session-usage.ts
 function insideOneRange(ranges, from, to) {
   return ranges.some((r) => r.from <= from && to <= r.to);
@@ -362,6 +482,7 @@ var HEARTBEAT_MIN_INTERVAL_MS = 3e4;
 var SessionBridge = class {
   constructor(deps) {
     this.deps = deps;
+    this.skeleton = deps.collectSkeleton === false ? null : new SessionSkeleton(deps.provider);
   }
   deps;
   sequence = 0;
@@ -393,6 +514,13 @@ var SessionBridge = class {
    * session keeps its telemetry and loses what it actually concluded).
    */
   lastAssistantMessage = null;
+  /**
+   * Session evidence floor (PRD §4): the v1 activity skeleton, accumulated
+   * from every REDACTED event this bridge records — capture-off included —
+   * and submitted on the existing heartbeats plus the forced beat at close.
+   * Null when the operator opted out at align (D3).
+   */
+  skeleton;
   /**
    * True after a heartbeat came back 409 SESSION_NOT_ACTIVE — the session is
    * terminal server-side. The watch host uses this as its end signal when no
@@ -463,6 +591,7 @@ var SessionBridge = class {
         this.deps.redactor.text(serializeSessionEvent(full))
       );
     }
+    this.skeleton?.observe(full);
     if (full.kind === "assistant_message") {
       const text2 = full.payload?.text;
       if (typeof text2 === "string" && text2.trim().length > 0) {
@@ -601,7 +730,12 @@ var SessionBridge = class {
             // Sent only once a receipt has actually been observed — an empty
             // rollup would overwrite the session's totals with nulls and
             // report UNAVAILABLE for a session that had already reported.
-            ...this.receipts.length > 0 ? { usage: this.usageRollup() } : {}
+            ...this.receipts.length > 0 ? { usage: this.usageRollup() } : {},
+            // Evidence floor (PRD §4/D2): the bounded activity skeleton rides
+            // the same beat (tolerant server parse — an old server strips the
+            // unknown key). Sent only once something was observed: null column
+            // means "never observed", never an empty object.
+            ...this.skeleton?.observedAnything ? { activitySkeleton: this.skeleton.snapshot() } : {}
           })
         }
       );
@@ -801,6 +935,7 @@ var SessionBridge = class {
    */
   async complete(opts) {
     const { pending } = await this.flushParts();
+    await this.flushUsageNow().catch(() => false);
     const finalResponseArtifactId = await this.pushFinalResponse();
     const rollup = this.usageRollup();
     const current = await this.deps.callTool("get_agent_session", {
@@ -1152,39 +1287,90 @@ function mapCodexThreadEvent(raw) {
       return { event: null, unrecognized: true };
   }
 }
+var CODEX_INJECTED_USER_CONTEXT = [
+  "<recommended_plugins>",
+  "# AGENTS.md instructions",
+  "<environment_context>"
+];
+function codexOpeningPromptOf(rollout) {
+  for (const rawLine of rollout.split("\n")) {
+    try {
+      const line = JSON.parse(rawLine);
+      if (line.type !== "response_item" || line.payload?.type !== "message" || line.payload.role !== "user") {
+        continue;
+      }
+      const text2 = (line.payload.content ?? []).filter((block) => block.type === "input_text").map((block) => block.text?.trim() ?? "").filter(
+        (block) => block && !CODEX_INJECTED_USER_CONTEXT.some(
+          (prefix) => block.startsWith(prefix)
+        )
+      );
+      if (text2.length > 0) return text2.join("\n\n");
+    } catch {
+    }
+  }
+  return null;
+}
 function reportedToken(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
 }
-function mapCodexRolloutUsageLine(rawLine) {
+function mapCodexRolloutLine(rawLine) {
   try {
     const line = JSON.parse(rawLine);
+    const modelId = line.payload?.model?.trim() || null;
+    const turnId = line.payload?.turn_id?.trim() || null;
+    const at = Date.parse(line.timestamp ?? "");
+    if (line.type === "turn_context") {
+      return { event: null, modelId, turn: null };
+    }
+    if (line.type === "event_msg" && turnId && Number.isFinite(at) && (line.payload?.type === "task_started" || line.payload?.type === "task_complete")) {
+      return {
+        event: null,
+        modelId: null,
+        turn: {
+          id: turnId,
+          phase: line.payload.type === "task_started" ? "started" : "completed",
+          at
+        }
+      };
+    }
     const usage = line.payload?.info?.last_token_usage;
     const inputTokens = reportedToken(usage?.input_tokens);
     const outputTokens = reportedToken(usage?.output_tokens);
     if (line.type !== "event_msg" || line.payload?.type !== "token_count" || inputTokens === null || outputTokens === null) {
-      return null;
+      return { event: null, modelId: null, turn: null };
     }
     const cacheReadTokens = reportedToken(usage?.cached_input_tokens);
     const cacheCreationTokens = reportedToken(usage?.cache_write_input_tokens);
     const reasoningOutputTokens = reportedToken(usage?.reasoning_output_tokens);
     return {
-      ...make(
-        "usage",
-        {
-          kind: "delta",
-          inputTokens,
-          outputTokens,
-          ...cacheReadTokens !== null ? { cacheReadTokens } : {},
-          ...cacheCreationTokens !== null ? { cacheCreationTokens } : {},
-          ...reasoningOutputTokens !== null ? { reasoningOutputTokens } : {}
-        },
-        typeof line.ordinal === "number" ? `rollout:${line.ordinal}` : line.timestamp
-      ),
-      ...line.timestamp ? { at: line.timestamp } : {}
+      event: {
+        ...make(
+          "usage",
+          {
+            kind: "delta",
+            inputTokens,
+            outputTokens,
+            ...cacheReadTokens !== null ? { cacheReadTokens } : {},
+            ...cacheCreationTokens !== null ? { cacheCreationTokens } : {},
+            ...reasoningOutputTokens !== null ? { reasoningOutputTokens } : {}
+          },
+          typeof line.ordinal === "number" ? `rollout:${line.ordinal}` : line.timestamp
+        ),
+        ...line.timestamp ? { at: line.timestamp } : {}
+      },
+      modelId: null,
+      turn: null
     };
   } catch {
-    return null;
+    return { event: null, modelId: null, turn: null };
+  }
+}
+function lastCodexRolloutModelOf(rollout) {
+  let modelId = null;
+  for (const rawLine of rollout.split("\n")) {
+    modelId = mapCodexRolloutLine(rawLine).modelId ?? modelId;
   }
+  return modelId;
 }
 
 // lib/session-codex-hooks.ts
@@ -1620,6 +1806,7 @@ async function runClaudeSessionHost(plan, deps = {}) {
     callTool: deps.callTool ?? sessionCallTool(plan.mcpUrl, bearerSource, plan.sessionId),
     fetchImpl: deps.fetchImpl,
     traceCapture,
+    collectSkeleton: plan.collectSkeleton !== false,
     log
   });
   bridge.recordCapabilities(
@@ -1680,6 +1867,9 @@ async function runClaudeSessionHost(plan, deps = {}) {
   }
   let transcriptPath = watch ? plan.transcriptPath ?? null : null;
   let transcriptOffset = 0;
+  let codexTurnId = null;
+  let codexModelId = null;
+  const codexRolloutTurnStarts = /* @__PURE__ */ new Map();
   const timing = new ClaudeTimingTracker();
   let transcriptSeen = false;
   let transcriptWarned = false;
@@ -1690,16 +1880,26 @@ async function runClaudeSessionHost(plan, deps = {}) {
       markHostTranscript(sessionDir, true, transcriptPath ?? void 0);
     }
   };
+  const observePriorCodexModel = (path) => {
+    if (plan.provider !== "codex" || plan.importHistory) return;
+    try {
+      const modelId = lastCodexRolloutModelOf(readFileSync3(path, "utf8"));
+      if (modelId) {
+        codexModelId = modelId;
+        bridge.observeModel(modelId);
+      }
+    } catch {
+    }
+  };
   if (watch && transcriptPath && !plan.importHistory) {
     try {
       transcriptOffset = statSync2(transcriptPath).size;
+      observePriorCodexModel(transcriptPath);
       noteTranscriptSeen();
     } catch {
     }
   }
   let bound = watch;
-  let codexTurnId = null;
-  let codexModelId = null;
   let sessionEnded = false;
   let lastPeriodicFlushAt = 0;
   let lastPromptAttemptAt = 0;
@@ -1715,13 +1915,14 @@ async function runClaudeSessionHost(plan, deps = {}) {
       }
       return;
     }
-    if (!transcriptPath || plan.provider !== "claude") return;
+    if (!transcriptPath) return;
     const nowMs = Date.now();
     if (nowMs - lastPromptAttemptAt < 3e4) return;
     lastPromptAttemptAt = nowMs;
     let prompt = null;
     try {
-      prompt = openingPromptOf(readFileSync3(transcriptPath, "utf8"));
+      const transcript = readFileSync3(transcriptPath, "utf8");
+      prompt = plan.provider === "claude" ? openingPromptOf(transcript) : codexOpeningPromptOf(transcript);
     } catch {
       return;
     }
@@ -1795,6 +1996,7 @@ async function runClaudeSessionHost(plan, deps = {}) {
           transcriptPath = hookTranscript;
           try {
             transcriptOffset = plan.importHistory ? 0 : statSync2(transcriptPath).size;
+            observePriorCodexModel(transcriptPath);
             noteTranscriptSeen();
           } catch {
             transcriptOffset = 0;
@@ -1876,7 +2078,32 @@ async function runClaudeSessionHost(plan, deps = {}) {
         transcriptOffset = tail.offset;
         if (tail.body) {
           for (const rawLine of tail.body.split("\n").filter(Boolean)) {
-            const event = mapCodexRolloutUsageLine(rawLine);
+            const mapped = mapCodexRolloutLine(rawLine);
+            if (mapped.modelId) {
+              codexModelId = mapped.modelId;
+              bridge.observeModel(mapped.modelId);
+            }
+            if (mapped.turn?.phase === "started") {
+              codexTurnId = mapped.turn.id;
+              codexRolloutTurnStarts.set(mapped.turn.id, mapped.turn.at);
+            } else if (mapped.turn?.phase === "completed") {
+              const startedAt = codexRolloutTurnStarts.get(mapped.turn.id);
+              if (startedAt !== void 0) {
+                if (mapped.turn.at >= startedAt) {
+                  bridge.recordInterval({
+                    kind: "turn",
+                    id: mapped.turn.id,
+                    startedAt,
+                    endedAt: mapped.turn.at
+                  });
+                } else {
+                  bridge.recordUnclosedInterval("turn", mapped.turn.id);
+                }
+                codexRolloutTurnStarts.delete(mapped.turn.id);
+              }
+              if (codexTurnId === mapped.turn.id) codexTurnId = null;
+            }
+            const event = mapped.event;
             if (!event) continue;
             bridge.record({
               ...event,
@@ -1946,6 +2173,9 @@ async function runClaudeSessionHost(plan, deps = {}) {
   for (const id of timing.unclosedToolIds()) {
     bridge.recordUnclosedInterval("tool", id);
   }
+  for (const id of codexRolloutTurnStarts.keys()) {
+    bridge.recordUnclosedInterval("turn", id);
+  }
   const end = await endRepoState(plan.repoRoot);
   const result = await bridge.complete({
     outcome: exitCode === 0 ? "COMPLETED" : "INTERRUPTED",
@@ -1989,6 +2219,7 @@ async function runCodexSessionHost(plan, deps = {}) {
     redactor: createSessionRedactor({ homedir: homedir() }),
     callTool: sessionCallTool(plan.mcpUrl, codexBearerSource, plan.sessionId),
     fetchImpl: deps.fetchImpl,
+    collectSkeleton: plan.collectSkeleton !== false,
     log
   });
   bridge.recordCapabilities({
@@ -2127,4 +2358,4 @@ export {
   safeParse,
   sessionCallTool
 };
-//# sourceMappingURL=session-host-NJF6CRET.js.map
+//# sourceMappingURL=session-host-L6XF4T2P.js.map