@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-FVDGR2ZL.js → chunk-6Q3CYFD3.js}

@@ -1,30 +1,34 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  loadProjectVerifierCatalog
-} from "./chunk-VN3SHNBN.js";
-import {
-  pathBoundaryCovers,
-  resolvePathBoundary
-} from "./chunk-HHV2GANA.js";
 import {
   classify
-} from "./chunk-PGF63K6I.js";
+} from "./chunk-KFV5L5SK.js";
 import {
-  artifactDefaultPath,
+  extractCommandCdTargets,
   extractCommandDeleteTargets,
   extractCommandWriteTargets,
   inlineShellScript,
-  tokenizeShellLike
-} from "./chunk-IKOZFYBN.js";
+  invokesClioSkillMutation,
+  scanShellLike
+} from "./chunk-NXYCB2VD.js";
 import {
   canonicalizeExistingPath
 } from "./chunk-ECH6PKUQ.js";
+import {
+  loadProjectVerifierCatalog
+} from "./chunk-DXKJURES.js";
+import {
+  pathBoundaryCovers,
+  resolvePathBoundary
+} from "./chunk-HHV2GANA.js";
+import {
+  artifactDefaultPath
+} from "./chunk-GYV6VZOC.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   foreignAgentDirs
-} from "./chunk-IHXBNWMM.js";
+} from "./chunk-KXDSS5WJ.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -48,7 +52,7 @@ function isSameOrDescendant(candidatePath, policyPath) {
   const candidate = path.resolve(candidatePath);
   const policy = path.resolve(policyPath);
   const relative = path.relative(policy, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
 function expandTilde(rawPath) {
   if (rawPath === "~") return homedir();
@@ -145,7 +149,7 @@ function normalizeSeparators(value) {
 // src/domains/safety/policy-engine.ts
 init_esm_shims();
 import { createHash as createHash2 } from "node:crypto";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/domains/safety/default-path-policy.ts
 init_esm_shims();
@@ -208,8 +212,10 @@ var DEFAULT_DAMAGE_CONTROL_PATH_POLICY = {
     // widen its own permissions in two tool calls. Both are authored by the
     // operator through the CLI (`clio-coder verifiers author` lands nothing
     // before `--yes`), so model-side writes and deletes are refused.
+    // Skills also refuse model-side writes and deletes; installs go through `clio-coder skills install`.
     ".clio-coder/safety.yaml",
     ".clio-coder/verifiers.yaml",
+    ".clio-coder/skills/",
     "/etc/",
     "/usr/",
     "/bin/",
@@ -730,6 +736,42 @@ function getCachedDefaultRulePacks() {
   return cachedPacks;
 }
 
+// src/domains/safety/skill-authority.ts
+init_esm_shims();
+import { homedir as homedir2 } from "node:os";
+import path3 from "node:path";
+function activeClioSkillRoots(cwd) {
+  return [path3.join(cwd, ".clio-coder", "skills"), path3.join(clioConfigDir(), "skills")];
+}
+function skillMutationReason(roots, targets, cwd, command) {
+  const workingDirs = [cwd];
+  if (command !== null) {
+    for (const destination of extractCommandCdTargets(command)) {
+      workingDirs.push(path3.resolve(workingDirs.at(-1) ?? cwd, expandHome(destination)));
+    }
+  }
+  for (const target of targets) {
+    if (target.operation === "read") continue;
+    for (const directory of workingDirs) {
+      const lexical = path3.resolve(directory, expandHome(target.path));
+      const resolved = canonicalizeExistingPath(lexical);
+      for (const root of roots) {
+        for (const boundary of [root, canonicalizeExistingPath(root)]) {
+          for (const candidate of [lexical, resolved]) {
+            if (isSameOrDescendant(candidate, boundary) || target.operation === "delete" && isSameOrDescendant(boundary, candidate)) {
+              return `active skill tree ${root} is operator-owned; draft changes outside active skill roots and ask the operator to install or update them`;
+            }
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function expandHome(value) {
+  return value === "~" ? homedir2() : value.startsWith("~/") ? path3.join(homedir2(), value.slice(2)) : value;
+}
+
 // src/domains/safety/policy-engine.ts
 var BUILTIN_ALLOWLIST = [
   { id: "builtin:pwd", re: /^pwd$/ },
@@ -771,19 +813,23 @@ function evaluateWriteRoots(roots, writeRootCwd, call) {
   if (roots.length === 0) return null;
   const target = writeRootTargetPath(call);
   if (target === null) return null;
-  const resolved = path3.resolve(writeRootCwd, target);
+  const resolved = path4.resolve(writeRootCwd, target);
   if (pathBoundaryCovers(roots, resolved)) return null;
   return `write target '${target}' resolves to '${resolved}', which is outside the permitted write roots for this run: ${roots.join(", ")}`;
 }
 function createSafetyPolicyEngine(options = {}) {
-  const cwd = canonicalizeExistingPath(path3.resolve(options.cwd ?? process.cwd()));
-  const writeRootCwd = path3.resolve(options.cwd ?? process.cwd());
+  const cwd = canonicalizeExistingPath(path4.resolve(options.cwd ?? process.cwd()));
+  const writeRootCwd = path4.resolve(options.cwd ?? process.cwd());
   const writeRoots = (options.writeRoots ?? []).map((root) => resolvePathBoundary(writeRootCwd, root));
+  const skillRoots = activeClioSkillRoots(cwd);
   const packs = options.rulePacks ?? getCachedDefaultRulePacks();
   const projectPolicy = options.projectPolicy ?? loadProjectSafetyPolicy(cwd);
-  const projectPolicyRoot = projectPolicy.path === null ? cwd : path3.dirname(path3.dirname(canonicalizeExistingPath(projectPolicy.path)));
+  const projectPolicyRoot = projectPolicy.path === null ? cwd : path4.dirname(path4.dirname(canonicalizeExistingPath(projectPolicy.path)));
   const pathPolicyInput = projectPolicy.disableDefaultPathPolicy ? projectPolicy.pathPolicy : mergePathPolicyInputs(DEFAULT_DAMAGE_CONTROL_PATH_POLICY, projectPolicy.pathPolicy);
-  const expandedDefaults = projectPolicy.disableDefaultPathPolicy ? pathPolicyInput : mergePathPolicyInputs(pathPolicyInput, { zeroAccessPaths: clioCredentialStorePaths() });
+  const expandedDefaults = projectPolicy.disableDefaultPathPolicy ? pathPolicyInput : mergePathPolicyInputs(pathPolicyInput, {
+    zeroAccessPaths: clioCredentialStorePaths(),
+    readOnlyPaths: clioSkillsRootPaths()
+  });
   const pathPolicy = compilePathPolicy(expandedDefaults, projectPolicyRoot);
   const zeroAccessPolicy = {
     root: pathPolicy.root,
@@ -843,6 +889,21 @@ function createSafetyPolicyEngine(options = {}) {
         if (projectPolicy.path !== null) blockInput.projectPolicyPath = projectPolicy.path;
         return blockDecision(base, blockInput);
       }
+      const mutationCommand = call.tool === ToolNames.Bash ? command : catalogCommand;
+      const skillReason = mutationCommand !== null && invokesClioSkillMutation(mutationCommand) ? "skill installation and updates require the operator CLI or an explicit operator install choice; draft outside active skill roots" : skillMutationReason(
+        skillRoots,
+        pathPolicyTargets(catalogCommand === null ? call : { tool: ToolNames.Bash, args: { command: catalogCommand } }),
+        callCwd,
+        mutationCommand
+      );
+      if (skillReason !== null) {
+        return blockDecision(base, {
+          ruleId: "skill-authority",
+          reasonCode: "skill-authority",
+          reasons: [skillReason],
+          policySource: "builtin-classifier"
+        });
+      }
       const pathBlock = evaluateProjectPathPolicy(pathPolicy, call, callCwd);
       if (pathBlock !== null) {
         const blockInput = {
@@ -940,7 +1001,14 @@ function createSafetyPolicyEngine(options = {}) {
 }
 function clioCredentialStorePaths() {
   try {
-    return [path3.join(clioConfigDir(), "credentials.yaml")];
+    return [path4.join(clioConfigDir(), "credentials.yaml")];
+  } catch {
+    return [];
+  }
+}
+function clioSkillsRootPaths() {
+  try {
+    return [path4.join(clioConfigDir(), "skills")];
   } catch {
     return [];
   }
@@ -962,10 +1030,10 @@ function stripQuotes(token) {
 }
 function bashPathTokenCandidates(command) {
   const candidates = [];
-  for (const token of tokenizeShellLike(command)) {
+  for (const scanned of scanShellLike(command)) {
+    if (scanned.operator) continue;
+    const token = scanned.value;
     if (token.length === 0) continue;
-    if (token === ";" || token === "&&" || token === "||" || token === "|" || token === ">" || token === ">>") continue;
-    if (token === "<" || token === "<<") continue;
     if (/\s/.test(token)) continue;
     if (token.startsWith("-") && !token.includes("/") && !token.includes("=")) continue;
     candidates.push(token);
@@ -1205,29 +1273,28 @@ function effectiveClassification(classification, match) {
 }
 function matchingProjectCommand(policy, command, cwd) {
   if (!policy.valid || policy.path === null) return null;
-  const policyRoot = path3.dirname(path3.dirname(policy.path));
+  const policyRoot = path4.dirname(path4.dirname(policy.path));
   for (const entry of policy.commands) {
     if (entry.command !== command) continue;
     if (entry.shellOperators === "deny" && hasShellOperators(command)) continue;
-    const allowedCwd = entry.cwd !== void 0 ? path3.resolve(policyRoot, entry.cwd) : policyRoot;
+    const allowedCwd = entry.cwd !== void 0 ? path4.resolve(policyRoot, entry.cwd) : policyRoot;
     if (!isUnderOrSame(cwd, allowedCwd)) continue;
     return entry;
   }
   return null;
 }
-var CHAIN_BREAKING_TOKENS = /* @__PURE__ */ new Set([";", "|", "||", ">", ">>", "<", "<<"]);
 var CHAIN_MAX_SEGMENTS = 6;
 function recognizeCommandChain(command, callCwd, workspaceRoot, policy) {
   const segments = [];
   let current = [];
-  for (const token of tokenizeShellLike(command)) {
-    if (token === "&&") {
+  for (const token of scanShellLike(command)) {
+    if (token.operator && token.value === "&&") {
       segments.push(current);
       current = [];
       continue;
     }
-    if (CHAIN_BREAKING_TOKENS.has(token)) return null;
-    current.push(token);
+    if (token.operator) return null;
+    current.push(token.value);
   }
   segments.push(current);
   if (segments.length < 2 || segments.length > CHAIN_MAX_SEGMENTS) return null;
@@ -1238,7 +1305,7 @@ function recognizeCommandChain(command, callCwd, workspaceRoot, policy) {
     if (segment[0] === "cd") {
       if (segment.length !== 2) return null;
       const target = segment[1] ?? "";
-      if (target.startsWith("~") || !isUnderOrSame(path3.resolve(callCwd, target), workspaceRoot)) return null;
+      if (target.startsWith("~") || !isUnderOrSame(path4.resolve(callCwd, target), workspaceRoot)) return null;
       ruleIds.push("builtin:cd-workspace");
       continue;
     }
@@ -1265,11 +1332,11 @@ function hasShellOperators(command) {
   return hasSequencingOperators(command) || hasCommandSubstitution(command);
 }
 function isUnderOrSame(child, parent) {
-  const rel = path3.relative(
-    canonicalizeExistingPath(path3.resolve(parent)),
-    canonicalizeExistingPath(path3.resolve(child))
+  const rel = path4.relative(
+    canonicalizeExistingPath(path4.resolve(parent)),
+    canonicalizeExistingPath(path4.resolve(child))
   );
-  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+  return rel === "" || !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function commandArg(args) {
   return typeof args?.command === "string" ? args.command : null;
@@ -1280,10 +1347,16 @@ function pathArg(args) {
   return typeof candidate === "string" && candidate.length > 0 ? candidate : null;
 }
 function cwdArg(args, fallback) {
-  const resolved = typeof args?.cwd === "string" && args.cwd.length > 0 ? path3.resolve(fallback, args.cwd) : fallback;
+  const resolved = typeof args?.cwd === "string" && args.cwd.length > 0 ? path4.resolve(fallback, args.cwd) : fallback;
   return canonicalizeExistingPath(resolved);
 }
-var CONTENT_BEARING_TOOLS = /* @__PURE__ */ new Set([ToolNames.Write, ToolNames.Edit, ToolNames.Artifact]);
+var CONTENT_BEARING_TOOLS = /* @__PURE__ */ new Set([
+  ToolNames.Write,
+  ToolNames.Edit,
+  ToolNames.Artifact,
+  ToolNames.Dispatch,
+  ToolNames.Tasks
+]);
 function damageControlScan(call) {
   if (!CONTENT_BEARING_TOOLS.has(call.tool)) return serializeArgs(call.args);
   const pathArg2 = call.args?.path;
@@ -1340,4 +1413,4 @@ export {
   WRITE_ROOT_REFUSED_TOOLS,
   createSafetyPolicyEngine
 };
-//# sourceMappingURL=chunk-FVDGR2ZL.js.map
+//# sourceMappingURL=chunk-6Q3CYFD3.js.map

package/dist/{chunk-IDNA72AH.js → chunk-6QOTUPRG.js}

@@ -4,33 +4,27 @@ import {
   extractCommandDeleteTargets,
   extractCommandWriteTargets,
   toolMutationPaths
-} from "./chunk-IKOZFYBN.js";
+} from "./chunk-NXYCB2VD.js";
+import {
+  PROJECT_VERIFIER_CATALOG_RELATIVE_PATH
+} from "./chunk-DXKJURES.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
 // src/domains/safety/finish-contract.ts
 init_esm_shims();
-var FINISH_CONTRACT_ADVISORY_MESSAGE = "[Clio Coder] finish-contract advisory: you changed files this turn without recording validation evidence or an explicit limitation. Run a verification command or state what could not be verified.";
+import { resolve } from "node:path";
+var FINISH_CONTRACT_ADVISORY_MESSAGE = "[Clio Coder] finish-contract advisory: you changed files this turn without recording validation evidence or a limitation receipt. Run a verification command or call limitation with the scope and reason.";
 var DEFAULT_RECENT_ENTRY_LIMIT = 80;
-var LIMITATION_PATTERNS = [
-  /\b(?:blocked by|blocker|blockers|unable to|not able to|could not|couldn't|cannot|can't)\b/i,
-  /\b(?:did not|didn't|have not|haven't|has not|hasn't|was not able|wasn't able)\b/i,
-  /\b(?:not complete|incomplete)\b/i,
-  /\b(?:not|un)(?:\s|-)?(?:validated|verified|tested)\b/i,
-  /^\s*Tests\s*:\s*(?:not run|not executed|not available|failed|blocked|skipped)\b/im,
-  /^\s*Known gaps?\s*:\s*(?!\s*(?:none|no\b|n\/a|not applicable)\b).+/im,
-  /\bremaining(?:\s+\w+){0,3}\s+(?:work|issue|issues|gap|gaps|blocker|blockers)\b/i
-];
 function assessFinishContract(input) {
-  const assistantText = input.assistantText.trim();
   const sessionEntries = input.sessionEntries ?? [];
   const assistantTurnId = input.assistantTurnId ?? null;
   const window = recentEntries(sessionEntries, assistantTurnId, input.recentEntryLimit ?? DEFAULT_RECENT_ENTRY_LIMIT);
@@ -38,12 +32,38 @@ function assessFinishContract(input) {
   if (mutatedPaths.length === 0) {
     return { kind: "ok", reason: "no_mutation", evidence: [], mutatedPaths };
   }
-  const evidence = collectValidationEvidence(window);
+  const acceptanceChecks = new Set(input.activeAcceptance?.verification.map((item) => item.check) ?? []);
+  const evidence = collectValidationEvidence(window, acceptanceChecks, input.workspaceRoot);
+  const limitations = collectLimitationEvidence(window);
+  const required = input.rigor === "high" ? input.activeAcceptance?.verification ?? [] : [];
+  if (required.length > 0) {
+    const passes = new Set(
+      required.filter((check) => evidence.some((item) => acceptanceCheckPassed(item, check, input.workspaceRoot)))
+    );
+    const limited = new Set(limitations.flatMap((item) => item.paths ?? []));
+    const missing = [
+      ...new Set(required.filter((check) => !passes.has(check) && !limited.has(check.check)).map((item) => item.check))
+    ];
+    if (missing.length > 0)
+      return {
+        kind: "engage",
+        reason: "unvalidated_mutation",
+        message: `[Clio Coder] high-rigor finish gate: operator acceptance still requires passing validation for: ${missing.join(", ")}. Run each named check or include its exact id in limitation.paths.`,
+        evidence: [...evidence, ...limitations],
+        mutatedPaths
+      };
+    return {
+      kind: "ok",
+      reason: passes.size === required.length ? "validation_evidence" : "explicit_limitation",
+      evidence: [...evidence, ...limitations],
+      mutatedPaths
+    };
+  }
   if (evidence.length > 0) {
     return { kind: "ok", reason: "validation_evidence", evidence, mutatedPaths };
   }
-  if (hasExplicitLimitation(assistantText)) {
-    return { kind: "ok", reason: "explicit_limitation", evidence: [], mutatedPaths };
+  if (limitations.length > 0) {
+    return { kind: "ok", reason: "explicit_limitation", evidence: limitations, mutatedPaths };
   }
   return {
     kind: "engage",
@@ -53,10 +73,59 @@ function assessFinishContract(input) {
     mutatedPaths
   };
 }
-function hasExplicitLimitation(text) {
-  const normalized = text.trim();
-  if (normalized.length === 0) return false;
-  return LIMITATION_PATTERNS.some((pattern) => pattern.test(normalized));
+function acceptanceCheckPassed(evidence, required, workspaceRoot) {
+  if (evidence.kind !== "validation_command" || evidence.check !== required.check || !workspaceRoot || !evidence.source)
+    return false;
+  if (evidence.durationMs !== void 0 && evidence.durationMs > required.timeoutMs) return false;
+  const root = resolve(workspaceRoot);
+  if (evidence.source.kind === "project-catalog")
+    return evidence.source.path === resolve(root, PROJECT_VERIFIER_CATALOG_RELATIVE_PATH);
+  return evidence.source.path === resolve(root, "package.json") && evidence.cwd === root && validationCheckId(evidence.argv?.join(" ") ?? "") === required.check;
+}
+function collectLimitationEvidence(recent) {
+  const evidence = [];
+  const calls = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of recent) {
+    const call = limitationToolCall(entry);
+    if (call !== null) {
+      calls.set(call.toolCallId, call);
+      continue;
+    }
+    const resultId = successfulToolResultId(entry);
+    if (resultId === null) continue;
+    const candidate = calls.get(resultId);
+    if (candidate === void 0) continue;
+    const item = {
+      kind: "limitation",
+      summary: candidate.command,
+      ...candidate.paths ? { paths: candidate.paths } : {}
+    };
+    if (candidate.turnId !== void 0) item.turnId = candidate.turnId;
+    pushEvidence(evidence, seen, item);
+  }
+  return evidence;
+}
+function limitationToolCall(entry) {
+  const record = asRecord(entry);
+  if (record?.kind !== "message" || record.role !== "tool_call") return null;
+  const payload = asRecord(record.payload);
+  if (payload === null) return null;
+  const toolName = stringFromFirst(payload, ["name", "toolName", "tool"]);
+  if (toolName !== ToolNames.Limitation) return null;
+  const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
+  if (toolCallId === null) return null;
+  const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
+  const scope = typeof args?.scope === "string" ? args.scope.trim() : "";
+  const reason = typeof args?.reason === "string" ? args.reason.trim() : "";
+  const candidate = {
+    toolCallId,
+    paths: Array.isArray(args?.paths) ? args.paths.filter((item) => typeof item === "string").map((item) => item.trim()) : [],
+    command: `limitation recorded: ${scope.length > 0 ? scope : "unspecified"} (reason=${reason.length > 0 ? reason : "unspecified"})`
+  };
+  const turnId = turnIdOf(entry);
+  if (turnId !== null) candidate.turnId = turnId;
+  return candidate;
 }
 function mutatingReceipts(recent) {
   const mutationCalls = /* @__PURE__ */ new Map();
@@ -117,7 +186,7 @@ function pushPath(paths, seen, path) {
   seen.add(path);
   paths.push(path);
 }
-function collectValidationEvidence(recent) {
+function collectValidationEvidence(recent, acceptanceChecks, workspaceRoot) {
   const evidence = [];
   const toolCalls = /* @__PURE__ */ new Map();
   const dispatchCalls = /* @__PURE__ */ new Map();
@@ -128,7 +197,7 @@ function collectValidationEvidence(recent) {
       pushEvidence(evidence, seen, protectedArtifact);
       continue;
     }
-    const call = bashValidationCall(entry);
+    const call = bashValidationCall(entry, acceptanceChecks, workspaceRoot);
     if (call !== null) {
       toolCalls.set(call.toolCallId, call);
       continue;
@@ -153,11 +222,11 @@ function collectValidationEvidence(recent) {
       }
       const candidate = toolCalls.get(resultId);
       if (candidate !== void 0) {
-        pushEvidence(evidence, seen, validationEvidence(candidate));
+        pushEvidence(evidence, seen, validationEvidence(candidate, entry));
       }
       continue;
     }
-    const bashExecution = bashExecutionEvidence(entry);
+    const bashExecution = bashExecutionEvidence(entry, acceptanceChecks, workspaceRoot);
     if (bashExecution !== null) pushEvidence(evidence, seen, bashExecution);
   }
   return evidence;
@@ -175,7 +244,7 @@ function recentEntries(entries, assistantTurnId, recentEntryLimit) {
   }
   return entries.slice(startInclusive, endExclusive);
 }
-function bashValidationCall(entry) {
+function bashValidationCall(entry, acceptanceChecks, workspaceRoot) {
   const record = asRecord(entry);
   if (record?.kind !== "message" || record.role !== "tool_call") return null;
   const payload = asRecord(record.payload);
@@ -185,13 +254,15 @@ function bashValidationCall(entry) {
   const args = asRecord(payload.args ?? payload.arguments ?? payload.input);
   const command = typeof args?.command === "string" ? args.command : null;
   if (command === null) return null;
-  const detected = detectValidationCommand(command);
+  const detected = acceptanceValidationCommand(command, acceptanceChecks);
   if (detected.kind !== "validation") return null;
   const toolCallId = stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]) ?? turnIdOf(entry);
   if (toolCallId === null) return null;
   const candidate = {
     toolCallId,
-    command: detected.matched
+    command: detected.matched,
+    ...validationCheckFields(detected.matched),
+    execution: packageCommandExecution(command, args?.cwd, workspaceRoot)
   };
   const turnId = turnIdOf(entry);
   if (turnId !== null) candidate.turnId = turnId;
@@ -245,7 +316,8 @@ function validationToolCall(entry) {
   if (toolCallId === null) return null;
   const candidate = {
     toolCallId,
-    command: summary
+    command: summary,
+    ...validationCheckFields(summary)
   };
   const turnId = turnIdOf(entry);
   if (turnId !== null) candidate.turnId = turnId;
@@ -273,7 +345,8 @@ function successfulToolResultId(entry) {
   if (payload.isError === true || payload.error === true) return null;
   const result = asRecord(payload.result);
   const details = asRecord(result?.details);
-  if (details?.kind === "error") return null;
+  if (result?.kind === "error" || details?.kind === "error") return null;
+  if (typeof details?.exitCode === "number" && details.exitCode !== 0) return null;
   return stringFromFirst(payload, ["toolCallId", "tool_call_id", "id"]);
 }
 function dispatchReceiptEvidence(entry, candidate) {
@@ -318,18 +391,20 @@ function dispatchReceiptAgentId(receiptAgentId, candidate) {
   if (receiptAgentId !== void 0 && receiptAgentId.length > 0) return receiptAgentId;
   return candidate?.command.match(/^agent=([^\s]+)/)?.[1] ?? "unknown";
 }
-function bashExecutionEvidence(entry) {
+function bashExecutionEvidence(entry, acceptanceChecks, workspaceRoot) {
   const record = asRecord(entry);
   if (record?.kind !== "bashExecution") return null;
   if (typeof record.command !== "string") return null;
   if (record.cancelled === true) return null;
   if (record.exitCode !== 0) return null;
-  const detected = detectValidationCommand(record.command);
+  const detected = acceptanceValidationCommand(record.command, acceptanceChecks);
   if (detected.kind !== "validation") return null;
   const contextMarker = record.excludeFromContext === true ? " [not sent to model]" : "";
   const evidence = {
     kind: "validation_command",
-    summary: `validation command passed: ${detected.matched}${contextMarker}`
+    summary: `validation command passed: ${detected.matched}${contextMarker}`,
+    ...validationCheckFields(detected.matched),
+    ...packageCommandExecution(record.command, record.cwd, workspaceRoot)
   };
   const turnId = turnIdOf(entry);
   if (turnId !== null) evidence.turnId = turnId;
@@ -349,16 +424,46 @@ function protectedArtifactEvidence(entry) {
   if (turnId !== null) evidence.turnId = turnId;
   return evidence;
 }
-function validationEvidence(candidate) {
+function validationEvidence(candidate, entry) {
   const evidence = {
     kind: "validation_command",
-    summary: `validation command passed: ${candidate.command}`
+    summary: `validation command passed: ${candidate.command}`,
+    ...candidate.check ? { check: candidate.check } : {},
+    ...candidate.execution ?? declaredCheckExecution(entry, candidate.check)
   };
   if (candidate.turnId !== void 0) evidence.turnId = candidate.turnId;
   return evidence;
 }
+function declaredCheckExecution(entry, check) {
+  const payload = asRecord(asRecord(entry)?.payload);
+  const details = asRecord(asRecord(payload?.result)?.details);
+  const source = asRecord(details?.source);
+  if (!details || details.check !== check || details.exitCode !== 0 || details.aborted === true || details.timedOut === true || details.outputCapped === true || source?.kind !== "package.json" && source?.kind !== "project-catalog" || typeof source.path !== "string" || typeof details.cwd !== "string" || !Array.isArray(details.argv) || !details.argv.every((arg) => typeof arg === "string"))
+    return {};
+  if (source.kind === "project-catalog") {
+    const argv = details.argv;
+    if (!Array.isArray(details.declaredCommand) || details.declaredCommand.length !== details.argv.length || !details.declaredCommand.every((arg, index) => arg === argv[index]) || typeof details.declaredCwd !== "string" || typeof details.declaredTimeoutMs !== "number" || typeof details.durationMs !== "number" || details.durationMs > details.declaredTimeoutMs || resolve(source.path, "../..", details.declaredCwd) !== details.cwd)
+      return {};
+  }
+  return {
+    source: { kind: source.kind, path: source.path },
+    cwd: details.cwd,
+    argv: details.argv,
+    ...typeof details.durationMs === "number" ? { durationMs: details.durationMs } : {}
+  };
+}
+function packageCommandExecution(command, cwd, workspaceRoot) {
+  if (!workspaceRoot || !/^(?:npm|pnpm|yarn|bun) /u.test(command.trim()) || validationCheckId(command.trim()) === void 0)
+    return {};
+  const executionCwd = resolve(workspaceRoot, typeof cwd === "string" ? cwd : ".");
+  return {
+    source: { kind: "package.json", path: resolve(executionCwd, "package.json") },
+    cwd: executionCwd,
+    argv: command.trim().split(/\s+/u)
+  };
+}
 function pushEvidence(evidence, seen, item) {
-  const key = `${item.kind}\0${item.summary}\0${item.turnId ?? ""}`;
+  const key = JSON.stringify(item);
   if (seen.has(key)) return;
   seen.add(key);
   evidence.push(item);
@@ -383,6 +488,19 @@ function stringFromFirst(record, keys) {
 function asRecord(value) {
   return value !== null && typeof value === "object" ? value : null;
 }
+function validationCheckId(command) {
+  return /^(?:npm|pnpm|yarn|bun) (?:run )?([a-z0-9][a-z0-9._:-]*)$/.exec(command)?.[1] ?? /^verify ([a-z0-9][a-z0-9._:-]*)$/.exec(command)?.[1];
+}
+function validationCheckFields(command) {
+  const check = validationCheckId(command);
+  return check ? { check } : {};
+}
+function acceptanceValidationCommand(command, checks) {
+  const exact = command.trim();
+  const check = /^npm run ([a-z0-9][a-z0-9._:-]*)$/.exec(exact)?.[1];
+  if (check && checks.has(check)) return { kind: "validation", matched: exact };
+  return detectValidationCommand(command);
+}
 
 // src/domains/safety/loop-detector.ts
 init_esm_shims();
@@ -487,6 +605,7 @@ export {
   observe,
   DEFAULT_RECENT_ENTRY_LIMIT,
   assessFinishContract,
+  recentEntries,
   typedValidationSummary
 };
-//# sourceMappingURL=chunk-IDNA72AH.js.map
+//# sourceMappingURL=chunk-6QOTUPRG.js.map

package/dist/{chunk-X7IARSHT.js → chunk-6UINWWS6.js}

@@ -5,13 +5,13 @@ import {
 import {
   probeWorkspace
 } from "./chunk-HVDIIIQW.js";
+import {
+  protectArtifact
+} from "./chunk-NXYCB2VD.js";
 import {
   isSessionEntry,
   isSessionHeader
-} from "./chunk-FSP7CMNU.js";
-import {
-  protectArtifact
-} from "./chunk-IKOZFYBN.js";
+} from "./chunk-54X7T7DK.js";
 import {
   stripTokenizerSentinels
 } from "./chunk-CFGTUFWB.js";
@@ -26,7 +26,7 @@ import {
   readSessionMeta,
   resumeSession,
   sessionPaths
-} from "./chunk-MQXIVJ35.js";
+} from "./chunk-HAXOFFRH.js";
 import {
   BusChannels
 } from "./chunk-F4EKGO4N.js";
@@ -1243,9 +1243,9 @@ function ledgerUsageCalls(entries, defaults = {}) {
       const usage2 = entry.usage;
       if (!usage2 || usage2.totalTokens <= 0) continue;
       calls.push({
-        providerId: currentTarget ?? "unknown",
-        attributedModelId: currentModel ?? "unknown",
-        requestedModelId: currentModel ?? "unknown",
+        providerId: usage2.targetId ?? currentTarget ?? "unknown",
+        attributedModelId: usage2.modelId ?? currentModel ?? "unknown",
+        requestedModelId: usage2.modelId ?? currentModel ?? "unknown",
         responseModelIdObservation: { state: "not-observed" },
         input: usage2.input,
         output: usage2.output,
@@ -1400,7 +1400,13 @@ async function readSessionEntriesForId(stateDir, sessionId) {
         return { entries: [], missing: false, errors: [`${currentPath}: ${err.message ?? String(err)}`] };
       }
     }
-    return parseSessionEntries(raw, source);
+    const result = parseSessionEntries(raw, source);
+    try {
+      const meta = JSON.parse(await readFile(join3(root, cwdHash2, sessionId, "meta.json"), "utf8"));
+      if (isRecord(meta) && typeof meta.pinnedLeafTurnId === "string") result.leafTurnId = meta.pinnedLeafTurnId;
+    } catch {
+    }
+    return result;
   }
   return { entries: [], missing: true, errors: [] };
 }
@@ -1481,4 +1487,4 @@ export {
   ledgerUsageCalls,
   SessionDomainModule
 };
-//# sourceMappingURL=chunk-X7IARSHT.js.map
+//# sourceMappingURL=chunk-6UINWWS6.js.map