@jentrix/cli 0.5.19 → 0.5.21

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "jentrix",
   "description": "Connect this Claude Code session to a Jentrix project: /jentrix-connect binds the current session (trusted lifecycle hooks supply the session id), /jentrix-align runs the MVP alignment wizard, /jentrix-status and /jentrix-end wrap the same session operations. Business logic lives in the Jentrix CLI — removing this plugin leaves `jentrix session attach` as the universal fallback.",
-  "version": "0.5.2"
+  "version": "0.5.3"
 }

package/claude-plugin/commands/jentrix-checkpoint.md

@@ -49,6 +49,15 @@ the plan, when a long investigation resolves, or before handing the work over.
    `jentrix task move --task <id> --to-column-id <id>`. Only the columns the
    board actually has.
 
+**Cadence duty (evidence floor).** Checkpoint after EVERY commit, not only at
+the end: push the `decision` (with `--basis`) the commit rested on the moment
+it lands, and run its gates through `jentrix push log --from-cmd "<command>"`
+so the exit code and output tail are recorded as a LOG. Record quality must
+track the work, not end-of-session diligence — `jentrix session end` enforces
+this (it refuses on commits with no decision record and on sectioned reports
+with no typed artifacts; a deliberate exception is an ordinary
+`jentrix push gap`).
+
 Note for the operator: this records the distillation. On a session aligned
 with `--capture`, the raw pre-compaction range is preserved separately and
 automatically by the `PreCompact` hook, so the bytes survive even when this

package/claude-plugin/commands/jentrix-end.md

@@ -77,3 +77,17 @@ pipeline), the typed artifacts ARE the record — push them before closing:
    step 1, or in the next session. Do not try to reopen it.
 8. Ending the Jentrix session does NOT terminate this Claude Code session —
    say so if the user seems to expect it.
+
+**Evidence floor.** `jentrix session end` enforces fixed checks and will
+REFUSE to close when they are unmet: E1 — HEAD moved but no attested DIFF
+(the CLI pushes the real patch itself; just re-run `session end` from the
+aligned checkout); E2 — commits with no `jentrix push decision` and no
+declared-deviation `jentrix push gap`; E3 — a REPORT carrying `## Learnings`
+/ `## Gaps` / `## Decisions` sections while the session has zero
+corresponding typed artifacts (split them into `push learning|gap|decision`,
+never one blob). Comply by pushing the named evidence and retrying, or
+deviate honestly with a `gap` — `--acknowledge-evidence-gaps` closes anyway
+and stamps each unmet check MISSING into Review readiness. Run every gate
+through `jentrix push log --from-cmd "<command>"` (it records the exit code
+and output tail as a LOG and exits with the command's own code), so "tests
+green" claims carry evidence instead of tripping the E4 advisory.

package/codex-plugin/plugins/jentrix/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "jentrix",
-  "version": "0.2.4",
-  "description": "Connect Codex tasks to Jentrix projects with trusted lifecycle hooks, alignment, checkpoints, and honest session capture.",
+  "version": "0.2.6",
+  "description": "Connect Codex tasks to Jentrix with trusted lifecycle hooks, exact-rollout telemetry recovery, typed artifacts, and operator-confirmed alignment.",
   "author": {
     "name": "Jentrix",
     "url": "https://github.com/jentrix-au"
@@ -14,7 +14,7 @@
   "interface": {
     "displayName": "Jentrix",
     "shortDescription": "Connect this Codex task to Jentrix.",
-    "longDescription": "Align a Codex task to a Jentrix project and task, preserve typed checkpoints, and capture supported lifecycle evidence through trusted hooks.",
+    "longDescription": "Align a Codex task to a Jentrix project and task, preserve typed artifacts and checkpoints, capture supported lifecycle evidence through trusted hooks, and recover provider-reported usage from the exact task rollout when hooks are unavailable.",
     "developerName": "Jentrix",
     "category": "Productivity",
     "capabilities": ["Interactive", "Write"],

package/codex-plugin/plugins/jentrix/hooks/hooks.json

@@ -1,12 +1,13 @@
 {
-  "description": "Trusted Codex lifecycle bridge. Hook payloads are appended locally; compact hooks also ask the Jentrix CLI to preserve the approved capture boundary.",
+  "description": "Trusted Codex lifecycle bridge. Structured hook stdin is appended locally; credentials and transcript content never enter argv. Hooks remain inactive until the operator reviews and trusts them. PreCompact/PostCompact additionally preserve the approved capture boundary; capture off records only the boundary, never transcript content.",
   "hooks": {
     "SessionStart": [
       {
         "hooks": [
           {
             "type": "command",
-            "command": "stacks-runner session-hook --provider codex --event SessionStart"
+            "command": "stacks-runner session-hook --provider codex --event SessionStart",
+            "timeout": 3
           }
         ]
       }
@@ -16,7 +17,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "stacks-runner session-hook --provider codex --event UserPromptSubmit"
+            "command": "stacks-runner session-hook --provider codex --event UserPromptSubmit",
+            "timeout": 3
           }
         ]
       }
@@ -26,7 +28,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "stacks-runner session-hook --provider codex --event PostToolUse"
+            "command": "stacks-runner session-hook --provider codex --event PostToolUse",
+            "timeout": 3
           }
         ]
       }
@@ -36,7 +39,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "stacks-runner session-hook --provider codex --event Stop"
+            "command": "stacks-runner session-hook --provider codex --event Stop",
+            "timeout": 3
           }
         ]
       }
@@ -47,12 +51,13 @@
           {
             "type": "command",
             "command": "stacks-runner session-hook --provider codex --event PreCompact",
-            "timeout": 10
+            "timeout": 3
           },
           {
             "type": "command",
             "command": "jentrix session snapshot --event PreCompact",
-            "timeout": 10
+            "timeout": 10,
+            "statusMessage": "Preserving the Jentrix capture boundary"
           }
         ]
       }
@@ -63,12 +68,13 @@
           {
             "type": "command",
             "command": "stacks-runner session-hook --provider codex --event PostCompact",
-            "timeout": 10
+            "timeout": 3
           },
           {
             "type": "command",
             "command": "jentrix session snapshot --event PostCompact",
-            "timeout": 10
+            "timeout": 10,
+            "statusMessage": "Recording the Jentrix compaction boundary"
           }
         ]
       }
@@ -78,7 +84,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "stacks-runner session-hook --provider codex --event SessionEnd"
+            "command": "stacks-runner session-hook --provider codex --event SessionEnd",
+            "timeout": 3
           }
         ]
       }

package/codex-plugin/plugins/jentrix/skills/jentrix-align/SKILL.md

@@ -34,6 +34,13 @@ description: Align the current Codex task to a Jentrix workspace, project, work
 8. Echo the returned server alignment snapshot verbatim. If `.mcp.json` changed,
    explain that the current task must reconnect MCP or restart before using it.
 
+If detection names an exact Codex rollout fallback instead of a lifecycle-hook
+record, say what that means: provider token receipts and the opening prompt remain
+collectable, but prompt/tool/assistant lifecycle events are not. Direct the operator
+to review and trust the plugin hooks with `/hooks`, then start a new Codex task for
+full lifecycle coverage. Never claim `coverage: COMPLETE` for token receipts proves
+that hooks ran.
+
 TRACE capture is off by default. Pass `--capture` only when the operator explicitly
 approved full hook-derived trace capture. Same-project re-alignment converges;
 different-project re-alignment must be refused until `jentrix session end`.

package/codex-plugin/plugins/jentrix/skills/jentrix-checkpoint/SKILL.md

@@ -20,3 +20,10 @@ status is stale, read the real columns and correct it.
 
 The compact hooks preserve only the approved evidence boundary; this skill performs
 the model-authored distillation.
+
+**Cadence duty (evidence floor).** Checkpoint after EVERY commit, not only at the
+end: push the `decision` (with `--basis`) the commit rested on the moment it lands,
+and run its gates through `jentrix push log --from-cmd "<command>"` so the exit code
+and output tail land as a LOG. `jentrix session end` enforces this — it refuses on
+commits with no decision record and on sectioned reports with no typed artifacts;
+a deliberate exception is an ordinary `jentrix push gap`.

package/codex-plugin/plugins/jentrix/skills/jentrix-connect/SKILL.md

@@ -18,5 +18,10 @@ trusted environment and lifecycle-hook context. Relay the command output or erro
 verbatim. The command starts the hook-watching host in the background and prints
 its pid; do not start a second host. Never put credentials on the command line.
 
-If trusted identity is unavailable, report the CLI's fallback exactly; do not guess
-from Codex session files.
+When lifecycle hooks are unavailable, the CLI may recover telemetry only from the
+exact `rollout-*-${CODEX_THREAD_ID}.jsonl` under the trusted Codex home. Accept that
+exact match; never choose the newest session file. Explain that the fallback keeps
+provider token receipts and opening-prompt provenance, but not prompt/tool/assistant
+lifecycle events. Direct the operator to review and trust the plugin hooks with
+`/hooks`, then start a new Codex task for full lifecycle coverage. If trusted task
+identity or the exact rollout is unavailable, relay the refusal and do not guess.

package/codex-plugin/plugins/jentrix/skills/jentrix-end/SKILL.md

@@ -29,3 +29,16 @@ description: End a connected Jentrix session after preserving approved outputs,
    the command and must not be claimed as captured.
 8. The Jentrix session is sealed after end; do not retry pushes against it. Ending it
    does not terminate the Codex task.
+
+**Evidence floor.** `jentrix session end` REFUSES to close on unmet checks: E1 —
+HEAD moved but no attested DIFF (the CLI pushes the real patch itself; re-run
+`session end` from the aligned checkout); E2 — commits with no `jentrix push
+decision` and no declared-deviation `jentrix push gap`; E3 — a REPORT carrying
+`## Learnings` / `## Gaps` / `## Decisions` sections while the session has zero
+corresponding typed artifacts (split them into `push learning|gap|decision`).
+Comply by pushing the named evidence and retrying, or deviate honestly with a
+`gap`; `--acknowledge-evidence-gaps` closes anyway and stamps each unmet check
+MISSING into Review readiness. Run every gate through
+`jentrix push log --from-cmd "<command>"` (records exit code + output tail as a
+LOG, exits with the command's own code) so gate claims carry evidence instead of
+tripping the E4 advisory.

package/codex-plugin/plugins/jentrix/skills/jentrix-status/SKILL.md

@@ -8,4 +8,8 @@ description: Show the connected Jentrix session, alignment, capture health, and
 
 Run `jentrix session status` and append the session id when the user supplied one.
 Relay stdout and stderr verbatim, including capture or telemetry warnings. Never turn
-null token values into zero or infer provider usage that the hooks did not report.
+null token values into zero or infer provider usage that Codex did not report.
+`coverage: COMPLETE` describes provider token-receipt coverage only; it does not prove
+the lifecycle hooks ran. If the session uses the exact-rollout fallback, report that
+prompt/tool/assistant lifecycle evidence is unavailable and point to `/hooks` plus a
+new Codex task for future full coverage.

package/dist/main.js

@@ -10324,7 +10324,7 @@ var require_dist = __commonJS({
 });
 
 // src/main.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { createInterface } from "node:readline";
 import {
   appendFileSync,
@@ -20966,7 +20966,7 @@ function refreshAccessToken(input) {
 
 // src/client.ts
 var CLI_NAME = "stacks-cli";
-var CLI_VERSION = "0.5.19";
+var CLI_VERSION = "0.5.21";
 var DEAD_TOKEN_MESSAGE = "authentication failed (HTTP 401): the token is dead or expired \u2014 mint a new PAT at /account/tokens on your Jentrix server and update STACKS_TOKEN (or --token / the config file).";
 var RELOGIN_MESSAGE = "OAuth session expired and could not be refreshed \u2014 run `jentrix login` to sign in again.";
 function originOf2(url2) {
@@ -21302,6 +21302,7 @@ function safeStringify(value) {
 }
 
 // src/commands/push.ts
+import { spawn as spawn2 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
 
 // src/align-questions.ts
@@ -22584,8 +22585,9 @@ async function runSessionStart(provider, flags, deps2) {
         // outlives the CLI holding a dead credential.
         bearer: deps2.resolveTarget().token,
         // …and the config file itself, so the host FOLLOWS later rotations
-        // instead of dying with a revoked snapshot (2026-08-08 finding).
-        configPath: deps2.configPath,
+        // instead of dying with a revoked snapshot (2026-08-08 finding) —
+        // but ONLY when the token IS the config's (hostConfigPathOf).
+        configPath: hostConfigPathOf(deps2),
         repoRoot: inspection.root,
         installationId,
         mode: "launch",
@@ -22663,6 +22665,23 @@ function hooksDir(deps2, provider) {
 function codexHooksDir(deps2) {
   return hooksDir(deps2, "codex");
 }
+function readCodexRolloutPath(deps2, sessionId) {
+  const configuredHome = deps2.env.CODEX_HOME?.trim() || null;
+  const userHome = deps2.env.HOME ?? deps2.env.USERPROFILE;
+  const home = configuredHome ?? (userHome ? join2(userHome, ".codex") : null);
+  if (!home) return null;
+  const root = join2(home, "sessions");
+  const suffix = `-${sessionId}.jsonl`;
+  try {
+    const relative = readdirSync(root, {
+      encoding: "utf8",
+      recursive: true
+    }).find((path) => path.endsWith(suffix));
+    return relative ? join2(root, relative) : null;
+  } catch {
+    return null;
+  }
+}
 function readClaudeHookContext(deps2, readFile = (path) => readFileSync2(path, "utf8"), mtimeOf = transcriptMtime, now = Date.now) {
   const own = deps2.env[CLAUDE_SESSION_ENV]?.trim() || null;
   const home = deps2.env.HOME ?? deps2.env.USERPROFILE;
@@ -22744,11 +22763,12 @@ function readCodexHookContext(deps2, readFile = (path) => readFileSync2(path, "u
   const { starts, endedAt } = ledger;
   if (own) {
     const source = threadId ? CODEX_THREAD_ENV : CODEX_SESSION_ENV;
-    const transcriptPath = transcriptForSessionIn(ledger, own);
+    const hookTranscript = transcriptForSessionIn(ledger, own);
+    const transcriptPath = hookTranscript ?? readCodexRolloutPath(deps2, own);
     return {
       sessionId: own,
       transcriptPath,
-      basis: `${source}=${own} \u2014 this Codex task's own id${transcriptPath ? " (rollout from its hook record)" : ""}`,
+      basis: `${source}=${own} \u2014 this Codex task's own id${hookTranscript ? " (rollout from its hook record)" : transcriptPath ? " (rollout resolved from Codex sessions)" : ""}`,
       newerElsewhere: null
     };
   }
@@ -22771,7 +22791,7 @@ function readCodexHookContext(deps2, readFile = (path) => readFileSync2(path, "u
   const match = matches[0];
   return match ? {
     sessionId: match.sessionId,
-    transcriptPath: transcriptForSessionIn(ledger, match.sessionId),
+    transcriptPath: transcriptForSessionIn(ledger, match.sessionId) ?? readCodexRolloutPath(deps2, match.sessionId),
     basis: `unambiguous SessionStart${match.at ? ` at ${match.at}` : ""} in ${match.cwd}`,
     newerElsewhere: null
   } : null;
@@ -22861,6 +22881,8 @@ async function runSessionAttach(flags, deps2) {
       }
     } else if (flags.provider === "claude" && flags.providerSession && !flags.transcriptPath) {
       flags.transcriptPath = readClaudeHookTranscript(deps2, flags.providerSession) ?? void 0;
+    } else if (flags.provider === "codex" && flags.providerSession && !flags.transcriptPath) {
+      flags.transcriptPath = readCodexRolloutPath(deps2, flags.providerSession) ?? void 0;
     }
     if (flags.provider === "codex") hookDir = codexHooksDir(deps2);
     if (!flags.providerSession) {
@@ -22924,8 +22946,9 @@ async function runSessionAttach(flags, deps2) {
           // outlives the CLI holding a dead credential.
           bearer: deps2.resolveTarget().token,
           // …and the config file itself, so the host FOLLOWS later rotations
-          // instead of dying with a revoked snapshot (2026-08-08 finding).
-          configPath: deps2.configPath,
+          // instead of dying with a revoked snapshot (2026-08-08 finding) —
+          // but ONLY when the token IS the config's (hostConfigPathOf).
+          configPath: hostConfigPathOf(deps2),
           repoRoot: inspection.root,
           installationId,
           mode: "watch",
@@ -23006,6 +23029,8 @@ async function runSessionStatus(sessionId, flags, deps2) {
           `Project: ${String(session.projectName)} (${String(session.projectId)})`,
           `Repository: ${String(session.repoOwnerName)}`,
           `Capture: ${capture}`,
+          // Evidence floor (D3): the skeleton mode the alignment declared.
+          `Skeleton: ${session.alignment?.skeleton === "off" ? "off (--no-skeleton at align)" : "on (content-free activity counts/timing)"}`,
           ...local,
           telemetry.line,
           `Summary artifact: ${session.summaryArtifactId ? String(session.summaryArtifactId) : "\u2014"}`
@@ -23102,6 +23127,87 @@ function telemetryVerdict(sessionId, usage, hostRan, provider = "claude") {
     warning: `NO TOKEN TELEMETRY: no local session host ever ran for ${sessionId}, so nothing could collect provider usage receipts. Align from inside the provider session (the plugin's hooks record the transcript), or pass --transcript-path.`
   };
 }
+function hostConfigPathOf(deps2) {
+  const source = deps2.resolveTarget().tokenSource;
+  return source === void 0 || source === "file" ? deps2.configPath : null;
+}
+var MAX_ATTESTED_DIFF_BYTES = 256 * 1024;
+async function buildAttestedDiffBody(git, root, startHead, endHead, dirty) {
+  const counted = await git(
+    ["rev-list", "--count", `${startHead}..${endHead}`],
+    root
+  );
+  if (counted.code !== 0) return null;
+  const commitCount = Number(counted.stdout.trim());
+  if (!Number.isFinite(commitCount) || commitCount === 0) return null;
+  const header = [
+    "Attested delivery \u2014 generated by `jentrix session end` from the aligned checkout (source: cli).",
+    `Range: ${startHead}..${endHead} \xB7 ${commitCount} commit(s)`,
+    ""
+  ].join("\n");
+  const cap = MAX_ATTESTED_DIFF_BYTES - Buffer.byteLength(header, "utf8");
+  const full = await git(
+    ["log", "--patch", "--stat", `${startHead}..${endHead}`],
+    root
+  );
+  let body;
+  if (full.code === 0 && Buffer.byteLength(full.stdout, "utf8") <= cap) {
+    body = full.stdout;
+  } else {
+    const stat = await git(["log", "--stat", `${startHead}..${endHead}`], root);
+    const notice = "[truncated stat-first: the full --patch output exceeded the 256 KB attested-diff cap \u2014 commit list + per-file stat retained; the full patch lives in git]\n\n";
+    let kept = stat.code === 0 ? stat.stdout : "(git log --stat failed)";
+    const room = cap - Buffer.byteLength(notice, "utf8");
+    if (Buffer.byteLength(kept, "utf8") > room) {
+      kept = Buffer.from(kept, "utf8").subarray(0, Math.max(0, room - 64)).toString("utf8").replace(/�+$/, "") + "\n[stat tail truncated at the cap]";
+    }
+    body = notice + kept;
+  }
+  if (dirty) {
+    const delta = await git(["diff", "--stat", "HEAD"], root);
+    body += `
+
+Uncommitted delta at end (stat only \u2014 not part of the attested range):
+${delta.code === 0 && delta.stdout.trim() ? delta.stdout : "(unreadable or empty)"}`;
+  }
+  return { body: header + body, commitCount };
+}
+async function postAttestedArtifact(deps2, sessionId, input) {
+  const credentials = deps2.resolveTarget();
+  try {
+    const response = await (deps2.fetchImpl ?? fetch)(
+      new URL(
+        `/api/agent-sessions/${sessionId}/artifacts`,
+        stacksBaseUrlOf(credentials.url)
+      ),
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${credentials.token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          kind: input.kind,
+          title: input.title,
+          body: redactLocal(input.body, deps2.env),
+          attested: true
+        })
+      }
+    );
+    const payload = await response.json().catch(() => ({}));
+    return response.ok ? { ok: true, artifactId: payload.artifactId ?? null, detail: null } : {
+      ok: false,
+      artifactId: null,
+      detail: payload.detail ?? payload.error ?? `HTTP ${response.status}`
+    };
+  } catch (error2) {
+    return {
+      ok: false,
+      artifactId: null,
+      detail: error2 instanceof Error ? error2.message : "network failure"
+    };
+  }
+}
 async function runSessionEnd(sessionIdFlag, flags, deps2) {
   try {
     const inspection = await inspectRepository(deps2.cwd(), deps2.git);
@@ -23168,6 +23274,39 @@ async function runSessionEnd(sessionIdFlag, flags, deps2) {
         );
       }
       const sessionId = resolved;
+      let commitCount = null;
+      try {
+        const row = await call(caller, "get_agent_session", { sessionId });
+        const startHead = typeof row.startHead === "string" ? row.startHead : null;
+        const attestRepo = inspection && inspection.repoOwnerName === row.repoOwnerName ? inspection : null;
+        if (attestRepo?.head && startHead && attestRepo.head !== startHead && (row.status === "ACTIVE" || row.status === "STARTING")) {
+          const built = await buildAttestedDiffBody(
+            deps2.git ?? defaultGitRunner,
+            attestRepo.root,
+            startHead,
+            attestRepo.head,
+            attestRepo.dirty
+          );
+          if (built) {
+            commitCount = built.commitCount;
+            const pushed = await postAttestedArtifact(deps2, sessionId, {
+              kind: "diff",
+              title: `Attested diff ${startHead.slice(0, 10)}..${attestRepo.head.slice(0, 10)} (${built.commitCount} commit${built.commitCount === 1 ? "" : "s"})`,
+              body: built.body
+            });
+            if (pushed.ok) {
+              deps2.writeOut(
+                `Attested diff pushed \u2192 artifact ${pushed.artifactId ?? "(unknown)"} (${built.commitCount} commit(s), source: cli)`
+              );
+            } else {
+              deps2.writeErr(
+                `note: attested diff push failed (${pushed.detail}) \u2014 the E1 delivery check will refuse the close; retry \`jentrix session end\`, or acknowledge with --acknowledge-evidence-gaps.`
+              );
+            }
+          }
+        }
+      } catch {
+      }
       const hostRan = hasLocalCaptureFootprint(deps2, sessionId);
       const reportTelemetry = (row) => {
         const verdict2 = telemetryVerdict(
@@ -23253,6 +23392,11 @@ async function runSessionEnd(sessionIdFlag, flags, deps2) {
         endHead: sameRepo?.head ?? null,
         endDirty: sameRepo?.dirty ?? null,
         ...spooledUsage ? { usage: spooledUsage } : {},
+        // Evidence floor (§5/§6): the CLI-counted commits in the range feed
+        // E2 and the summary's density line; the acknowledge flag closes over
+        // unmet checks with each stamped MISSING into Review readiness.
+        ...commitCount !== null ? { commitCount } : {},
+        ...flags.acknowledgeEvidenceGaps ? { acknowledgeEvidenceGaps: true } : {},
         expectedUpdatedAt: session.updatedAt
       });
       if (inspection) {
@@ -23586,6 +23730,12 @@ function reportError(error2, deps2) {
   }
   const message = error2 instanceof Error ? error2.message : String(error2);
   deps2.writeErr(`error: ${message}`);
+  if (message.includes("EVIDENCE_FLOOR")) {
+    deps2.writeErr(
+      "To close anyway with the unmet checks stamped MISSING: `jentrix session end --acknowledge-evidence-gaps` (a declared deviation is an ordinary `jentrix push gap`)."
+    );
+    return EXIT_CODES.CONFLICT;
+  }
   if (message.includes("SESSION_ALREADY_BOUND")) return EXIT_CODES.CONFLICT;
   if (message.includes("FORBIDDEN") || message.includes("PROJECT_DISCOVERY_REQUIRES_UNPINNED_LOGIN")) {
     return EXIT_CODES.FORBIDDEN;
@@ -23641,7 +23791,12 @@ function registerSessionCommand(program3, deps2, onExit2) {
   ).option("--json", "stable JSON output").action(
     async (sessionId, flags) => onExit2(await runSessionStatus(sessionId, flags, deps2))
   );
-  session.command("end [sessionId]").description("Close a session, verify capture, and store the RUN_SUMMARY.").option("--json", "stable JSON output").action(
+  session.command("end [sessionId]").description(
+    "Close a session, verify capture, and store the RUN_SUMMARY. Pushes the attested delivery patch when HEAD moved, and enforces the evidence-floor checks E1\u2013E4 (refusal names each unmet check and its fix)."
+  ).option("--json", "stable JSON output").option(
+    "--acknowledge-evidence-gaps",
+    "close even with unmet evidence-floor checks \u2014 each unmet check is stamped MISSING into the summary's Review readiness"
+  ).action(
     async (sessionId, flags) => onExit2(await runSessionEnd(sessionId, flags, deps2))
   );
   return session;
@@ -23890,10 +24045,11 @@ function sessionBindingCheck(detected) {
 function detectProvider(flags, deps2) {
   if (flags.provider === "codex") {
     const hook2 = flags.providerSession ? null : readCodexHookContext(deps2);
+    const providerSessionId = flags.providerSession ?? hook2?.sessionId ?? null;
     return {
       provider: "codex",
-      providerSessionId: flags.providerSession ?? hook2?.sessionId ?? null,
-      transcriptPath: flags.transcriptPath ?? hook2?.transcriptPath ?? null,
+      providerSessionId,
+      transcriptPath: flags.transcriptPath ?? hook2?.transcriptPath ?? (providerSessionId ? readCodexRolloutPath(deps2, providerSessionId) : null),
       basis: flags.providerSession ? `codex thread ${flags.providerSession} (explicit)` : hook2?.basis ?? null,
       newerElsewhere: null,
       transcriptGap: null,
@@ -24276,9 +24432,13 @@ ${JSON.stringify(session.alignment, null, 2)}`
     } : {},
     ...budget !== null ? { tokenBudget: budget } : {},
     capture: captureMode,
+    // Evidence floor (D3): only an explicit --no-skeleton is sent; absent
+    // lets the server keep the stored mode (default "on").
+    ...flags.skeleton === false ? { skeleton: "off" } : {},
     expectedUpdatedAt: session.updatedAt
   });
   const alignment = aligned.alignment;
+  const skeletonMode = alignment.skeleton === "off" ? "off" : "on";
   writeAlignmentMarker(
     deps2.configPath,
     inspection.root,
@@ -24326,8 +24486,9 @@ ${JSON.stringify(session.alignment, null, 2)}`
       mcpUrl: target.url,
       bearer: deps2.resolveTarget().token,
       // …and the config file itself, so the host FOLLOWS later rotations
-      // instead of dying with a revoked snapshot (2026-08-08 finding).
-      configPath: deps2.configPath,
+      // instead of dying with a revoked snapshot (2026-08-08 finding) —
+      // but ONLY when the token IS the config's (hostConfigPathOf).
+      configPath: hostConfigPathOf(deps2),
       repoRoot: inspection.root,
       installationId,
       mode: "watch",
@@ -24335,6 +24496,7 @@ ${JSON.stringify(session.alignment, null, 2)}`
       ...detected.transcriptPath ? { transcriptPath: detected.transcriptPath } : {},
       ...detected.hookDir ? { hookDir: detected.hookDir } : {},
       captureTrace: captureMode === "on",
+      collectSkeleton: skeletonMode === "on",
       spoolRoot: deps2.spoolRoot
     });
     if (pid !== null) {
@@ -24809,6 +24971,7 @@ async function runAlign(flags, deps2) {
             `  Agent:     ${a.agent?.provider ?? "\u2014"}`,
             `  Repo:      ${a.repo?.ownerName ?? "\u2014"}@${a.repo?.branch ?? "detached"}`,
             `  Capture:   ${a.capture ?? "off"}`,
+            `  Skeleton:  ${a.skeleton ?? "on"} (content-free activity counts/timing; --no-skeleton opts out)`,
             `Alignment snapshot (server-confirmed): ${JSON.stringify(result.alignment)}`
           ].join("\n")
         );
@@ -24873,6 +25036,9 @@ function registerAlignCommand(program3, deps2, onExit2) {
   ).option(
     "--no-capture",
     "keep TRACE capture OFF explicitly \u2014 also corrects a wrongly-on record on re-align"
+  ).option(
+    "--no-skeleton",
+    "opt out of the content-free activity skeleton (event/tool counts, files-touched, timing buckets) for this session \u2014 default on, independent of capture"
   ).addOption(
     new Option(
       "--provider <provider>",
@@ -24910,7 +25076,8 @@ var PUSH_KINDS = [
   "prd",
   "gap",
   "issue",
-  "context"
+  "context",
+  "log"
 ];
 var ARTIFACT_TYPE_BY_PUSH_KIND = {
   plan: "PLAN",
@@ -24925,8 +25092,23 @@ var ARTIFACT_TYPE_BY_PUSH_KIND = {
   prd: "PRD",
   gap: "GAP",
   issue: "ISSUE",
-  context: "SOURCE_DIGEST"
+  context: "SOURCE_DIGEST",
+  log: "LOG"
 };
+var MAX_FROM_CMD_OUTPUT_BYTES = 64 * 1024;
+function fromCmdLogBody(command, exitCode, output) {
+  const header = `$ ${command}
+exit code: ${exitCode}
+
+`;
+  if (Buffer.byteLength(output, "utf8") <= MAX_FROM_CMD_OUTPUT_BYTES) {
+    return header + (output || "(no output)");
+  }
+  const notice = `[head truncated: output exceeded ${MAX_FROM_CMD_OUTPUT_BYTES / 1024} KB \u2014 tail retained]
+`;
+  const tail = Buffer.from(output, "utf8").subarray(-MAX_FROM_CMD_OUTPUT_BYTES).toString("utf8").replace(/^�+/, "");
+  return header + notice + tail;
+}
 function sessionTarget(sessionId) {
   return {
     path: `/api/agent-sessions/${sessionId}/artifacts`,
@@ -24936,6 +25118,32 @@ function sessionTarget(sessionId) {
 function taskTarget(taskId) {
   return { path: `/api/tasks/${taskId}/artifacts`, label: `task ${taskId}` };
 }
+function defaultRunCommand(command) {
+  return new Promise((resolve5) => {
+    const child = spawn2(command, { shell: true, windowsHide: true });
+    let tail = Buffer.alloc(0);
+    const keep = (chunk) => {
+      tail = Buffer.concat([tail, chunk]);
+      if (tail.byteLength > MAX_FROM_CMD_OUTPUT_BYTES * 2) {
+        tail = tail.subarray(-MAX_FROM_CMD_OUTPUT_BYTES);
+      }
+    };
+    child.stdout?.on("data", keep);
+    child.stderr?.on("data", keep);
+    child.once(
+      "error",
+      (error2) => resolve5({ code: 127, output: `${error2.message}
+` })
+    );
+    child.once(
+      "exit",
+      (code, signal) => resolve5({
+        code: code ?? (signal ? 130 : 1),
+        output: tail.toString("utf8")
+      })
+    );
+  });
+}
 async function drainStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -24955,6 +25163,21 @@ async function runPush(kind, file, flags, deps2) {
         "--basis records what a decision rested on \u2014 it only applies to `jentrix push decision`"
       );
     }
+    if (flags.fromCmd !== void 0) {
+      if (kind !== "log") {
+        throw new UsageError(
+          '--from-cmd captures a command\'s exit code and output as a LOG \u2014 it only applies to `jentrix push log --from-cmd "<command>"`'
+        );
+      }
+      if (file || flags.ref) {
+        throw new UsageError(
+          "--from-cmd generates the LOG body from the command run \u2014 drop the file/--ref"
+        );
+      }
+      if (!flags.fromCmd.trim()) {
+        throw new UsageError("--from-cmd needs a non-empty command");
+      }
+    }
     if (flags.ref) {
       if (flags.basis?.length) {
         throw new UsageError(
@@ -25007,7 +25230,17 @@ async function runPush(kind, file, flags, deps2) {
       correlatedSessionId = marker.sessionId;
       fallbackTaskId = marker.taskId;
     }
-    const raw = file ? readFileSync4(file, "utf8") : await (deps2.readStdin ?? drainStdin)();
+    let commandExit = null;
+    let raw;
+    if (flags.fromCmd !== void 0) {
+      const command = flags.fromCmd.trim();
+      deps2.writeErr(`running: ${command}`);
+      const ran = await (deps2.runCommand ?? defaultRunCommand)(command);
+      commandExit = ran.code;
+      raw = fromCmdLogBody(command, ran.code, ran.output);
+    } else {
+      raw = file ? readFileSync4(file, "utf8") : await (deps2.readStdin ?? drainStdin)();
+    }
     if (!raw.trim()) {
       throw new UsageError(
         file ? `${file} is empty` : "stdin is empty \u2014 pipe the content or name a file"
@@ -25031,6 +25264,9 @@ ${raw}` : raw;
           ...flags.title ? { title: flags.title } : {},
           ...flags.agent ? { producerLabel: flags.agent } : {},
           ...flags.agentEmoji ? { producerEmoji: flags.agentEmoji } : {},
+          // D4: only the CLI-generated capture is attested — never a piped
+          // body, whatever its kind.
+          ...commandExit !== null ? { attested: true } : {},
           body
         })
       }
@@ -25086,7 +25322,12 @@ ${raw}` : raw;
     if (isMintableKind(kind) && payload.taskId) {
       await offerCardMint(kind, payload, flags, deps2, correlatedSessionId);
     }
-    return 0;
+    if (commandExit !== null && commandExit !== 0) {
+      deps2.writeErr(
+        `command exited ${commandExit} \u2014 recorded in the LOG; exiting with the command's code`
+      );
+    }
+    return commandExit ?? 0;
   } catch (error2) {
     if (error2 instanceof UsageError) {
       deps2.writeErr(`error: ${error2.message}`);
@@ -25400,6 +25641,9 @@ function registerPushCommand(program3, deps2, onExit2) {
   ).option(
     "--blocks",
     "with --yes on a findings/gap/issue push: the minted card BLOCKS the aligned task (acceptance-blocking) instead of RELATES_TO"
+  ).option(
+    "--from-cmd <command>",
+    `log pushes only: run the command locally, capture exit code + a 64 KB tail-biased output tail, and push an ATTESTED LOG opening with both \u2014 then exit with the command's own code ("tests green" claims carry evidence)`
   ).option("--json", "stable JSON output").action(
     async (kind, file, flags) => onExit2(await runPush(kind, file, flags, deps2))
   );
@@ -27754,7 +27998,7 @@ function registerPluginCommand(program3, deps2, onExit2) {
 }
 
 // src/commands/runner.ts
-import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
+import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
 import { constants, promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, resolve as resolve3 } from "node:path";
@@ -28188,7 +28432,7 @@ function runRunnerForeground(file, args) {
   }
   const target = execTarget(file, args);
   return new Promise((resolveRun, reject) => {
-    const child = spawn2(target.file, target.args, {
+    const child = spawn3(target.file, target.args, {
       stdio: "inherit",
       ...target.options
     });
@@ -29202,7 +29446,11 @@ var sessionDeps = {
   configPath: CONFIG_PATH,
   resolveTarget: () => {
     const target = resolveConfig({ env: process.env, file: configFile() });
-    return { token: target.token, url: target.url };
+    return {
+      token: target.token,
+      url: target.url,
+      tokenSource: target.tokenSource
+    };
   },
   ensureInstallationId: () => ensureInstallationId(HOME_CONFIG_PATH),
   connect: async (target) => {
@@ -29225,7 +29473,7 @@ var sessionDeps = {
       planPath
     ]);
     try {
-      const child = spawn3(target.file, target.args, {
+      const child = spawn4(target.file, target.args, {
         detached: true,
         stdio: ["ignore", fd, fd],
         ...target.options

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jentrix/cli",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "Command-line client for the Jentrix MCP surface (jentrix tool <name>, generated noun-verb commands).",
   "keywords": [
     "jentrix",

package/surface.json

@@ -463,6 +463,14 @@
             "minLength": 1,
             "type": "string"
           },
+          "skeleton": {
+            "description": "Activity-skeleton mode the CLI declared for this session (--no-skeleton). Default on, independent of capture.",
+            "enum": [
+              "on",
+              "off"
+            ],
+            "type": "string"
+          },
           "taskId": {
             "anyOf": [
               {
@@ -1655,6 +1663,10 @@
       "description": "Close a session with an honest lifecycle outcome (COMPLETED normal end / INTERRUPTED crash / CANCELLED pre-first-turn abort). The server verifies the trace-part manifest against durable artifacts, stores the deterministic RUN_SUMMARY, and sets captureComplete ONLY when every expected part and the summary are acknowledged — lifecycle and capture integrity stay orthogonal. Requires expectedUpdatedAt (CAS).",
       "inputSchema": {
         "properties": {
+          "acknowledgeEvidenceGaps": {
+            "description": "Close even with unmet evidence-floor checks (E1–E3); each unmet check is stamped MISSING into the summary's Review readiness.",
+            "type": "boolean"
+          },
           "captureError": {
             "anyOf": [
               {
@@ -1666,6 +1678,19 @@
               }
             ]
           },
+          "commitCount": {
+            "anyOf": [
+              {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "description": "CLI-counted commits in startHead..endHead; absent = not counted (HEAD movement is then the only signal)."
+          },
           "endBranch": {
             "anyOf": [
               {