@jentrix/runner 0.5.20 → 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-FWAHAHAM.js.map → chunk-UN63BYMS.js.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../lib/version.ts"],
-  "sourcesContent": ["export const RUNNER_VERSION = \"0.5.20\";\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-FWAHAHAM.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-P6W3PH3S.js");
+    const { runSessionHost } = await import("./session-host-L6XF4T2P.js");
     let raw;
     const planFile = valueAfter(args, "--plan-file");
     if (planFile) {

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

@@ -1,6 +1,6 @@
 import {
   RUNNER_VERSION
-} from "./chunk-FWAHAHAM.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", {
@@ -1230,6 +1365,13 @@ function mapCodexRolloutLine(rawLine) {
     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
 function text(value) {
@@ -1664,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(
@@ -1724,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;
@@ -1734,17 +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;
-  const codexRolloutTurnStarts = /* @__PURE__ */ new Map();
   let sessionEnded = false;
   let lastPeriodicFlushAt = 0;
   let lastPromptAttemptAt = 0;
@@ -1841,6 +1996,7 @@ async function runClaudeSessionHost(plan, deps = {}) {
           transcriptPath = hookTranscript;
           try {
             transcriptOffset = plan.importHistory ? 0 : statSync2(transcriptPath).size;
+            observePriorCodexModel(transcriptPath);
             noteTranscriptSeen();
           } catch {
             transcriptOffset = 0;
@@ -2020,9 +2176,6 @@ async function runClaudeSessionHost(plan, deps = {}) {
   for (const id of codexRolloutTurnStarts.keys()) {
     bridge.recordUnclosedInterval("turn", id);
   }
-  if (plan.provider === "codex") {
-    await bridge.flushUsageNow().catch(() => false);
-  }
   const end = await endRepoState(plan.repoRoot);
   const result = await bridge.complete({
     outcome: exitCode === 0 ? "COMPLETED" : "INTERRUPTED",
@@ -2066,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({
@@ -2204,4 +2358,4 @@ export {
   safeParse,
   sessionCallTool
 };
-//# sourceMappingURL=session-host-P6W3PH3S.js.map
+//# sourceMappingURL=session-host-L6XF4T2P.js.map