@jentrix/runner 0.5.20 → 0.5.22

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-2YTE5PGH.js

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

package/dist/{chunk-FWAHAHAM.js.map → chunk-2YTE5PGH.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.22\";\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-2YTE5PGH.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-6WPHLGSS.js");
     let raw;
     const planFile = valueAfter(args, "--plan-file");
     if (planFile) {

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

@@ -1,6 +1,6 @@
 import {
   RUNNER_VERSION
-} from "./chunk-FWAHAHAM.js";
+} from "./chunk-2YTE5PGH.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", {
@@ -818,6 +953,8 @@ var SessionBridge = class {
       endHead: opts.end.head,
       endDirty: opts.end.dirty,
       captureError,
+      ...opts.acknowledgeEvidenceGaps ? { acknowledgeEvidenceGaps: true } : {},
+      ...typeof opts.commitCount === "number" ? { commitCount: opts.commitCount } : {},
       ...manifest ? { manifest } : {},
       usage: {
         inputTokens: rollup.inputTokens,
@@ -1230,6 +1367,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) {
@@ -1595,6 +1739,22 @@ function sessionCallTool(mcpUrl, bearerSource, sessionId) {
     }
   };
 }
+function evidenceFloorRefusalOf(error) {
+  const raw = error instanceof Error ? error.message : String(error ?? "");
+  if (!raw.includes("EVIDENCE_FLOOR")) return null;
+  const start = raw.indexOf("{");
+  if (start >= 0) {
+    try {
+      const envelope = JSON.parse(raw.slice(start));
+      const message = envelope.error?.message;
+      if (typeof message === "string" && message.includes("EVIDENCE_FLOOR")) {
+        return message;
+      }
+    } catch {
+    }
+  }
+  return raw;
+}
 function claudeHookSettings(runnerBin, sessionDir) {
   const hook = (event) => [
     {
@@ -1664,6 +1824,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 +1885,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,18 +1898,29 @@ 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 endAcknowledgeGaps = false;
+  let endCommitCount = null;
   let lastPeriodicFlushAt = 0;
   let lastPromptAttemptAt = 0;
   const promptRedactor = createSessionRedactor({ homedir: homedir() });
@@ -1823,6 +1998,14 @@ async function runClaudeSessionHost(plan, deps = {}) {
   const poll = async () => {
     const endRequestPath = join3(sessionDir, "end-request.json");
     if (!sessionEnded && existsSync(endRequestPath)) {
+      try {
+        const request = JSON.parse(readFileSync3(endRequestPath, "utf8"));
+        endAcknowledgeGaps = request.acknowledgeEvidenceGaps === true;
+        endCommitCount = typeof request.commitCount === "number" ? request.commitCount : null;
+      } catch {
+        endAcknowledgeGaps = false;
+        endCommitCount = null;
+      }
       try {
         unlinkSync3(endRequestPath);
       } catch {
@@ -1841,6 +2024,7 @@ async function runClaudeSessionHost(plan, deps = {}) {
           transcriptPath = hookTranscript;
           try {
             transcriptOffset = plan.importHistory ? 0 : statSync2(transcriptPath).size;
+            observePriorCodexModel(transcriptPath);
             noteTranscriptSeen();
           } catch {
             transcriptOffset = 0;
@@ -1988,52 +2172,77 @@ async function runClaudeSessionHost(plan, deps = {}) {
     }
     await bridge.maybeHeartbeat();
   };
-  const timer = setInterval(() => {
+  let timer = setInterval(() => {
     void poll();
   }, 2e3);
-  const exitCode = await (watch ? (
-    // Watch mode: live capture beside the operator's own provider process.
-    // End signals: the SessionEnd lifecycle hook, an end request from
-    // `jentrix session end`, or a heartbeat 409 (session terminal
-    // server-side — the out-of-band case the hooks can never deliver).
-    new Promise((resolve) => {
-      const check = setInterval(() => {
-        if (sessionEnded || bridge.sessionInactive) {
-          clearInterval(check);
-          resolve(0);
-        }
-      }, 1e3);
-    })
-  ) : new Promise((resolve) => {
-    child.once("error", () => resolve(1));
-    child.once(
-      "exit",
-      (code, signal) => resolve(code ?? (signal ? 130 : 0))
-    );
-  }));
-  clearInterval(timer);
-  await poll().catch(() => void 0);
-  await bridge.flushParts().catch(() => void 0);
-  for (const id of timing.unclosedToolIds()) {
-    bridge.recordUnclosedInterval("tool", id);
-  }
-  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",
-    end
-  }).catch((error) => {
+  let exitCode = 0;
+  let result = null;
+  for (; ; ) {
+    exitCode = await (watch ? (
+      // Watch mode: live capture beside the operator's own provider process.
+      // End signals: the SessionEnd lifecycle hook, an end request from
+      // `jentrix session end`, or a heartbeat 409 (session terminal
+      // server-side — the out-of-band case the hooks can never deliver).
+      new Promise((resolve) => {
+        const check = setInterval(() => {
+          if (sessionEnded || bridge.sessionInactive) {
+            clearInterval(check);
+            resolve(0);
+          }
+        }, 1e3);
+      })
+    ) : new Promise((resolve) => {
+      child.once("error", () => resolve(1));
+      child.once(
+        "exit",
+        (code, signal) => resolve(code ?? (signal ? 130 : 0))
+      );
+    }));
+    clearInterval(timer);
+    await poll().catch(() => void 0);
+    await bridge.flushParts().catch(() => void 0);
+    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);
+    let failure = null;
+    result = await bridge.complete({
+      outcome: exitCode === 0 ? "COMPLETED" : "INTERRUPTED",
+      end,
+      acknowledgeEvidenceGaps: endAcknowledgeGaps,
+      commitCount: endCommitCount
+    }).catch((error) => {
+      failure = error;
+      return null;
+    });
+    if (result) break;
+    const refusal = watch ? evidenceFloorRefusalOf(failure) : null;
+    if (refusal) {
+      writeFileSync4(
+        join3(sessionDir, "end-refusal.json"),
+        JSON.stringify({
+          refusedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          message: refusal
+        }),
+        { mode: 384 }
+      );
+      log(
+        `capture: the close was refused by the evidence floor \u2014 this host (pid ${process.pid}) stays up; push the named evidence and re-run \`jentrix session end ${plan.sessionId}\``
+      );
+      sessionEnded = false;
+      endAcknowledgeGaps = false;
+      endCommitCount = null;
+      timer = setInterval(() => {
+        void poll();
+      }, 2e3);
+      continue;
+    }
     log(
-      `capture: completion failed (${error instanceof Error ? error.message : "unknown"}) \u2014 spool retained for retry`
+      `capture: completion failed (${failure instanceof Error ? failure.message : "unknown"}) \u2014 spool retained for retry`
     );
-    return null;
-  });
-  if (!result) {
     markHostExited(sessionDir, 1);
     return 1;
   }
@@ -2066,6 +2275,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({
@@ -2196,6 +2406,7 @@ export {
   appendHookEvent,
   claudeHookSettings,
   defaultSpoolRoot,
+  evidenceFloorRefusalOf,
   readHookLines,
   readTranscriptTail,
   runClaudeSessionHost,
@@ -2204,4 +2415,4 @@ export {
   safeParse,
   sessionCallTool
 };
-//# sourceMappingURL=session-host-P6W3PH3S.js.map
+//# sourceMappingURL=session-host-6WPHLGSS.js.map