opencode-swarm 7.199.0 → 7.199.2

package/dist/cli/{index-awt5dpam.js → index-h349p91m.js}

@@ -685,6 +685,37 @@ function selfHealAuthorityKeys(directory, keys) {
     mergeAuthorityKeys(directory, state, keys);
   } catch {}
 }
+function getCoderRetryEscalationActions(directory, taskId, retryEpoch) {
+  const actions = new Set;
+  const prefix = `retry|${taskId}|${retryEpoch}|`;
+  const state = loadAuthorityIndex(directory);
+  if (state.kind === "corrupt") {
+    throw new Error("CORE_EVENT_AUTHORITY_INDEX_UNREADABLE");
+  }
+  const heal = [];
+  if (state.kind === "ok") {
+    for (const key of Object.keys(state.index.entries)) {
+      if (key.startsWith(prefix)) {
+        const action = key.slice(prefix.length);
+        if (RETRY_ACTIONS.has(action)) {
+          actions.add(action);
+        }
+      }
+    }
+  }
+  for (const event of scanWindowFor(directory, (e) => e.type === AUTHORITY_RETRY && e.taskId === taskId && e.retryEpoch === retryEpoch && typeof e.action === "string" && RETRY_ACTIONS.has(e.action))) {
+    const action = event.action;
+    if (!actions.has(action)) {
+      actions.add(action);
+      const key = authorityKeyFor(event);
+      if (key)
+        heal.push(key);
+    }
+  }
+  if (heal.length > 0)
+    selfHealAuthorityKeys(directory, heal);
+  return actions;
+}
 function hasAuthorityEvent(directory, key, predicate) {
   const state = loadAuthorityIndex(directory);
   if (state.kind === "corrupt") {
@@ -904,4 +935,4 @@ function emitHealth(directory, payload, preloadedAuthorityState) {
   _internals.emitHealth(directory, payload, preloadedAuthorityState);
 }
 
-export { readCoreEvents, getCoreEventCoverage, CORE_EVENT_LOCKED, appendCoreEventSync, appendCoreEventsSync, hasSpecDriftAuditEvent, hasTaskRepairAuditEvent, finalizeCoreEventsForClose };
+export { readCoreEvents, getCoreEventCoverage, CORE_EVENT_LOCKED, appendCoreEventSync, appendCoreEventsSync, getCoderRetryEscalationActions, hasSpecDriftAuditEvent, hasTaskRepairAuditEvent, finalizeCoreEventsForClose };

package/dist/cli/{index-42dtc5nd.js → index-hfsyvkn0.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   loadPlanJsonOnly
-} from "./index-tnrq0pg8.js";
+} from "./index-mb3y5cgy.js";
 import {
   isCanonicalPathWithinRoot
 } from "./index-6b295cas.js";
@@ -14,7 +14,7 @@ import {
   legacyEpicIssuePath,
   migrateLegacyEpicConfig,
   resolveEpicConfig
-} from "./index-qdwccqv5.js";
+} from "./index-vd6s2mxq.js";
 import {
   FALLBACK_MODELS_MAX,
   GATE_CONFIG_KNOWN_SECTION_KEYS,
@@ -25,13 +25,13 @@ import {
   init_schema,
   retiredEpicKeyReplacement,
   stripKnownSwarmPrefix
-} from "./index-3x07b03s.js";
+} from "./index-5mbpybdm.js";
 import {
   ALL_AGENT_NAMES,
   TOOL_NAME_SET,
   init_constants,
   init_tool_metadata
-} from "./index-hqrkr9ag.js";
+} from "./index-xfzkq1k4.js";
 import {
   log
 } from "./index-zgwm4ryv.js";

package/dist/cli/{index-3gwh8c9d.js → index-hj76n215.js}

@@ -4745,7 +4745,7 @@ async function reconcileLegacyCoderSettlements(directory, maxRecords, onReconcil
   const candidates = readDelegations(directory).filter((record) => record.normalizedAgent === "coder" && Boolean(record.legacyCoderSettlementTransfer) && Boolean(record.terminalResult)).slice(0, maxRecords);
   if (candidates.length === 0)
     return 0;
-  const { transferCoderSettlementToBackground } = await import("./coder-settlement-qy77s1x6.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-189074m3.js");
   let transferred = 0;
   for (const record of candidates) {
     try {

package/dist/cli/{index-9ztsfved.js → index-hz2609qt.js}

@@ -201,8 +201,9 @@ async function runGitAsyncDetailed(directory, args, timeoutMs) {
     } catch {}
   }
 }
+var gitSnapshotRelativePathPattern = /^(?:\.\/|\.?(?=[A-Za-z0-9]))(?:\.?[A-Za-z0-9][A-Za-z0-9._-]*\/)*\.?[A-Za-z0-9][A-Za-z0-9._-]*$/;
 function readGitTextAtRevision(directory, revision, relativePath) {
-  if (!isSafeGitRevisionToken(revision) || !/^\.?(?:[A-Za-z0-9][A-Za-z0-9._-]*\/)*[A-Za-z0-9][A-Za-z0-9._-]*$/.test(relativePath) || relativePath.split("/").includes("..")) {
+  if (!isSafeGitRevisionToken(revision) || !gitSnapshotRelativePathPattern.test(relativePath) || relativePath.split("/").includes("..")) {
     return null;
   }
   const result = _internals.spawnSync(_internals.resolveGitExecutable(), ["-C", directory, "show", `${revision}:${relativePath}`], {
@@ -533,6 +534,120 @@ async function resolveIsWorkingTreeCleanAsync(directory) {
   ]);
   return status === null ? null : status.length === 0;
 }
+async function resolveWorkingTreeDirtyPathsAsync(directory) {
+  const status = await runGitAsync(directory, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ]);
+  if (status === null)
+    return null;
+  const paths = [];
+  let skipNextRecord = false;
+  for (const entry of status.split("\x00")) {
+    if (entry.length === 0)
+      continue;
+    if (skipNextRecord) {
+      skipNextRecord = false;
+      continue;
+    }
+    if (entry.length < 4)
+      continue;
+    const statusCode = entry.slice(0, 2);
+    if (statusCode.startsWith("R") || statusCode.startsWith("C")) {
+      skipNextRecord = true;
+    }
+    const rawPath = entry.slice(3);
+    if (rawPath.length === 0)
+      continue;
+    paths.push(rawPath);
+  }
+  return paths;
+}
+async function resolvePrWorkflowChangedPathSetAsync(directory, baseHeadSha) {
+  if (!/^[0-9a-f]{40}$/i.test(baseHeadSha))
+    return null;
+  const diff = await runGitAsync(directory, [
+    "diff",
+    "--no-ext-diff",
+    "--name-only",
+    "-z",
+    baseHeadSha
+  ]);
+  if (diff === null)
+    return null;
+  const status = await runGitAsync(directory, [
+    "status",
+    "--porcelain=v1",
+    "-z",
+    "--untracked-files=all"
+  ]);
+  if (status === null)
+    return null;
+  const set = new Set;
+  const normalize = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "");
+  for (const name of diff.split("\x00")) {
+    if (name.length > 0)
+      set.add(normalize(name));
+  }
+  let skipNextRecord = false;
+  for (const entry of status.split("\x00")) {
+    if (entry.length === 0)
+      continue;
+    if (skipNextRecord) {
+      skipNextRecord = false;
+      continue;
+    }
+    if (entry.length < 4 || entry[2] !== " ")
+      continue;
+    const statusCode = entry.slice(0, 2);
+    if (statusCode.includes("R") || statusCode.includes("C")) {
+      skipNextRecord = true;
+    }
+    const rawPath = entry.slice(3);
+    if (rawPath.length === 0)
+      continue;
+    set.add(normalize(rawPath));
+  }
+  return set;
+}
+async function resolveRepoTopLevelAsync(directory) {
+  const toplevel = await runGitAsync(directory, [
+    "rev-parse",
+    "--show-toplevel"
+  ]);
+  if (toplevel === null || toplevel.length === 0)
+    return null;
+  return toplevel;
+}
+async function resolveLocalRefHeadAsync(directory, ref) {
+  if (!/^[A-Za-z0-9._/-]+$/.test(ref))
+    return null;
+  const sha = await runGitAsync(directory, [
+    "rev-parse",
+    "--verify",
+    `${ref}^{commit}`
+  ]);
+  return sha && /^[0-9a-f]{40}$/i.test(sha) ? sha.toLowerCase() : null;
+}
+async function resolveIsAncestorAsync(directory, ancestor, descendant) {
+  if (!/^[0-9a-f]{40}$/i.test(ancestor) || !/^[0-9a-f]{40}$/i.test(descendant))
+    return false;
+  const out = await runGitAsyncDetailed(directory, ["merge-base", "--is-ancestor", ancestor, descendant], _internals.gitTimeoutMs);
+  if (!out.ok) {
+    if (out.reason === "git-failed")
+      return false;
+    return null;
+  }
+  return true;
+}
+async function fastForwardToRefAsync(directory, ref) {
+  if (!/^[A-Za-z0-9._/-]+$/.test(ref))
+    return false;
+  const out = await runGitAsync(directory, ["merge", "--ff-only", "--", ref], 15000);
+  return out !== null;
+}
 function resolveCommitCountSince(directory, baseHeadSha, currentHeadSha) {
   if (!isSafeGitRevisionToken(baseHeadSha) || !isSafeGitRevisionToken(currentHeadSha))
     return null;
@@ -1322,4 +1437,4 @@ var _internals = {
   readChangedFileSync: (filePath) => fs.readFileSync(filePath)
 };
 
-export { readGitTextAtRevision, resolveCurrentGitHead, resolveCurrentGitHeadAsync, resolveExactMergeBase, resolveExactMergeBaseAsync, resolvePrReviewDiffStats, resolvePrReviewDiffStatsAsync, resolveCurrentUpstreamRemoteRef, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamPushTargetAsync, resolveCurrentLocalHeadRefAsync, resolveExactRemoteBranchHead, resolveExactRemoteBranchHeadAsync, redactRemoteUrlIdentity, resolveRemoteUrlIdentity, resolveRemoteUrlIdentityAsync, resolveGitControlStateDigest, resolveGitControlStateDigestAsync, resolveIsWorkingTreeClean, resolveIsWorkingTreeCleanAsync, resolveCommitCountSince, resolveCommitCountSinceAsync, resolveIsExactSingleChildCommit, resolveIsExactSingleChildCommitAsync, resolveRemoteRefsContainingHead, resolveRemoteRefsContainingHeadAsync, resolvePrFeedbackTrackingCandidatesAsync, switchPrFeedbackTrackingCandidateAsync, resolvePrWorkflowRevisionDigestDetailed, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestDetailedAsync, resolvePrWorkflowRevisionDigestAsync, parsePorcelainPaths, isSwarmRuntimePath, parsePorcelainV2Snapshot, captureWorkspaceSnapshot, captureWorkspaceSnapshotAsync, shouldSkipSnapshot, changedFilesSinceSnapshot, changedFilesSinceSnapshotAsync, committedFilesBetween, workspaceSnapshotMatches, compareWorkspaceSnapshot, compareWorkspaceSnapshots, digest, _internals };
+export { readGitTextAtRevision, resolveCurrentGitHead, resolveCurrentGitHeadAsync, resolveExactMergeBase, resolveExactMergeBaseAsync, resolvePrReviewDiffStats, resolvePrReviewDiffStatsAsync, resolveCurrentUpstreamRemoteRef, resolveCurrentUpstreamPushTarget, resolveCurrentUpstreamPushTargetAsync, resolveCurrentLocalHeadRefAsync, resolveExactRemoteBranchHead, resolveExactRemoteBranchHeadAsync, redactRemoteUrlIdentity, resolveRemoteUrlIdentity, resolveRemoteUrlIdentityAsync, resolveGitControlStateDigest, resolveGitControlStateDigestAsync, resolveIsWorkingTreeClean, resolveIsWorkingTreeCleanAsync, resolveWorkingTreeDirtyPathsAsync, resolvePrWorkflowChangedPathSetAsync, resolveRepoTopLevelAsync, resolveLocalRefHeadAsync, resolveIsAncestorAsync, fastForwardToRefAsync, resolveCommitCountSince, resolveCommitCountSinceAsync, resolveIsExactSingleChildCommit, resolveIsExactSingleChildCommitAsync, resolveRemoteRefsContainingHead, resolveRemoteRefsContainingHeadAsync, resolvePrFeedbackTrackingCandidatesAsync, switchPrFeedbackTrackingCandidateAsync, resolvePrWorkflowRevisionDigestDetailed, resolvePrWorkflowRevisionDigest, resolvePrWorkflowRevisionDigestDetailedAsync, resolvePrWorkflowRevisionDigestAsync, parsePorcelainPaths, isSwarmRuntimePath, parsePorcelainV2Snapshot, captureWorkspaceSnapshot, captureWorkspaceSnapshotAsync, shouldSkipSnapshot, changedFilesSinceSnapshot, changedFilesSinceSnapshotAsync, committedFilesBetween, workspaceSnapshotMatches, compareWorkspaceSnapshot, compareWorkspaceSnapshots, digest, _internals };

package/dist/cli/{index-b5k6etf9.js → index-jrdepg4w.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   computePlanStructureHash
-} from "./index-26h8fb7t.js";
+} from "./index-djtqb6b7.js";
 import {
   appendCoreEventSync
-} from "./index-awt5dpam.js";
+} from "./index-h349p91m.js";
 import {
   deleteCoordinationState,
   importCoordinationOnce,

package/dist/cli/{index-vh87e91s.js → index-km9tjdgw.js}

@@ -2,14 +2,14 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-qdwccqv5.js";
+} from "./index-vd6s2mxq.js";
 import {
   init_schema
-} from "./index-3x07b03s.js";
+} from "./index-5mbpybdm.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants
-} from "./index-hqrkr9ag.js";
+} from "./index-xfzkq1k4.js";
 
 // src/config/index.ts
 init_constants();

package/dist/cli/{index-kxaxf3en.js → index-kwh4b9cm.js}

@@ -5,13 +5,17 @@ import {
 import {
   telemetry
 } from "./index-6dtt0brw.js";
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-zxdawwc7.js";
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-3x07b03s.js";
+} from "./index-5mbpybdm.js";
 import {
   init_constants
-} from "./index-hqrkr9ag.js";
+} from "./index-xfzkq1k4.js";
 import {
   getPathFlavor,
   init_path_identity,
@@ -1806,6 +1810,7 @@ function stableCanonicalStringify(value) {
 }
 
 // src/hooks/guardrails/file-authority.ts
+import { execFileSync } from "child_process";
 import * as fsSync from "fs";
 var import_picomatch = __toESM(require_picomatch2(), 1);
 import * as path2 from "path";
@@ -2148,12 +2153,166 @@ function protectedRoots(projectRoot, additional = []) {
 var HASH_INPUT_CAP_BYTES = 64 * 1024;
 
 // src/hooks/guardrails/file-authority.ts
+init_git_executable();
 var pathNormalizationCache = new QuickLRU({
   maxSize: 500
 });
 var globMatcherCache = new QuickLRU({
   maxSize: 200
 });
+var GIT_WORKTREE_CACHE_MAX_AGE_MS = 60000;
+var gitWorktreeCache = new QuickLRU({
+  maxSize: 50,
+  maxAge: GIT_WORKTREE_CACHE_MAX_AGE_MS
+});
+function gitEnvWithoutRepoRedirectors() {
+  const env = { ...process.env };
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_INDEX_FILE;
+  delete env.GIT_COMMON_DIR;
+  return env;
+}
+function parseWorktreeListPorcelain(output) {
+  const records = [];
+  for (const line of output.split(`
+`)) {
+    if (line.startsWith("worktree ")) {
+      const wtPath = line.slice("worktree ".length).trim();
+      if (wtPath) {
+        records.push({ path: wtPath, attributes: new Set });
+      }
+      continue;
+    }
+    const record = records[records.length - 1];
+    if (!record)
+      continue;
+    const separator = line.indexOf(" ");
+    const attribute = separator === -1 ? line : line.slice(0, separator);
+    if (attribute)
+      record.attributes.add(attribute);
+  }
+  return records;
+}
+function canonicalizeWindowsPathNative(p) {
+  if (process.platform !== "win32")
+    return p;
+  try {
+    const native = fsSync.realpathSync.native(p);
+    return native.startsWith(String.fromCharCode(92, 92, 63, 92)) ? native.slice(4) : native;
+  } catch {
+    return;
+  }
+}
+function canonicalizeWindowsPathTailTolerant(p) {
+  if (process.platform !== "win32")
+    return p;
+  const tail = [];
+  let probe = p;
+  for (;; ) {
+    const native = canonicalizeWindowsPathNative(probe);
+    if (native !== undefined) {
+      return tail.length === 0 ? native : path2.join(native, ...tail.reverse());
+    }
+    const parent = path2.dirname(probe);
+    if (parent === probe)
+      return p;
+    tail.push(path2.basename(probe));
+    probe = parent;
+  }
+}
+function isValidWorktreeRecord(repoRootRecord, record) {
+  if (record === repoRootRecord) {
+    try {
+      return fsSync.statSync(path2.join(record.path, ".git")).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  if (record.attributes.has("bare"))
+    return false;
+  const dotGitPath = path2.join(record.path, ".git");
+  let dotGitStat;
+  try {
+    dotGitStat = fsSync.lstatSync(dotGitPath);
+  } catch {
+    return false;
+  }
+  if (!dotGitStat.isFile())
+    return false;
+  let gitDirLine;
+  try {
+    gitDirLine = fsSync.readFileSync(dotGitPath, "utf8").trim();
+  } catch {
+    return false;
+  }
+  if (!gitDirLine.startsWith("gitdir:"))
+    return false;
+  const gitDirRef = gitDirLine.slice("gitdir:".length).trim();
+  if (!gitDirRef)
+    return false;
+  const gitDirPath = path2.isAbsolute(gitDirRef) ? gitDirRef : path2.resolve(record.path, gitDirRef);
+  let registrationGitdirFile;
+  try {
+    registrationGitdirFile = fsSync.realpathSync(path2.join(gitDirPath, "gitdir"));
+  } catch {
+    return false;
+  }
+  if (repoRootRecord) {
+    let worktreesRoot;
+    try {
+      worktreesRoot = path2.join(fsSync.realpathSync(path2.join(repoRootRecord.path, ".git")), "worktrees");
+    } catch {
+      return false;
+    }
+    if (!isPathIdentityWithin(registrationGitdirFile, worktreesRoot)) {
+      return false;
+    }
+  }
+  let backReference;
+  try {
+    backReference = fsSync.readFileSync(registrationGitdirFile, "utf8").trim();
+  } catch {
+    return false;
+  }
+  try {
+    return pathIdentitiesEqual(fsSync.realpathSync(dotGitPath), fsSync.realpathSync(backReference));
+  } catch {
+    return false;
+  }
+}
+function getLinkedGitWorktrees(dir) {
+  const cached = gitWorktreeCache.get(dir);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const worktrees = [];
+  try {
+    const output = execFileSync(resolveGitExecutable(), ["worktree", "list", "--porcelain"], {
+      cwd: dir,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1500,
+      maxBuffer: 4 * 1024 * 1024,
+      windowsHide: true,
+      env: gitEnvWithoutRepoRedirectors()
+    });
+    const records = parseWorktreeListPorcelain(output);
+    const repoRootRecord = records[0];
+    for (const record of records) {
+      if (!isValidWorktreeRecord(repoRootRecord, record)) {
+        continue;
+      }
+      const native = canonicalizeWindowsPathNative(record.path);
+      if (native === undefined) {
+        continue;
+      }
+      worktrees.push(native);
+    }
+  } catch {}
+  gitWorktreeCache.set(dir, worktrees);
+  return worktrees;
+}
 function normalizePathWithCache(filePath, cwd) {
   const cacheKey = `${cwd}:${filePath}`;
   const cached = pathNormalizationCache.get(cacheKey);
@@ -2468,21 +2627,89 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, o
     resolvedTarget = path2.resolve(dir, filePath);
     normalizedPath = path2.relative(dir, resolvedTarget).replace(/\\/g, "/");
   }
+  let effectiveDir = dir;
+  const nativeTarget2 = canonicalizeWindowsPathTailTolerant(resolvedTarget);
+  const matchWorktreeRoot = () => {
+    const worktrees = getLinkedGitWorktrees(dir);
+    let best;
+    for (const wt of worktrees) {
+      const relToWt = path2.relative(wt, nativeTarget2).replace(/\\/g, "/");
+      if (relToWt !== ".." && !relToWt.startsWith("../") && !isOnDifferentFilesystemRoot(nativeTarget2, wt)) {
+        if (!best || wt.length > best.wt.length) {
+          best = { wt, rel: relToWt };
+        }
+      }
+    }
+    if (best) {
+      effectiveDir = best.wt;
+      normalizedPath = best.rel;
+    }
+    return best?.wt;
+  };
+  const findPlantedLinkBelow = (root) => {
+    const ancestors = [];
+    let current = nativeTarget2;
+    while (true) {
+      const rel = path2.relative(root, current);
+      if (rel === "" || rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel))
+        break;
+      ancestors.push(current);
+      const parent = path2.dirname(current);
+      if (parent === current)
+        break;
+      current = parent;
+    }
+    for (const ancestor of ancestors) {
+      try {
+        if (fsSync.lstatSync(ancestor).isSymbolicLink())
+          return ancestor;
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+          continue;
+        return ancestor;
+      }
+    }
+    return null;
+  };
   if (isOnDifferentFilesystemRoot(resolvedTarget, dir)) {
-    return denyAuthority(agentName, normalizedPath, {
-      code: "AUTHORITY_ROOT_ESCAPE",
-      layer: "containment",
-      rule: "same-filesystem-root",
-      detail: "target is on a different drive or filesystem root"
-    });
-  }
-  if (normalizedPath === ".." || normalizedPath.startsWith("../")) {
-    return denyAuthority(agentName, normalizedPath, {
-      code: "AUTHORITY_ROOT_ESCAPE",
-      layer: "containment",
-      rule: "workspace-containment",
-      detail: "target resolves outside the working directory"
-    });
+    const matchedWorktree = matchWorktreeRoot();
+    if (!matchedWorktree) {
+      return denyAuthority(agentName, normalizedPath, {
+        code: "AUTHORITY_ROOT_ESCAPE",
+        layer: "containment",
+        rule: "same-filesystem-root",
+        detail: "target is on a different drive or filesystem root"
+      });
+    }
+    const plantedLink = findPlantedLinkBelow(matchedWorktree);
+    if (plantedLink) {
+      return denyAuthority(agentName, normalizedPath, {
+        code: "AUTHORITY_ROOT_ESCAPE",
+        layer: "containment",
+        rule: "workspace-containment",
+        detail: `re-rooted target crosses symlink/junction "${plantedLink}" inside the matched worktree`
+      });
+    }
+  } else if (normalizedPath === ".." || normalizedPath.startsWith("../")) {
+    const matchedWorktree = matchWorktreeRoot();
+    if (!matchedWorktree) {
+      return denyAuthority(agentName, normalizedPath, {
+        code: "AUTHORITY_ROOT_ESCAPE",
+        layer: "containment",
+        rule: "workspace-containment",
+        detail: "target resolves outside the working directory"
+      });
+    }
+    const plantedLink = findPlantedLinkBelow(matchedWorktree);
+    if (plantedLink) {
+      return denyAuthority(agentName, normalizedPath, {
+        code: "AUTHORITY_ROOT_ESCAPE",
+        layer: "containment",
+        rule: "workspace-containment",
+        detail: `re-rooted target crosses symlink/junction "${plantedLink}" inside the matched worktree`
+      });
+    }
   }
   const classifiedRules = effectiveRules[normalizedAgent] ?? effectiveRules[strippedAgent];
   const unclassifiedWhileDisabled = !classifiedRules && options.authorityEnabled === false && normalizedAgent !== "unknown";
@@ -2496,10 +2723,10 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, o
     });
   }
   const flavor = getPathFlavor();
-  const matchesPathPrefix = (candidate, prefix) => isPathIdentityWithin(path2.resolve(dir, candidate), path2.resolve(dir, prefix), flavor);
+  const matchesPathPrefix = (candidate, prefix) => isPathIdentityWithin(path2.resolve(effectiveDir, candidate), path2.resolve(effectiveDir, prefix), flavor);
   const matchesGlob = (glob) => getGlobMatcher(glob)(normalizedPath);
   for (const prefix of options.universalDenyPrefixes ?? []) {
-    if (matchesAuthorityDenyPrefix(normalizedPath, prefix, dir, flavor)) {
+    if (matchesAuthorityDenyPrefix(normalizedPath, prefix, effectiveDir, flavor)) {
       return denyAuthority(agentName, normalizedPath, {
         code: "AUTHORITY_UNIVERSAL_DENY",
         layer: "universal-deny",
@@ -2563,7 +2790,7 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, o
       detail: "agent role is read-only"
     });
   }
-  const pathIsInDeclaredScope = isCoderAgent && options.declaredScope != null && options.declaredScope.length > 0 && isPathWithinDeclaredScope(normalizedPath, options.declaredScope, dir);
+  const pathIsInDeclaredScope = isCoderAgent && options.declaredScope != null && options.declaredScope.length > 0 && isPathWithinDeclaredScope(normalizedPath, options.declaredScope, effectiveDir);
   if (pathIsInDeclaredScope) {
     return {
       allowed: true,

package/dist/cli/{index-tnrq0pg8.js → index-mb3y5cgy.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-6b295cas.js";
 import {
   readEffectiveSpecSync
-} from "./index-zd15v0gr.js";
+} from "./index-xapmt05a.js";
 import {
   _internals,
   clearWorktreeMergeStatus,
@@ -43,10 +43,10 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-26h8fb7t.js";
+} from "./index-djtqb6b7.js";
 import {
   appendCoreEventSync
-} from "./index-awt5dpam.js";
+} from "./index-h349p91m.js";
 import {
   deleteCoordinationStateWithinTransaction,
   getCoordinationStateRaw,
@@ -93,7 +93,7 @@ import {
   init_loader,
   isEpicModeConfigEnabled,
   loadPluginConfigWithMeta
-} from "./index-qdwccqv5.js";
+} from "./index-vd6s2mxq.js";
 import {
   exports_external,
   init_zod
@@ -2664,7 +2664,7 @@ ${markdown}`;
   }
 }
 async function defaultMaybeSaveAutoCheckpoint(directory, plan) {
-  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-1wf9n5yj.js");
+  const { maybeSaveAutoCheckpoint } = await import("./auto-checkpoint-0ajspw7n.js");
   return maybeSaveAutoCheckpoint(directory, plan);
 }
 async function updateTaskStatus(directory, taskId, status, options) {
@@ -2740,7 +2740,7 @@ async function updateTaskStatus(directory, taskId, status, options) {
       if (status === "completed") {
         try {
           const completedTask = updatedPlan.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId);
-          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-9b2zj8hd.js");
+          const { maybePropagateSpeckitCheckoff } = await import("./speckit-checkoff-d92ej93g.js");
           await maybePropagateSpeckitCheckoff(directory, {
             taskId,
             frRefs: completedTask?.fr_refs ?? [],

package/dist/cli/{index-71g0ps66.js → index-mbygjbj8.js}

@@ -2,7 +2,7 @@
 import {
   _internals,
   resolveWorktreeIsolationConfig
-} from "./index-vh87e91s.js";
+} from "./index-km9tjdgw.js";
 import {
   ApprovalEvidenceSchema,
   BaseEvidenceSchema,
@@ -46,7 +46,7 @@ import {
   loadPluginConfigWithMeta,
   loadPluginConfigWithMetaAsync,
   resetConfigAdvisoryDedup
-} from "./index-qdwccqv5.js";
+} from "./index-vd6s2mxq.js";
 import"./index-zxdawwc7.js";
 import {
   AUTO_REVIEW_V8_BURN_IN_DECISION,
@@ -72,7 +72,7 @@ import {
   TurboConfigSchema,
   WorktreeIsolationConfigSchema,
   resolveAutoReviewConfig
-} from "./index-3x07b03s.js";
+} from "./index-5mbpybdm.js";
 import {
   ALL_AGENT_NAMES,
   ALL_SUBAGENT_NAMES,
@@ -82,7 +82,7 @@ import {
   QA_AGENTS,
   isQAAgent,
   isSubagent
-} from "./index-hqrkr9ag.js";
+} from "./index-xfzkq1k4.js";
 import"./index-bk5tah7q.js";
 import"./index-gknz3bv1.js";
 import"./index-zpsr8rpc.js";