@jentrix/cli 0.5.20 → 0.5.22

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,6 +1,6 @@
 {
   "name": "jentrix",
-  "version": "0.2.5",
+  "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",

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-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/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.20";
+var CLI_VERSION = "0.5.22";
 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
@@ -21387,6 +21388,9 @@ function buildAlignDisclosures(catalog) {
   disclosures.push(
     catalog.captureMode === "on" ? "TRACE capture: ON \u2014 the full transcript will be recorded" : "TRACE capture: OFF (MVP default) \u2014 typed artifacts only, no transcript"
   );
+  disclosures.push(
+    catalog.skeletonMode === "on" ? "activity skeleton: ON (default) \u2014 content-free counts/timing (turns, tool names, files-touched), independent of capture; --no-skeleton opts out" : "activity skeleton: OFF \u2014 no counts, no timing, no files-touched; the session's Session activity section will read as not observed"
+  );
   disclosures.push("write the local alignment marker for this checkout");
   const mcp = catalog.mcpConfig;
   if (mcp && mcp.action !== "unchanged") {
@@ -22449,20 +22453,39 @@ function readLiveHostMarker(deps2, sessionId) {
     return null;
   }
 }
-async function waitForHostExit(deps2, sessionId, pid, timeoutMs) {
+async function waitForHostEnd(deps2, sessionId, pid, timeoutMs) {
   const sleep = deps2.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const path = join2(deps2.spoolRoot, sessionId, "host.json");
+  const dir = join2(deps2.spoolRoot, sessionId);
+  const path = join2(dir, "host.json");
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     await sleep(500);
+    const refusal = readEndRefusal(deps2, sessionId);
+    if (refusal) return { kind: "refused", message: refusal };
     try {
       const marker = JSON.parse(readFileSync2(path, "utf8"));
-      if (marker.exitedAt) return true;
+      if (marker.exitedAt) return { kind: "exited" };
     } catch {
     }
-    if (!(deps2.isPidAlive ?? defaultIsPidAlive)(pid)) return false;
+    if (!(deps2.isPidAlive ?? defaultIsPidAlive)(pid)) return { kind: "gone" };
+  }
+  return { kind: "gone" };
+}
+function readEndRefusal(deps2, sessionId) {
+  try {
+    const marker = JSON.parse(
+      readFileSync2(join2(deps2.spoolRoot, sessionId, "end-refusal.json"), "utf8")
+    );
+    return typeof marker.message === "string" && marker.message.trim() ? marker.message : null;
+  } catch {
+    return null;
+  }
+}
+function clearEndRefusal(deps2, sessionId) {
+  try {
+    unlinkSync(join2(deps2.spoolRoot, sessionId, "end-refusal.json"));
+  } catch {
   }
-  return false;
 }
 function localCaptureLines(deps2, sessionId, serverStatus) {
   const dir = join2(deps2.spoolRoot, sessionId);
@@ -22584,8 +22607,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",
@@ -22944,8 +22968,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",
@@ -23026,6 +23051,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"}`
@@ -23122,6 +23149,85 @@ 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;
+  }
+  let uncommitted = null;
+  if (dirty) {
+    const delta = await git(["diff", "--stat", "HEAD"], root);
+    uncommitted = delta.code === 0 && delta.stdout.trim() ? delta.stdout.trim() : null;
+  }
+  return { body: header + body, commitCount, uncommitted };
+}
+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);
@@ -23188,6 +23294,45 @@ 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)`
+              );
+              if (built.uncommitted) {
+                deps2.writeOut(
+                  `note: uncommitted delta at end (stat only \u2014 not part of the attested range):
+${built.uncommitted}`
+                );
+              }
+            } 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(
@@ -23201,21 +23346,32 @@ async function runSessionEnd(sessionIdFlag, flags, deps2) {
       };
       const live = readLiveHostMarker(deps2, sessionId);
       if (live) {
+        clearEndRefusal(deps2, sessionId);
         writeFileSync2(
           join2(deps2.spoolRoot, sessionId, "end-request.json"),
-          JSON.stringify({ requestedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+          JSON.stringify({
+            requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // JEN-167: the host closes the session, so the operator's
+            // acknowledgement has to travel with the request — otherwise the
+            // floor refuses a close they explicitly asked to force. The
+            // CLI-counted commits ride along for the same reason: only the
+            // CLI can count them, and the host's close is the one that lands.
+            ...flags.acknowledgeEvidenceGaps ? { acknowledgeEvidenceGaps: true } : {},
+            ...commitCount !== null ? { commitCount } : {}
+          }),
           { mode: 384 }
         );
         deps2.writeOut(
           `Local capture host (pid ${live.pid}) is finalizing capture\u2026`
         );
-        const finished = await waitForHostExit(
-          deps2,
-          sessionId,
-          live.pid,
-          9e4
-        );
-        if (finished) {
+        const outcome = await waitForHostEnd(deps2, sessionId, live.pid, 9e4);
+        if (outcome.kind === "refused") {
+          deps2.writeErr(
+            `local capture host (pid ${live.pid}) is still running \u2014 the skeleton, heartbeats and telemetry keep accumulating through the comply work; re-run \`jentrix session end ${sessionId}\` once the evidence is pushed`
+          );
+          throw new Error(outcome.message);
+        }
+        if (outcome.kind === "exited") {
           const final = await call(caller, "get_agent_session", { sessionId });
           const stillOpen = final.status === "STARTING" || final.status === "ACTIVE";
           if (!stillOpen) {
@@ -23273,6 +23429,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) {
@@ -23606,6 +23767,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;
@@ -23661,7 +23828,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;
@@ -24050,6 +24222,9 @@ async function buildCatalog(caller, flags, detection) {
     // checkout root); defaults here are the no-live-host reading.
     liveHostPid: null,
     captureMode: decideCaptureMode(flags.capture, false),
+    // JEN-169: only `--no-skeleton` acts (the same rule submit applies at
+    // line ~1273), so the disclosure needs no server round trip.
+    skeletonMode: flags.skeleton === false ? "off" : "on",
     producer: producerFromFlags(flags),
     tokenBudget: budgetFromFlags(flags),
     preconditionNotices: [],
@@ -24297,9 +24472,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,
@@ -24347,8 +24526,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",
@@ -24356,6 +24536,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) {
@@ -24830,6 +25011,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")
         );
@@ -24894,6 +25076,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>",
@@ -24931,7 +25116,8 @@ var PUSH_KINDS = [
   "prd",
   "gap",
   "issue",
-  "context"
+  "context",
+  "log"
 ];
 var ARTIFACT_TYPE_BY_PUSH_KIND = {
   plan: "PLAN",
@@ -24946,8 +25132,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`,
@@ -24957,6 +25158,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) {
@@ -24976,6 +25203,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(
@@ -25028,7 +25270,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"
@@ -25052,6 +25304,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
         })
       }
@@ -25107,7 +25362,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}`);
@@ -25421,6 +25681,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))
   );
@@ -26351,6 +26614,10 @@ function parseArgsJson(raw, source) {
   }
   return { ok: true, value: parsed };
 }
+function workspaceIdShapeError(value) {
+  if (/^[a-z0-9]{20,}$/.test(value)) return null;
+  return `workspaceId "${value}" is not a workspace id (ids look like "cmt2cuhyo000004l38ddsim1y"). Find yours with \`jentrix workspace list\`, set it once as \`defaults.workspace\` in the config file, or use \`jentrix align --workspace <id-or-slug>\` \u2014 align is the command that accepts a slug.`;
+}
 async function runToolCommand(name, flags, deps2) {
   const maxWaitSeconds = Number(flags.maxWait);
   if (!Number.isFinite(maxWaitSeconds) || maxWaitSeconds < 0) {
@@ -26387,6 +26654,14 @@ async function runToolCommand(name, flags, deps2) {
     deps2.writeErr(`error: ${parsed.error}`);
     return EXIT_CODES.INVALID_INPUT;
   }
+  const workspaceId = parsed.value.workspaceId;
+  if (typeof workspaceId === "string") {
+    const shapeError = workspaceIdShapeError(workspaceId);
+    if (shapeError) {
+      deps2.writeErr(`error: ${shapeError}`);
+      return EXIT_CODES.INVALID_INPUT;
+    }
+  }
   let config2;
   try {
     config2 = resolveConfig({
@@ -27775,7 +28050,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";
@@ -28209,7 +28484,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
     });
@@ -29223,7 +29498,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) => {
@@ -29246,7 +29525,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.20",
+  "version": "0.5.22",
   "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": [
               {