@jentrix/cli 0.5.21 → 0.5.23

package/dist/main.js

@@ -20966,7 +20966,7 @@ function refreshAccessToken(input) {
 
 // src/client.ts
 var CLI_NAME = "stacks-cli";
-var CLI_VERSION = "0.5.21";
+var CLI_VERSION = "0.5.23";
 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) {
@@ -21386,7 +21386,10 @@ function buildAlignDisclosures(catalog) {
     catalog.liveHostPid !== null ? `keep the live session host (pid ${catalog.liveHostPid}) running` : "start a detached session host (heartbeats + provider usage receipts)"
   );
   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"
+    catalog.captureMode === "on" ? "TRACE capture: ON \u2014 the full transcript will be recorded" : catalog.captureMode === "off" ? "TRACE capture: OFF \u2014 typed artifacts only, no transcript" : "TRACE capture: your account default (Account \u2192 Capture; the built-in is OFF \u2014 typed artifacts only). The confirmed value is printed after the align; --capture/--no-capture decides it here instead"
+  );
+  disclosures.push(
+    catalog.skeletonMode === "on" ? "activity skeleton: ON \u2014 content-free counts/timing (turns, tool names, files-touched), independent of capture; --no-skeleton opts out" : catalog.skeletonMode === "off" ? "activity skeleton: OFF \u2014 no counts, no timing, no files-touched; the session's Session activity section will read as not observed" : "activity skeleton: your account default (Account \u2192 Capture; the built-in is ON \u2014 content-free counts/timing). The confirmed value is printed after the align; --skeleton/--no-skeleton decides it here instead"
   );
   disclosures.push("write the local alignment marker for this checkout");
   const mcp = catalog.mcpConfig;
@@ -22004,6 +22007,10 @@ function upsertAlignmentMarker(file, providerSessionId, marker) {
   sessions[providerSessionId] = marker;
   return { version: 2, sessions, latest: providerSessionId };
 }
+function findAlignmentMarkerForSession(file, sessionId) {
+  if (!file) return null;
+  return Object.values(file.sessions).find((m) => m.sessionId === sessionId) ?? null;
+}
 function removeAlignmentMarkerEntry(file, sessionId) {
   if (!file) return null;
   const sessions = Object.fromEntries(
@@ -22450,20 +22457,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);
@@ -23013,6 +23039,13 @@ async function runSessionStatus(sessionId, flags, deps2) {
       const deadLocal = open && boundHere && !hasLocalCaptureFootprint(deps2, sessionId);
       const captureOff = session.alignment?.capture === "off";
       const capture = captureOff ? "off (MVP alignment \u2014 typed artifacts only)" : session.captureComplete ? "complete" : deadLocal ? "bound server-side; local capture NOT RUNNING" : open ? "recording (finalizes when the session ends)" : `INCOMPLETE${session.captureError ? ` \u2014 ${String(session.captureError)}` : ""}`;
+      const inspection = await inspectRepository(deps2.cwd(), deps2.git);
+      const alignMarker = inspection ? findAlignmentMarkerForSession(
+        readAlignmentMarkerFile(deps2.configPath, inspection.root),
+        sessionId
+      ) : null;
+      const captureProvenance = alignMarker?.captureSource ? ` \xB7 resolved from ${alignMarker.captureSource}` : "";
+      const skeletonProvenance = alignMarker?.skeletonSource ? ` \xB7 resolved from ${alignMarker.skeletonSource}` : "";
       const local = deadLocal ? [
         "Local capture: NOT RUNNING \u2014 this machine bound the session but no capture host ever started here (no host marker, no spool parts).",
         `  Fix: \`jentrix session end ${sessionId}\` closes it honestly (the capture gap is recorded), or reattach with a transcript path to start capture.`
@@ -23028,9 +23061,9 @@ async function runSessionStatus(sessionId, flags, deps2) {
           `Session ${String(session.id)} \xB7 ${String(session.provider)} \xB7 ${String(session.status)}`,
           `Project: ${String(session.projectName)} (${String(session.projectId)})`,
           `Repository: ${String(session.repoOwnerName)}`,
-          `Capture: ${capture}`,
+          `Capture: ${capture}${captureProvenance}`,
           // 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)"}`,
+          `Skeleton: ${session.alignment?.skeleton === "off" ? "off (no activity counts, no timing, no files-touched)" : "on (content-free activity counts/timing)"}${skeletonProvenance}`,
           ...local,
           telemetry.line,
           `Summary artifact: ${session.summaryArtifactId ? String(session.summaryArtifactId) : "\u2014"}`
@@ -23163,14 +23196,12 @@ async function buildAttestedDiffBody(git, root, startHead, endHead, dirty) {
     }
     body = notice + kept;
   }
+  let uncommitted = null;
   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)"}`;
+    uncommitted = delta.code === 0 && delta.stdout.trim() ? delta.stdout.trim() : null;
   }
-  return { body: header + body, commitCount };
+  return { body: header + body, commitCount, uncommitted };
 }
 async function postAttestedArtifact(deps2, sessionId, input) {
   const credentials = deps2.resolveTarget();
@@ -23298,6 +23329,12 @@ async function runSessionEnd(sessionIdFlag, flags, deps2) {
               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.`
@@ -23320,21 +23357,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) {
@@ -24184,7 +24232,11 @@ async function buildCatalog(caller, flags, detection) {
     // Host/capture disclosure inputs are filled by runAlign (they need the
     // checkout root); defaults here are the no-live-host reading.
     liveHostPid: null,
-    captureMode: decideCaptureMode(flags.capture, false),
+    captureMode: captureSubmission(flags.capture, false, false) ?? "default",
+    // JEN-169 + capture settings §5: the disclosure states the same tri-state
+    // the submission carries, so "your account default" is never quietly
+    // disclosed as a posture the wizard guessed.
+    skeletonMode: skeletonSubmission(flags.skeleton) ?? "default",
     producer: producerFromFlags(flags),
     tokenBudget: budgetFromFlags(flags),
     preconditionNotices: [],
@@ -24298,6 +24350,18 @@ function decideCaptureMode(requested, liveCapturing) {
   if (requested === false) return "off";
   return liveCapturing ? "on" : "off";
 }
+function captureSubmission(requested, liveHost, liveCapturing) {
+  if (requested === void 0 && !liveHost) return void 0;
+  return decideCaptureMode(requested, liveCapturing);
+}
+function skeletonSubmission(requested) {
+  if (requested === void 0) return void 0;
+  return requested ? "on" : "off";
+}
+function captureSourceLabel(requested, liveHost, serverLabel) {
+  if (requested === void 0 && liveHost) return "(live host)";
+  return serverLabel;
+}
 function keepCurrentAlignment(currentAlignment, projectId, workItem, ownerUserId) {
   if (workItem !== null || !projectId) return null;
   const current = currentAlignment;
@@ -24362,7 +24426,9 @@ ${JSON.stringify(session.alignment, null, 2)}`
         sessionId,
         alignment: session.alignment,
         realigned: false,
-        captureMode: (session.alignment.capture ?? "off") === "on" ? "on" : "off"
+        captureMode: (session.alignment.capture ?? "off") === "on" ? "on" : "off",
+        // No align ran, so nothing resolved anything — claim no provenance.
+        captureSources: null
       };
     }
   }
@@ -24413,7 +24479,12 @@ ${JSON.stringify(session.alignment, null, 2)}`
       `cannot turn TRACE capture off: the live session host (pid ${liveHost.pid}) is actively capturing \u2014 end the session (\`jentrix session end\`) to stop it`
     );
   }
-  const captureMode = decideCaptureMode(flags.capture, liveCapturing);
+  const captureSubmitted = captureSubmission(
+    flags.capture,
+    liveHost !== null,
+    liveCapturing
+  );
+  const skeletonSubmitted = skeletonSubmission(flags.skeleton);
   if (liveHost && session.taskId && session.taskId !== (taskId ?? null)) {
     const acked = await requestUsageFlush(deps2, sessionId);
     deps2.writeOut(
@@ -24431,14 +24502,22 @@ ${JSON.stringify(session.alignment, null, 2)}`
       ...producer.emoji ? { agentEmoji: producer.emoji } : {}
     } : {},
     ...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" } : {},
+    ...captureSubmitted !== void 0 ? { capture: captureSubmitted } : {},
+    ...skeletonSubmitted !== void 0 ? { skeleton: skeletonSubmitted } : {},
     expectedUpdatedAt: session.updatedAt
   });
   const alignment = aligned.alignment;
   const skeletonMode = alignment.skeleton === "off" ? "off" : "on";
+  const captureMode = alignment.capture === "on" ? "on" : "off";
+  const serverSources = aligned.captureSources ?? null;
+  const captureSources = serverSources ? {
+    capture: captureSourceLabel(
+      flags.capture,
+      liveHost !== null,
+      serverSources.capture
+    ),
+    skeleton: serverSources.skeleton
+  } : null;
   writeAlignmentMarker(
     deps2.configPath,
     inspection.root,
@@ -24448,6 +24527,12 @@ ${JSON.stringify(session.alignment, null, 2)}`
       projectId: choices.projectId,
       taskId,
       capture: captureMode,
+      // Capture settings D6/S4: `session status` reads the provenance back
+      // from here — the snapshot deliberately stores values only, so the
+      // align that resolved them is the only place the source exists.
+      ...captureSources?.capture ? { captureSource: captureSources.capture } : {},
+      ...captureSources?.skeleton ? { skeletonSource: captureSources.skeleton } : {},
+      skeleton: skeletonMode,
       alignedAt: (/* @__PURE__ */ new Date()).toISOString()
     },
     detected.providerSessionId
@@ -24474,7 +24559,8 @@ ${JSON.stringify(session.alignment, null, 2)}`
       sessionId,
       alignment,
       realigned: Boolean(aligned.realigned),
-      captureMode
+      captureMode,
+      captureSources
     };
   }
   if (!liveHost && (detected.provider === "claude" && detected.transcriptPath || detected.provider === "codex" && detected.hookDir)) {
@@ -24518,7 +24604,8 @@ ${JSON.stringify(session.alignment, null, 2)}`
     sessionId,
     alignment,
     realigned: Boolean(aligned.realigned),
-    captureMode
+    captureMode,
+    captureSources
   };
 }
 async function requestUsageFlush(deps2, sessionId, timeoutMs = 6e3) {
@@ -24569,10 +24656,11 @@ async function runAlign(flags, deps2) {
       );
       const markerHost = marker ? readLiveHostMarker(deps2, marker.sessionId) : null;
       catalog.liveHostPid = markerHost?.pid ?? null;
-      catalog.captureMode = decideCaptureMode(
+      catalog.captureMode = captureSubmission(
         flags.capture,
+        markerHost !== null,
         marker !== null && markerHost !== null && isHostCapturing(deps2, marker.sessionId, markerHost)
-      );
+      ) ?? "default";
       const newest = newestAlignmentMarker(deps2.configPath, inspection.root);
       catalog.lastAlignedWorkspaceId = newest?.workspaceId ?? null;
       catalog.binding = {
@@ -24961,6 +25049,7 @@ async function runAlign(flags, deps2) {
         deps2.writeOut(JSON.stringify(result));
       } else {
         const a = result.alignment;
+        const sources = result.captureSources;
         deps2.writeOut(
           [
             `${result.realigned ? "Re-aligned" : "Aligned"} session ${result.sessionId}:`,
@@ -24970,8 +25059,12 @@ async function runAlign(flags, deps2) {
             `  Owner:     ${a.owner?.name ?? a.owner?.email ?? "\u2014"}`,
             `  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)`,
+            // Capture settings D6: each resolved knob names WHERE it came
+            // from, in the server's own words — "(flag)", "(this session)",
+            // "(your default)", "(built-in)". A server older than this round
+            // sends none, and then nothing is claimed.
+            `  Capture:   ${a.capture ?? "off"}${sources?.capture ? ` ${sources.capture}` : ""}`,
+            `  Skeleton:  ${a.skeleton ?? "on"}${sources?.skeleton ? ` ${sources.skeleton}` : ""} \u2014 content-free activity counts/timing; --skeleton/--no-skeleton decides one session, Account \u2192 Capture sets your default`,
             `Alignment snapshot (server-confirmed): ${JSON.stringify(result.alignment)}`
           ].join("\n")
         );
@@ -25032,13 +25125,16 @@ function registerAlignCommand(program3, deps2, onExit2) {
     "token budget for this session \u2014 a breach is recorded and badged, never enforced"
   ).option(
     "--capture",
-    "turn TRACE capture ON for this session (MVP default: off; applies from a fresh attach)"
+    "turn TRACE capture ON for this session (overrides your account default; applies from a fresh attach)"
   ).option(
     "--no-capture",
-    "keep TRACE capture OFF explicitly \u2014 also corrects a wrongly-on record on re-align"
+    "keep TRACE capture OFF explicitly \u2014 overrides your account default, and corrects a wrongly-on record on re-align"
+  ).option(
+    "--skeleton",
+    "record the content-free activity skeleton for this session explicitly (overrides your account default)"
   ).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"
+    "opt out of the content-free activity skeleton (event/tool counts, files-touched, timing buckets) for this session \u2014 independent of capture"
   ).addOption(
     new Option(
       "--provider <provider>",
@@ -26574,6 +26670,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) {
@@ -26610,6 +26710,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({

package/package.json

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

package/surface.json

@@ -441,7 +441,7 @@
             "description": "Optional producer label for this session (\"triage-bot\"). Null = the operator themself; absent leaves it unchanged."
           },
           "capture": {
-            "description": "TRACE capture mode the CLI declared for this session — MVP default off.",
+            "description": "TRACE capture mode for this session. OMIT to let the server resolve it: this session's previous value, then the operator's account default (Account → Capture), then the built-in off.",
             "enum": [
               "off",
               "on"
@@ -464,7 +464,7 @@
             "type": "string"
           },
           "skeleton": {
-            "description": "Activity-skeleton mode the CLI declared for this session (--no-skeleton). Default on, independent of capture.",
+            "description": "Activity-skeleton mode for this session, independent of capture. OMIT to let the server resolve it: this session's previous value, then the operator's account default, then the built-in on.",
             "enum": [
               "on",
               "off"