@iowarp/clio-coder 0.4.4 → 0.4.5

package/dist/{chunk-TOIVGRUX.js → chunk-GJ24ODAX.js}

@@ -3,16 +3,16 @@ import {
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-U6TMQNSI.js";
+} from "./chunk-LTR5QCLS.js";
 import {
   clampTimerDelayMs
-} from "./chunk-EBY63B7G.js";
+} from "./chunk-6EXUUOSN.js";
 import {
   AI_AGENT_NAME
-} from "./chunk-6EJMN2Y3.js";
+} from "./chunk-ZTNFYMIO.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/safe-exec.ts
 init_esm_shims();
@@ -193,4 +193,4 @@ export {
   runCommandVector,
   combineSafeOutput
 };
-//# sourceMappingURL=chunk-TOIVGRUX.js.map
+//# sourceMappingURL=chunk-GJ24ODAX.js.map

package/dist/{chunk-QUFRYSWI.js → chunk-GNQRWTMY.js}

@@ -4,24 +4,27 @@ import {
   normalizeWriteBoundary,
   normalizeWriteBoundaryEntry,
   writeBoundaryCovers
-} from "./chunk-OEJSLEPW.js";
+} from "./chunk-YEJIG7LN.js";
 import {
   asDirectoryPathBoundary,
   pathBoundaryEntryCovers
-} from "./chunk-HHV2GANA.js";
+} from "./chunk-R2P2U3ZS.js";
 import {
   atomicWrite
-} from "./chunk-HAXOFFRH.js";
+} from "./chunk-FQOOGXBH.js";
+import {
+  buildSafeToolEnv
+} from "./chunk-GJ24ODAX.js";
 import {
   clioStateDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/compete-worktrees.ts
 init_esm_shims();
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   existsSync as existsSync2,
@@ -32,26 +35,74 @@ import {
   realpathSync as realpathSync2,
   renameSync,
   rmdirSync,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { hostname } from "node:os";
-import { join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+import { join as join3, relative as relative2, resolve as resolve2 } from "node:path";
 
-// src/tools/task-worktree.ts
+// src/domains/dispatch/workspace-checkpoint.ts
 init_esm_shims();
 import { execFileSync } from "node:child_process";
-import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function workspaceCheckpointRef(kind, identity) {
+  return `refs/clio-coder/${kind}/${createHash("sha256").update(identity).digest("hex")}`;
+}
+function captureWorkspaceCheckpoint(cwd, ref, message) {
+  if (!/^refs\/clio-coder\/(loop|compete)\/[a-f0-9]{64}$/.test(ref)) throw new Error("invalid workspace checkpoint ref");
+  const directory = mkdtempSync(join(tmpdir(), "clio-checkpoint-index-"));
+  const env = buildSafeToolEnv({
+    GIT_INDEX_FILE: join(directory, "index"),
+    GIT_AUTHOR_NAME: "Clio checkpoint",
+    GIT_AUTHOR_EMAIL: "checkpoint@clio.invalid",
+    GIT_COMMITTER_NAME: "Clio checkpoint",
+    GIT_COMMITTER_EMAIL: "checkpoint@clio.invalid"
+  });
+  const config = ["-c", "core.hooksPath=/dev/null", "-c", "core.fsmonitor=false"];
+  const git4 = (args) => execFileSync("git", ["-C", cwd, ...config, ...args], {
+    env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4,
+    maxBuffer: 1024 * 1024
+  }).trim();
+  try {
+    try {
+      git4(["rev-parse", "--verify", ref]);
+      return ref;
+    } catch {
+    }
+    const head = git4(["rev-parse", "HEAD"]);
+    const filterKeys = git4(["config", "--null", "--name-only", "--list"]).split("\0").filter((key) => /^filter\..*\.(?:clean|process|required)$/.test(key));
+    for (const key of filterKeys) config.push("-c", `${key}=${key.endsWith(".required") ? "false" : ""}`);
+    git4(["read-tree", head]);
+    git4(["add", "-A", "--", "."]);
+    const tree = git4(["write-tree"]);
+    const commit = git4(["commit-tree", tree, "-p", head, "-m", message]);
+    git4(["update-ref", ref, commit, ""]);
+    return ref;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+// src/tools/task-worktree.ts
+init_esm_shims();
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync as rmSync2, writeFileSync } from "node:fs";
+import { isAbsolute, join as join2, relative, resolve, sep } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 var OWNER_FILE_SUFFIX = ".task-owner.json";
 var TASK_WORKTREE_KIND = "clio-coder-task-worktree";
 var LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
 var COMMIT_IDENTITY = "clio-coder-task";
 function gitBytes(root, args) {
-  return execFileSync("git", ["-C", root, ...args], {
+  return execFileSync2("git", ["-C", root, ...args], {
     stdio: ["ignore", "pipe", "pipe"],
     timeout: 3e4
   });
@@ -158,8 +209,8 @@ function createTaskWorktree(root, runId, base) {
   validateRunId(runId);
   const canonical = realpathSync(root);
   const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
-  const parent = join(canonical, ".clio-coder", "worktrees");
-  const path = join(parent, runId);
+  const parent = join2(canonical, ".clio-coder", "worktrees");
+  const path = join2(parent, runId);
   const branch = `clio-coder/task/${runId}`;
   mkdirSync(parent, { recursive: true });
   if (!isCanonicalWorktreePathInside(parent, path))
@@ -175,8 +226,8 @@ function createTaskWorktree(root, runId, base) {
   return { root: canonical, runId, path, branch, base: resolvedBase, ownerToken };
 }
 function assertOwnership(worktree) {
-  const expected = join(worktree.root, ".clio-coder", "worktrees", worktree.runId);
-  if (resolve(worktree.path) !== resolve(expected) || !isCanonicalWorktreePathInside(join(worktree.root, ".clio-coder", "worktrees"), worktree.path)) {
+  const expected = join2(worktree.root, ".clio-coder", "worktrees", worktree.runId);
+  if (resolve(worktree.path) !== resolve(expected) || !isCanonicalWorktreePathInside(join2(worktree.root, ".clio-coder", "worktrees"), worktree.path)) {
     throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
   }
   const ownerPath = `${worktree.path}${OWNER_FILE_SUFFIX}`;
@@ -199,7 +250,7 @@ function commitTaskWorktree(worktree, message = `Clio Coder task ${worktree.runI
 }
 function taskWorktreeDiffHash(worktree) {
   const bytes = gitBytes(worktree.root, ["diff", `${worktree.base}..${worktree.branch}`]);
-  return createHash("sha256").update(bytes).digest("hex");
+  return createHash2("sha256").update(bytes).digest("hex");
 }
 function protectedPathsChangedByTaskBranch(worktree, protectedPaths) {
   return protectedPathsChangedByWorktreeBranch(worktree.root, worktree.branch, protectedPaths);
@@ -226,11 +277,11 @@ function cleanupTaskWorktree(worktree, deleteBranch) {
   try {
     git(worktree.root, ["worktree", "remove", "--force", worktree.path]);
   } catch {
-    if (existsSync(worktree.path)) rmSync(worktree.path, { recursive: true, force: true });
+    if (existsSync(worktree.path)) rmSync2(worktree.path, { recursive: true, force: true });
     git(worktree.root, ["worktree", "prune"]);
   }
   if (deleteBranch) git(worktree.root, ["branch", "-D", worktree.branch]);
-  rmSync(`${worktree.path}${OWNER_FILE_SUFFIX}`, { force: true });
+  rmSync2(`${worktree.path}${OWNER_FILE_SUFFIX}`, { force: true });
 }
 
 // src/tools/compete-worktrees.ts
@@ -243,7 +294,7 @@ var SAFE_GROUP = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var PROCESS_EXIT_GRACE_MS = 750;
 var PROCESS_POLL_MS = 25;
 function git2(root, args) {
-  return execFileSync2("git", ["-C", root, ...args], {
+  return execFileSync3("git", ["-C", root, ...args], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: 3e4
@@ -273,7 +324,7 @@ function processSnapshot(pid) {
   } catch {
   }
   try {
-    const started = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
+    const started = execFileSync3("ps", ["-o", "lstart=", "-p", String(pid)], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 2e3
@@ -349,14 +400,14 @@ function canonicalRoot(root) {
   return realpathSync2(root);
 }
 function competeParent(root) {
-  return join2(root, ...COMPETE_PARENT_SEGMENTS);
+  return join3(root, ...COMPETE_PARENT_SEGMENTS);
 }
 function groupDirectory(root, group) {
   validateGroup(group);
-  return join2(competeParent(root), group);
+  return join3(competeParent(root), group);
 }
 function manifestPath(directory) {
-  return join2(directory, COMPETE_MANIFEST_FILE);
+  return join3(directory, COMPETE_MANIFEST_FILE);
 }
 function isPlainDirectory(path) {
   try {
@@ -433,7 +484,7 @@ function replaceManifest(ownership, manifest) {
 `, { encoding: "utf8", flag: "wx" });
     renameSync(temporary, destination);
   } finally {
-    if (existsSync2(temporary)) rmSync2(temporary, { force: true });
+    if (existsSync2(temporary)) rmSync3(temporary, { force: true });
   }
 }
 function isGitRepository(root) {
@@ -555,7 +606,7 @@ function markCompeteGroupWinnerPreserved(ownership, winnerIndex) {
 function createCandidateWorktree(ownership, index, baseline) {
   assertOwnership2(ownership);
   const branch = competeBranch(ownership.group, index);
-  const path = join2(ownership.directory, `candidate-${index}`);
+  const path = join3(ownership.directory, `candidate-${index}`);
   if (!isCanonicalPathInside(ownership.directory, path)) {
     throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
   }
@@ -565,7 +616,7 @@ function createCandidateWorktree(ownership, index, baseline) {
 async function createCandidateWorktreeMapped(ownership, index, baseline, mux) {
   assertOwnership2(ownership);
   const branch = competeBranch(ownership.group, index);
-  const path = join2(ownership.directory, `candidate-${index}`);
+  const path = join3(ownership.directory, `candidate-${index}`);
   if (!isCanonicalPathInside(ownership.directory, path)) {
     throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
   }
@@ -625,16 +676,33 @@ function removeRegisteredWorktree(root, path) {
   try {
     git2(root, ["worktree", "remove", "--force", path]);
   } catch {
-    if (existsSync2(path)) rmSync2(path, { recursive: true, force: true });
+    if (existsSync2(path)) rmSync3(path, { recursive: true, force: true });
     git2(root, ["worktree", "prune"]);
   }
 }
+function preserveCandidateWorktree(ownership, path, index) {
+  if (resolve2(path) !== resolve2(join3(ownership.directory, `candidate-${index}`)) || !isCanonicalPathInside(ownership.directory, path))
+    throw new Error("candidate checkpoint path is outside its proven group");
+  const ref = workspaceCheckpointRef("compete", `${ownership.group}:${index}`);
+  if (existsSync2(path)) captureWorkspaceCheckpoint(path, ref, `Compete ${ownership.group} candidate ${index}`);
+  else {
+    const branch = competeBranchForCandidate(ownership.root, ownership.group, index);
+    if (exactGroupBranches(ownership.root, ownership.group).includes(branch)) {
+      try {
+        git2(ownership.root, ["rev-parse", "--verify", ref]);
+      } catch {
+        git2(ownership.root, ["update-ref", ref, branch, ""]);
+      }
+    }
+  }
+}
 function removeCandidateWorktree(ownership, worktree, deleteBranch) {
   assertOwnership2(ownership);
-  const expectedPath = join2(ownership.directory, `candidate-${worktree.index}`);
+  const expectedPath = join3(ownership.directory, `candidate-${worktree.index}`);
   if (resolve2(worktree.path) !== resolve2(expectedPath) || !competeBranchMatches(worktree.branch, ownership.group, worktree.index) || !isCanonicalPathInside(ownership.directory, worktree.path)) {
     throw new Error(`candidate ${worktree.index} does not belong to compete group ${ownership.group}`);
   }
+  preserveCandidateWorktree(ownership, worktree.path, worktree.index);
   removeRegisteredWorktree(ownership.root, worktree.path);
   if (deleteBranch && exactGroupBranches(ownership.root, ownership.group).includes(worktree.branch)) {
     git2(ownership.root, ["branch", "-D", worktree.branch]);
@@ -648,6 +716,8 @@ function removeCandidateWorktree(ownership, worktree, deleteBranch) {
   }
 }
 async function removeCandidateWorktreeMapped(ownership, worktree, deleteBranch, mux) {
+  assertOwnership2(ownership);
+  preserveCandidateWorktree(ownership, worktree.path, worktree.index);
   const workspaceId = worktree.provenance?.backend === "herdr" ? worktree.provenance.workspaceId : void 0;
   if (workspaceId && mux?.available()) {
     await mux.worktreeRemove(workspaceId, { force: true }).catch(() => false);
@@ -661,6 +731,8 @@ function cleanupWorktreeGroup(ownership) {
   assertOwnership2(ownership);
   for (const path of registeredWorktreePaths(ownership.root)) {
     if (!isCanonicalPathInside(ownership.directory, path)) continue;
+    const index = Number.parseInt(path.split(/[\\/]/).at(-1)?.replace("candidate-", "") ?? "", 10);
+    if (Number.isInteger(index)) preserveCandidateWorktree(ownership, path, index);
     removeRegisteredWorktree(ownership.root, path);
   }
   git2(ownership.root, ["worktree", "prune"]);
@@ -673,6 +745,13 @@ function cleanupWorktreeGroup(ownership) {
     );
   }
   for (const branch of exactGroupBranches(ownership.root, ownership.group)) {
+    const index = Number.parseInt(branch.split("/").at(-1) ?? "", 10);
+    const ref = workspaceCheckpointRef("compete", `${ownership.group}:${index}`);
+    try {
+      git2(ownership.root, ["rev-parse", "--verify", ref]);
+    } catch {
+      git2(ownership.root, ["update-ref", ref, branch, ""]);
+    }
     git2(ownership.root, ["branch", "-D", branch]);
   }
   const branchesRemain = exactGroupBranches(ownership.root, ownership.group);
@@ -682,7 +761,7 @@ function cleanupWorktreeGroup(ownership) {
   assertOwnership2(ownership);
   for (const entry of readdirSync(ownership.directory)) {
     if (entry === COMPETE_MANIFEST_FILE) continue;
-    rmSync2(join2(ownership.directory, entry), { recursive: true, force: true });
+    rmSync3(join3(ownership.directory, entry), { recursive: true, force: true });
   }
   assertOwnership2(ownership);
   const unexpected = readdirSync(ownership.directory).filter((entry) => entry !== COMPETE_MANIFEST_FILE);
@@ -725,7 +804,7 @@ function settleRecoveredCompeteDecision(root, group, winnerIndex) {
   }
   const branches = exactGroupBranches(ownership.root, group);
   const winnerBranch = competeBranchForCandidate(ownership.root, group, winnerIndex);
-  const winnerPath = join2(ownership.directory, `candidate-${winnerIndex}`);
+  const winnerPath = join3(ownership.directory, `candidate-${winnerIndex}`);
   if (!branches.includes(winnerBranch) || !registeredWorktreePaths(ownership.root).some((path) => resolve2(path) === resolve2(winnerPath))) {
     throw new Error(`recovered winner ${winnerBranch} has no intact candidate worktree`);
   }
@@ -733,7 +812,7 @@ function settleRecoveredCompeteDecision(root, group, winnerIndex) {
   for (const branch of branches) {
     const index = Number.parseInt(branch.split("/").at(-1) ?? "", 10);
     if (index === winnerIndex) continue;
-    removeCandidateWorktree(ownership, { index, branch, path: join2(ownership.directory, `candidate-${index}`) }, true);
+    removeCandidateWorktree(ownership, { index, branch, path: join3(ownership.directory, `candidate-${index}`) }, true);
   }
   return ownership;
 }
@@ -798,15 +877,15 @@ function recoverCleanupReadyCompeteGroups(root, options = {}) {
 
 // src/domains/dispatch/write-boundary.ts
 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, isAbsolute as isAbsolute2, join as join3, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync3, lstatSync as lstatSync2, mkdirSync as mkdirSync3, readlinkSync, realpathSync as realpathSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname, isAbsolute as isAbsolute2, join as join4, 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;
 function git3(root, args, input) {
-  return execFileSync3("git", ["-C", root, ...args], {
+  return execFileSync4("git", ["-C", root, ...args], {
     encoding: "utf8",
     stdio: ["pipe", "pipe", "pipe"],
     timeout: GIT_TIMEOUT_MS,
@@ -815,7 +894,7 @@ function git3(root, args, input) {
   });
 }
 function gitBytes2(root, args) {
-  return execFileSync3("git", ["-C", root, ...args], {
+  return execFileSync4("git", ["-C", root, ...args], {
     stdio: ["ignore", "pipe", "pipe"],
     timeout: GIT_TIMEOUT_MS,
     maxBuffer: 256 * 1024 * 1024
@@ -830,7 +909,7 @@ function contentTokens(root, paths) {
   const tokens = /* @__PURE__ */ new Map();
   const hashable = [];
   for (const path of paths) {
-    const full = join3(root, path);
+    const full = join4(root, path);
     let stat;
     try {
       stat = lstatSync2(full);
@@ -857,7 +936,7 @@ function contentTokens(root, paths) {
     hashable.push(path);
   }
   if (hashable.length > 0) {
-    const hashes = git3(root, ["hash-object", "--stdin-paths"], `${hashable.map((path) => join3(root, path)).join("\n")}
+    const hashes = git3(root, ["hash-object", "--stdin-paths"], `${hashable.map((path) => join4(root, path)).join("\n")}
 `).split("\n").filter((line) => line.length > 0);
     hashable.forEach((path, index) => {
       tokens.set(path, `blob:${hashes[index] ?? "unknown"}`);
@@ -923,7 +1002,7 @@ function canonicalVerdict(verdict) {
   return JSON.stringify(verdict);
 }
 function rollbackPath(snapshot, change) {
-  const full = join3(snapshot.root, change.path);
+  const full = join4(snapshot.root, change.path);
   if (snapshot.entries.has(change.path)) {
     return {
       unrecoverable: {
@@ -934,7 +1013,7 @@ function rollbackPath(snapshot, change) {
   }
   if (change.before === ABSENT) {
     try {
-      rmSync3(full, { force: true, recursive: false });
+      rmSync4(full, { force: true, recursive: false });
     } catch (error) {
       return {
         unrecoverable: { path: change.path, reason: `could not remove: ${error.message}` }
@@ -1030,13 +1109,13 @@ function enforceWriteBoundary(input) {
     reason: violations.length === 0 ? null : WRITE_BOUNDARY_VIOLATION_REASON,
     detail: detail.length === 0 ? null : detail.join(" ")
   };
-  return { ...body, digest: createHash2("sha256").update(canonicalVerdict(body), "utf8").digest("hex") };
+  return { ...body, digest: createHash3("sha256").update(canonicalVerdict(body), "utf8").digest("hex") };
 }
 function assertWriteBoundaryInsideRoot(root, allow) {
   const realRoot = realpathSync3(resolve3(root));
   for (const entry of allow) {
     const relativeEntry = entry.endsWith("/") ? entry.slice(0, -1) : entry;
-    let probe = join3(realRoot, relativeEntry);
+    let probe = join4(realRoot, relativeEntry);
     while (probe !== realRoot && !existsSync3(probe)) probe = dirname(probe);
     const resolved = realpathSync3(probe);
     if (resolved !== realRoot && !pathBoundaryEntryCovers(asDirectoryPathBoundary(realRoot), resolved)) {
@@ -1077,10 +1156,10 @@ function repoRelative(root, path) {
   return rel.split(sep2).join("/");
 }
 function writeBoundaryDir(rootId) {
-  return join3(clioStateDir(), "write-boundaries", rootId);
+  return join4(clioStateDir(), "write-boundaries", rootId);
 }
 function writeBoundaryVerdictPath(rootId, window) {
-  return join3(writeBoundaryDir(rootId), `${window.replace(/[^A-Za-z0-9._-]/gu, "_")}.json`);
+  return join4(writeBoundaryDir(rootId), `${window.replace(/[^A-Za-z0-9._-]/gu, "_")}.json`);
 }
 function writeWriteBoundaryVerdict(rootId, verdict) {
   const path = writeBoundaryVerdictPath(rootId, verdict.window);
@@ -1182,6 +1261,8 @@ export {
   createTaskWorktree,
   applyTaskWorktree,
   cleanupTaskWorktree,
+  workspaceCheckpointRef,
+  captureWorkspaceCheckpoint,
   isGitRepository,
   claimCompeteGroup,
   loadCompeteGroup,
@@ -1205,4 +1286,4 @@ export {
   preflightWriteBoundaries,
   createWriteBoundaryEnforcer
 };
-//# sourceMappingURL=chunk-QUFRYSWI.js.map
+//# sourceMappingURL=chunk-GNQRWTMY.js.map

package/dist/{chunk-5ICU3EUH.js → chunk-GVYWZNRK.js}

@@ -4,17 +4,17 @@ import {
   settingsPath,
   validateSettings,
   withSettingsLock
-} from "./chunk-GHS5EBTQ.js";
+} from "./chunk-FKIOX6DS.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/lifecycle/migrations/2026-09-01-settings-v2.ts
 init_esm_shims();
@@ -305,4 +305,4 @@ export {
   migrateSettingsV1Document,
   settings_v2_default
 };
-//# sourceMappingURL=chunk-5ICU3EUH.js.map
+//# sourceMappingURL=chunk-GVYWZNRK.js.map

package/dist/{chunk-GX5WYQO4.js → chunk-GXCCHKN6.js}

@@ -1,19 +1,19 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   VERIFICATION_SCRIPT_FAMILY_HINT
-} from "./chunk-UL3WSD3F.js";
+} from "./chunk-M4KFUXS7.js";
 import {
   typebox_exports
-} from "./chunk-5B2AEOW5.js";
+} from "./chunk-GH5ZR6JP.js";
 import {
   ToolNames
-} from "./chunk-4NSRCOYP.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   StringEnum
-} from "./chunk-YPC6ZR5L.js";
+} from "./chunk-5CMARGPF.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/verify/surface.ts
 init_esm_shims();
@@ -56,4 +56,4 @@ export {
   prepareVerifyArguments,
   verifyToolSurface
 };
-//# sourceMappingURL=chunk-GX5WYQO4.js.map
+//# sourceMappingURL=chunk-GXCCHKN6.js.map

package/dist/{chunk-K6T2ZAMZ.js → chunk-HGSLRG33.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   runVectorTool
-} from "./chunk-BJVFZO5U.js";
+} from "./chunk-WJIMKGD6.js";
 import {
   PROJECT_VERIFIER_CATALOG_RELATIVE_PATH,
   compareNumeric,
@@ -13,17 +13,17 @@ import {
   renderNumericReport,
   renderPerfBaseline,
   resolveProjectVerifierExecutionCwd
-} from "./chunk-DXKJURES.js";
+} from "./chunk-MDU3C27C.js";
 import {
   declaredVerificationScripts
-} from "./chunk-UL3WSD3F.js";
+} from "./chunk-M4KFUXS7.js";
 import {
   resolveSafeCwd,
   runCommandVector
-} from "./chunk-TOIVGRUX.js";
+} from "./chunk-GJ24ODAX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/verify/scripts.ts
 init_esm_shims();
@@ -401,4 +401,4 @@ export {
   recordPerfBaseline,
   runScriptCheck
 };
-//# sourceMappingURL=chunk-K6T2ZAMZ.js.map
+//# sourceMappingURL=chunk-HGSLRG33.js.map

package/dist/{chunk-26QSH3EJ.js → chunk-HHVJNVUJ.js}

@@ -2,17 +2,17 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   resolveAuthTarget,
   resolveRuntimeAuthTarget
-} from "./chunk-ID64D7PE.js";
+} from "./chunk-HXHFDHB6.js";
 import {
   getRuntimeRegistry
-} from "./chunk-NUGM5KR6.js";
+} from "./chunk-SRCEQKQS.js";
 import {
   catalogProviderForRuntime,
   listCatalogModelsForRuntime
-} from "./chunk-5OIVVPHF.js";
+} from "./chunk-TN5FW4XY.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/providers/support.ts
 init_esm_shims();
@@ -176,4 +176,4 @@ export {
   configuredTargetsForRuntime,
   resolveProviderReference
 };
-//# sourceMappingURL=chunk-26QSH3EJ.js.map
+//# sourceMappingURL=chunk-HHVJNVUJ.js.map

package/dist/{chunk-F4EKGO4N.js → chunk-HL26ADLH.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/bus-events.ts
 init_esm_shims();
@@ -38,7 +38,9 @@ var BusChannels = {
   CompactionEnd: "compaction.end",
   MiddlewareHookFailed: "middleware.hookFailed",
   ExtensionsReloaded: "extensions.reloaded",
+  ExtensionsLoadIssue: "extensions.loadIssue",
   ContextActivity: "context.activity",
+  ContextSourcesChanged: "context.sourcesChanged",
   ContextWarning: "context.warning",
   ContextPruned: "context.pruned",
   ContextRecalled: "context.recalled",
@@ -72,4 +74,4 @@ export {
   BusChannels,
   isRunAbortedPayload
 };
-//# sourceMappingURL=chunk-F4EKGO4N.js.map
+//# sourceMappingURL=chunk-HL26ADLH.js.map

package/dist/{chunk-JT2RFCC5.js → chunk-HR3HPQ76.js}

@@ -1,17 +1,17 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   FAILURE_CAUSE_TAGS
-} from "./chunk-NRO2BJRH.js";
+} from "./chunk-SDWNDICN.js";
 import {
   withStateFileLock,
   withStateFileLockSync
-} from "./chunk-IKCO5N3L.js";
+} from "./chunk-2QPI3TR3.js";
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/observability/evidence-index.ts
 init_esm_shims();
@@ -263,4 +263,4 @@ export {
   appendOutOfTurnUsageRow,
   readOutOfTurnUsageRows
 };
-//# sourceMappingURL=chunk-JT2RFCC5.js.map
+//# sourceMappingURL=chunk-HR3HPQ76.js.map