@iowarp/clio-coder 0.3.7 → 0.3.8

package/dist/{chunk-EELBMBT6.js → chunk-KTYTFRMB.js}

@@ -7,18 +7,22 @@ import {
   cloneDispatchBudgetRequest,
   isApprovedAssignmentRoute,
   isDispatchIntent,
-  isToolProfileName
-} from "./chunk-CEYBNUGC.js";
+  isToolProfileName,
+  resolveDispatchPathScope
+} from "./chunk-A3WNZD3P.js";
 import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent,
   parseRoutingIntent
-} from "./chunk-5C77SEEY.js";
+} from "./chunk-P43ETTHK.js";
 import {
   isExecutionRole,
   requestExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
+import {
+  pathBoundaryCovers
+} from "./chunk-TTHACPOM.js";
 import {
   AGENT_AUTOMATION_AUTHORITIES
 } from "./chunk-AOCYTWAV.js";
@@ -217,8 +221,34 @@ function dispatchRequestsFromArgs(args, options) {
   for (let index = 0; index < tasks.length; index += 1) {
     const item = tasks[index];
     const itemArgs = isRecord(item) ? { ...shared, ...item } : { ...shared, task: item };
+    const sharedIntent = isRecord(shared.intent) ? shared.intent : null;
+    const itemIntent = isRecord(item) && Object.hasOwn(item, "intent") && isRecord(item.intent) ? item.intent : null;
+    if (sharedIntent !== null && itemIntent !== null) itemArgs.intent = { ...sharedIntent, ...itemIntent };
     const parsed = dispatchRequestFromArgs(itemArgs, options);
     if (!parsed.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${parsed.message}` };
+    if (sharedIntent !== null && itemIntent !== null) {
+      if (options.resolveIntent === void 0) {
+        return { ok: false, message: `dispatch: task ${index + 1}: intent resolver is unavailable` };
+      }
+      const ceiling = options.resolveIntent(sharedIntent, parsed.request.cwd);
+      if (!ceiling.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${ceiling.message}` };
+      const pathCeilings = {
+        readRoots: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots],
+        writeRoots: ceiling.intent.writeRoots,
+        relevantPaths: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots, ...ceiling.intent.relevantPaths]
+      };
+      for (const field of ["readRoots", "writeRoots", "relevantPaths"]) {
+        const outside = parsed.request.intent?.[field].find(
+          (candidate) => !pathBoundaryCovers(pathCeilings[field], candidate)
+        );
+        if (outside !== void 0) {
+          return {
+            ok: false,
+            message: `dispatch: task ${index + 1}: intent_scope_widening: ${field} entry '${outside}' is outside the top-level intent ceiling`
+          };
+        }
+      }
+    }
     requests.push(parsed.request);
   }
   return { ok: true, requests };
@@ -308,6 +338,32 @@ function safeField(value) {
   }
   return result;
 }
+function renderLegacyPathScope(task) {
+  if (task.intent !== void 0) return [];
+  const scope = resolveDispatchPathScope({
+    agentId: task.agent,
+    executionRole: task.executionRole,
+    task: task.task,
+    ...task.briefing !== void 0 ? { briefing: task.briefing } : {}
+  });
+  const lines = ["    scope mode=legacy-inferred"];
+  for (const [policy, entries] of [
+    ["working_context", scope.provenance.workingContextPaths],
+    ["write_boundary", scope.provenance.writeBoundaries]
+  ]) {
+    for (const entry of entries) {
+      for (const evidence of entry.evidence) {
+        lines.push(
+          `    scope ${policy} path=${JSON.stringify(safeField(entry.path))} provenance=${evidence.provenance} source=${evidence.source} confidence=${evidence.confidence} reason=${evidence.reason}`
+        );
+      }
+    }
+  }
+  if (scope.provenance.workingContextPaths.length === 0 && scope.provenance.writeBoundaries.length === 0) {
+    lines.push("    scope policy_paths=none");
+  }
+  return lines;
+}
 function taskViews(args) {
   const tasks = Array.isArray(args.tasks) ? args.tasks : [];
   const sharedAgent = str(args.agent) ?? "coder";
@@ -452,6 +508,7 @@ function renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, max
       const serialized = JSON.stringify(task.intent);
       lines.push(`    intent_sha256=${createHash("sha256").update(serialized, "utf8").digest("hex")}`);
     }
+    lines.push(...renderLegacyPathScope(task));
     for (const check of task.resolvedVerification ?? []) {
       lines.push(
         `    verification check=${safeField(check.check)} argv=${JSON.stringify(check.argv)} cwd=${JSON.stringify(check.cwd)} timeout_ms=${check.timeoutMs}`
@@ -756,4 +813,4 @@ export {
   withResolvedDispatchPlan,
   describeDispatchPlan
 };
-//# sourceMappingURL=chunk-EELBMBT6.js.map
+//# sourceMappingURL=chunk-KTYTFRMB.js.map

package/dist/chunk-LU7P4LHA.js

@@ -0,0 +1,33 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  openAuthStorage
+} from "./chunk-EQ63NRB7.js";
+import {
+  getRuntimeRegistry
+} from "./chunk-NUGM5KR6.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/credentials.ts
+init_esm_shims();
+function credentialsPresent() {
+  const present = /* @__PURE__ */ new Set();
+  const registry = getRuntimeRegistry();
+  const auth = openAuthStorage();
+  for (const desc of registry.list()) {
+    const envVar = desc.credentialsEnvVar;
+    if (!envVar) continue;
+    const providerId = desc.id;
+    const status = auth.status(providerId, { explicitEnvVar: envVar, includeFallback: false });
+    if (status.available) {
+      present.add(envVar);
+    }
+  }
+  return present;
+}
+
+export {
+  credentialsPresent
+};
+//# sourceMappingURL=chunk-LU7P4LHA.js.map

package/dist/{chunk-DQA7QLMD.js → chunk-ME6CCNFO.js}

@@ -1,48 +1,33 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
-  compileFleetExecutionPlan
-} from "./chunk-M4AKACEO.js";
+  discoverAgentRecipes
+} from "./chunk-FBVTI2TJ.js";
 import {
-  loadRecipesFromDir,
-  mergeRecipes
-} from "./chunk-UVDSQ6LW.js";
+  compileFleetExecutionPlan
+} from "./chunk-J3YUBZWY.js";
 import {
   loadFleetCommands,
   loadFleetContract,
   renderFleetPrompt
-} from "./chunk-KCMKRQX4.js";
+} from "./chunk-E77JEWSD.js";
 import {
   requestExecutionRole,
   withAttemptRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
 import {
   normalizeAgentSpec
 } from "./chunk-AOCYTWAV.js";
 import {
   readSettings
-} from "./chunk-UHXRNZ2J.js";
-import {
-  clioConfigDir
-} from "./chunk-BNAZZHFG.js";
-import {
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-IJ7RPIYJ.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
 // src/cli/fleet-preflight.ts
 init_esm_shims();
-import { join } from "node:path";
 function discoverSpecs(cwd) {
-  const diagnostics = [];
-  const builtin = loadRecipesFromDir(
-    { dir: join(resolvePackageRoot(), "src", "domains", "agents", "builtins"), source: "builtin" },
-    diagnostics
-  );
-  const user = loadRecipesFromDir({ dir: join(clioConfigDir(), "agents"), source: "user" }, diagnostics);
-  const project = loadRecipesFromDir({ dir: join(cwd, ".clio-coder", "agents"), source: "project" }, diagnostics);
-  return mergeRecipes(builtin, user, project).map(normalizeAgentSpec);
+  return discoverAgentRecipes(cwd).map(normalizeAgentSpec);
 }
 function inspectFleet(name, vars) {
   const cwd = process.cwd();
@@ -120,4 +105,4 @@ function inspectFleet(name, vars) {
 export {
   inspectFleet
 };
-//# sourceMappingURL=chunk-DQA7QLMD.js.map
+//# sourceMappingURL=chunk-ME6CCNFO.js.map

package/dist/{chunk-KZ2H5X4G.js → chunk-MXKJU4JB.js}

@@ -2,11 +2,16 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   describeWriteBoundary,
   normalizeWriteBoundary,
+  normalizeWriteBoundaryEntry,
   writeBoundaryCovers
-} from "./chunk-KCMKRQX4.js";
+} from "./chunk-E77JEWSD.js";
+import {
+  asDirectoryPathBoundary,
+  pathBoundaryEntryCovers
+} from "./chunk-TTHACPOM.js";
 import {
   atomicWrite
-} from "./chunk-FO5ZOVUY.js";
+} from "./chunk-3BINW3FP.js";
 import {
   clioStateDir
 } from "./chunk-BNAZZHFG.js";
@@ -730,7 +735,7 @@ init_esm_shims();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readlinkSync, realpathSync as realpathSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname, join as join3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+import { dirname, isAbsolute as isAbsolute2, join as join3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
 var WRITE_BOUNDARY_VIOLATION_REASON = "writes_boundary_violation";
 var ABSENT = "absent";
 var GIT_TIMEOUT_MS = 3e4;
@@ -876,10 +881,25 @@ function rollbackPath(snapshot, change) {
   }
   return { rolledBack: { path: change.path, action: "restored", restoredFrom: `${snapshot.head}:${change.path}` } };
 }
+function withinRecordedWrite(recorded, path) {
+  if (recorded.has(path)) return true;
+  for (const target of recorded) {
+    if (path.startsWith(`${target}/`)) return true;
+  }
+  return false;
+}
 function enforceWriteBoundary(input) {
   const allow = normalizeWriteBoundary(input.allow);
   const changes = diffWorkspace(input.snapshot);
-  const violations = changes.filter((change) => !writeBoundaryCovers(allow, change.path));
+  const outside = changes.filter((change) => !writeBoundaryCovers(allow, change.path));
+  const attributionComplete = input.attribution?.complete === true;
+  const recorded = /* @__PURE__ */ new Set();
+  for (const target of input.attribution?.recorded ?? []) {
+    const relativeTarget = repoRelative(input.snapshot.root, target);
+    if (relativeTarget !== null) recorded.add(relativeTarget);
+  }
+  const violations = attributionComplete ? outside.filter((change) => withinRecordedWrite(recorded, change.path)) : outside;
+  const unattributed = attributionComplete ? outside.filter((change) => !withinRecordedWrite(recorded, change.path)) : [];
   const rolledBack = [];
   const unrecoverable = [];
   for (const change of violations) {
@@ -888,14 +908,20 @@ function enforceWriteBoundary(input) {
     if (outcome.unrecoverable !== void 0) unrecoverable.push(outcome.unrecoverable);
   }
   const status = violations.length === 0 ? "clean" : unrecoverable.length === 0 ? "rolled-back" : "rollback-incomplete";
-  const attribution = input.stepIds.length === 1 ? `step '${input.stepIds[0]}'` : `steps ${input.stepIds.map((id) => `'${id}'`).join(", ")} ran concurrently in one checkout, so the write cannot be attributed to one of them`;
-  const detail = violations.length === 0 ? null : [
-    `${attribution} wrote outside its declared boundary.`,
+  const who = input.stepIds.length === 1 ? `step '${input.stepIds[0]}'` : `steps ${input.stepIds.map((id) => `'${id}'`).join(", ")} ran concurrently in one checkout, so the write cannot be attributed to one of them`;
+  const violationDetail = violations.length === 0 ? [] : [
+    `${who} wrote outside its declared boundary.`,
     `Unauthorized paths: ${violations.map((change) => change.path).join(", ")}.`,
     `Declared writes: ${describeWriteBoundary(allow)}.`,
     status === "rolled-back" ? "Those paths were rolled back to the baseline commit." : `Rollback is incomplete; the working tree is left as the step made it. Unrestorable: ${unrecoverable.map((entry) => `${entry.path} (${entry.reason})`).join("; ")}.`,
+    attributionComplete ? "Each was blamed on this window because a run in it recorded writing that path." : "This window had no complete write record, so every change outside the declaration was blamed on it.",
     "If the change was legitimate, widen the step's `writes:` declaration to cover it."
-  ].join(" ");
+  ];
+  const concurrentDetail = unattributed.length === 0 ? [] : [
+    `Concurrent changes were seen in this window that no run in it recorded writing: ${unattributed.map((change) => change.path).join(", ")}.`,
+    "They were left untouched, because a path this window did not write is not this window's to restore."
+  ];
+  const detail = [...violationDetail, ...concurrentDetail];
   const body = {
     version: 1,
     window: input.window,
@@ -906,11 +932,13 @@ function enforceWriteBoundary(input) {
     checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
     changedPaths: changes.map((change) => change.path),
     violations: violations.map((change) => change.path),
+    unattributed: unattributed.map((change) => change.path),
+    attributionComplete,
     rolledBack,
     unrecoverable,
     status,
     reason: violations.length === 0 ? null : WRITE_BOUNDARY_VIOLATION_REASON,
-    detail
+    detail: detail.length === 0 ? null : detail.join(" ")
   };
   return { ...body, digest: createHash2("sha256").update(canonicalVerdict(body), "utf8").digest("hex") };
 }
@@ -921,14 +949,41 @@ function assertWriteBoundaryInsideRoot(root, allow) {
     let probe = join3(realRoot, relativeEntry);
     while (probe !== realRoot && !existsSync3(probe)) probe = dirname(probe);
     const resolved = realpathSync3(probe);
-    if (resolved !== realRoot && !resolved.startsWith(realRoot + sep2)) {
+    if (resolved !== realRoot && !pathBoundaryEntryCovers(asDirectoryPathBoundary(realRoot), resolved)) {
       throw new Error(`write boundary: entry '${entry}' resolves to ${resolved}, outside the workspace at ${realRoot}`);
     }
   }
 }
+function assertWriteBoundaryVisibleToGit(root, allow) {
+  const entries = [...new Set(allow.map(normalizeWriteBoundaryEntry))].sort();
+  if (entries.length === 0) return;
+  const absolute = resolve3(root);
+  let raw;
+  try {
+    raw = git3(absolute, ["check-ignore", "-v", "-z", "--stdin"], `${entries.join("\0")}\0`);
+  } catch (error) {
+    const status = error.status;
+    if (status === 1) return;
+    throw new Error(
+      `write boundary: could not determine whether ${describeWriteBoundary(entries)} is ignored by git in ${absolute}: ${error.message}`
+    );
+  }
+  const fields = raw.split("\0");
+  const refusals = [];
+  for (let index = 0; index + 3 < fields.length; index += 4) {
+    const [source, line, pattern, path] = fields.slice(index, index + 4);
+    if (path === void 0 || path.length === 0) continue;
+    refusals.push(`'${path}' is ignored by ${source}:${line}:${pattern}`);
+  }
+  if (refusals.length === 0) return;
+  throw new Error(
+    `write boundary: ${refusals.join(", ")}. git status never reports an ignored path, so a boundary declared over one is verified against nothing and every window would be certified clean without an observation. Declare a path the repository tracks, or stop ignoring this one.`
+  );
+}
 function repoRelative(root, path) {
-  const rel = relative3(resolve3(root), resolve3(path));
-  if (rel.length === 0 || rel.startsWith("..") || rel.startsWith(`..${sep2}`)) return null;
+  const base = resolve3(root);
+  const rel = relative3(base, resolve3(base, path));
+  if (rel.length === 0 || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) return null;
   return rel.split(sep2).join("/");
 }
 function writeBoundaryDir(rootId) {
@@ -956,6 +1011,7 @@ function preflightWriteBoundaries(plan, root) {
     );
   }
   for (const step of declared) assertWriteBoundaryInsideRoot(root, step.writes ?? []);
+  assertWriteBoundaryVisibleToGit(root, [...new Set(declared.flatMap((step) => [...step.writes ?? []]))]);
 }
 function createWriteBoundaryEnforcer(input) {
   const open = /* @__PURE__ */ new Map();
@@ -964,10 +1020,26 @@ function createWriteBoundaryEnforcer(input) {
     for (const stepId of stepIds) for (const entry of input.boundaryFor(stepId) ?? []) allow.add(entry);
     return [...allow].sort();
   };
+  const attributionFor = (stepIds) => {
+    const recordedWritesFor = input.recordedWritesFor;
+    if (recordedWritesFor === void 0) return void 0;
+    const recorded = /* @__PURE__ */ new Set();
+    let complete = true;
+    for (const stepId of stepIds) {
+      const observed = recordedWritesFor(stepId);
+      if (observed === null) {
+        complete = false;
+        continue;
+      }
+      for (const target of observed) recorded.add(target);
+    }
+    return { recorded: [...recorded].sort(), complete };
+  };
   return {
     begin(window, stepIds) {
       const allow = allowFor(stepIds);
       assertWriteBoundaryInsideRoot(input.root, allow);
+      assertWriteBoundaryVisibleToGit(input.root, allow);
       open.set(window, { snapshot: captureWorkspaceSnapshot(input.root), allow });
     },
     async verify(window, stepIds) {
@@ -976,11 +1048,13 @@ function createWriteBoundaryEnforcer(input) {
         throw new Error(`write boundary: window '${window}' was verified without a snapshot`);
       }
       open.delete(window);
+      const attribution = attributionFor(stepIds);
       const verdict = enforceWriteBoundary({
         snapshot: pending.snapshot,
         window,
         stepIds,
-        allow: pending.allow
+        allow: pending.allow,
+        ...attribution === void 0 ? {} : { attribution }
       });
       const path = writeWriteBoundaryVerdict(input.rootId, verdict);
       input.onVerdict?.(verdict, path);
@@ -1023,4 +1097,4 @@ export {
   preflightWriteBoundaries,
   createWriteBoundaryEnforcer
 };
-//# sourceMappingURL=chunk-KZ2H5X4G.js.map
+//# sourceMappingURL=chunk-MXKJU4JB.js.map

package/dist/{chunk-DMD2AGVS.js → chunk-N22QMJKY.js}

@@ -1,16 +1,18 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   receiptResponseModelIdObservationLabel
-} from "./chunk-VREKEFLL.js";
+} from "./chunk-HLE42MG7.js";
 import {
-  adaptRunReceiptTrustStatus
-} from "./chunk-UUANF5CR.js";
+  adaptRunReceiptTrustStatus,
+  formatTrustAxes,
+  formatTrustSummary
+} from "./chunk-K4XHGFR5.js";
 import {
   formatBudgetPolicy,
   formatBudgetReasons,
   formatBudgetRequest,
   formatEffectiveBudget
-} from "./chunk-CEYBNUGC.js";
+} from "./chunk-A3WNZD3P.js";
 import {
   mentionsWorkerToolCallCap
 } from "./chunk-4ZG3XFUR.js";
@@ -73,9 +75,9 @@ function receiptActivityLabels(receipt, status) {
 }
 function receiptEvidenceLabels(receipt, verification, integrity) {
   const status = adaptRunReceiptTrustStatus({ ...receipt, verification }, { integrity });
-  const canonical = canonicalTrustLabel(status);
+  const canonical = canonicalTrustLabels(status);
   if (!integrity.ok) {
-    return [canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
+    return [...canonical, `receipt_integrity=FAILED reason=${JSON.stringify(integrity.reason)}`];
   }
   const briefing = receipt.briefing === void 0 ? "briefing=none" : `briefing=bytes:${receipt.briefing.bytes} sha256:${receipt.briefing.contentHash}`;
   let projectContext = "project_context=absent";
@@ -91,7 +93,7 @@ function receiptEvidenceLabels(receipt, verification, integrity) {
     `budget_reason=${JSON.stringify(formatBudgetReasons(receipt.budget))}`
   ];
   return [
-    canonical,
+    ...canonical,
     `receipt_integrity=verified/v${receipt.integrity.version}/${receipt.integrity.algorithm}`,
     `evidence_verification=${verification.state}/${verification.basis}`,
     `host_verification=${receipt.hostVerification?.status ?? "not_requested"}`,
@@ -103,16 +105,8 @@ function receiptEvidenceLabels(receipt, verification, integrity) {
     projectContext
   ];
 }
-function canonicalTrustLabel(status) {
-  return [
-    `trust_status=v${status.version}`,
-    `artifactIntegrity:${status.artifactIntegrity.state}`,
-    `validationGrounding:${status.validationGrounding.state}`,
-    `independentReview:${status.independentReview.state}`,
-    `contextProvenance:${status.contextProvenance.state}`,
-    `autonomyEnforcement:${status.autonomyEnforcement.state}`,
-    `completionEvidence:${status.completionEvidence.state}`
-  ].join(" ");
+function canonicalTrustLabels(status) {
+  return [`trust=${JSON.stringify(formatTrustSummary(status))}`, formatTrustAxes(status)];
 }
 function workerTextLabel(status) {
   switch (status.validationGrounding.state) {
@@ -122,6 +116,14 @@ function workerTextLabel(status) {
       return "reconnaissance output (advisory leads, not validation evidence):";
     case "unknown":
       return "worker claims (validation not observable at this layer):";
+    // The three remaining states were one label. The evidence bundle tells
+    // a failed check, an inferred claim, and no validation at all apart, so
+    // the terminal must too or it hands the operator a coarser verdict than
+    // the report for the same run.
+    case "failed":
+      return "worker claims (validation failed; a check ran and did not pass):";
+    case "ungrounded":
+      return "worker claims (inferred; validation claimed, none observed):";
     default:
       return "worker claims (unverified prose):";
   }
@@ -171,4 +173,4 @@ export {
   workerTextLabel,
   workerTextNonEvidenceNotices
 };
-//# sourceMappingURL=chunk-DMD2AGVS.js.map
+//# sourceMappingURL=chunk-N22QMJKY.js.map