opencode-swarm 7.132.2 → 7.134.0

package/dist/cli/index-b8zgtz81.js

@@ -0,0 +1,123 @@
+// @bun
+// src/hooks/delegation-gate/worktree-merge-status.ts
+import * as fs from "fs";
+import * as path from "path";
+var failuresByTask = new Map;
+var durableStatusPath;
+var MAX_RECOVERY_STATUS_BYTES = 2 * 1024 * 1024;
+var MAX_RECOVERY_STATUS_ENTRIES = 512;
+var hasLoaded = false;
+function loadDurableStatus(statusPath) {
+  try {
+    hasLoaded = true;
+    if (!fs.existsSync(statusPath)) {
+      failuresByTask.clear();
+      return;
+    }
+    const data = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+    if (data && typeof data === "object") {
+      failuresByTask.clear();
+      for (const [taskId, failure] of Object.entries(data)) {
+        failuresByTask.set(taskId, failure);
+      }
+    }
+  } catch {
+    failuresByTask.clear();
+  }
+}
+function isRecoveryFailure(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const candidate = value;
+  if (candidate.outcome !== "partial" && candidate.outcome !== "failed" || typeof candidate.stage !== "string" || !candidate.stage || typeof candidate.message !== "string" || !candidate.message) {
+    return false;
+  }
+  for (const key of ["worktreePath", "branch"]) {
+    if (candidate[key] !== undefined && (typeof candidate[key] !== "string" || candidate[key].length === 0)) {
+      return false;
+    }
+  }
+  for (const key of ["queuedAt", "completedAt"]) {
+    if (candidate[key] !== undefined && (typeof candidate[key] !== "number" || !Number.isFinite(candidate[key]) || candidate[key] < 0)) {
+      return false;
+    }
+  }
+  return true;
+}
+function scanWorktreeMergeFailuresForRecovery(projectDir) {
+  const statusPath = path.join(projectDir, ".swarm", "worktree-merge-status.json");
+  try {
+    const stat = fs.statSync(statusPath);
+    if (stat.size > MAX_RECOVERY_STATUS_BYTES) {
+      return {
+        status: "uncertain",
+        reason: `worktree merge-status file exceeds the ${MAX_RECOVERY_STATUS_BYTES}-byte recovery bound`
+      };
+    }
+    const raw = fs.readFileSync(statusPath, "utf-8");
+    if (Buffer.byteLength(raw, "utf8") > MAX_RECOVERY_STATUS_BYTES) {
+      return {
+        status: "uncertain",
+        reason: `worktree merge-status file changed beyond the ${MAX_RECOVERY_STATUS_BYTES}-byte recovery bound`
+      };
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        status: "uncertain",
+        reason: "worktree merge-status file does not contain an object"
+      };
+    }
+    const entries = Object.entries(parsed);
+    if (entries.length > MAX_RECOVERY_STATUS_ENTRIES) {
+      return {
+        status: "uncertain",
+        reason: `worktree merge-status owner count exceeds the ${MAX_RECOVERY_STATUS_ENTRIES}-entry safety bound`
+      };
+    }
+    for (const [taskId, failure] of entries) {
+      if (!taskId || !isRecoveryFailure(failure)) {
+        return {
+          status: "uncertain",
+          reason: `worktree merge-status has an invalid owner record for task "${taskId}"`
+        };
+      }
+    }
+    return {
+      status: "ok",
+      failures: entries
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "ok", failures: [] };
+    }
+    return {
+      status: "uncertain",
+      reason: `worktree merge-status is unreadable or malformed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function initDurableStatusPath(projectDir) {
+  if (typeof projectDir !== "string" || projectDir.length === 0)
+    return;
+  const nextPath = path.join(projectDir, ".swarm", "worktree-merge-status.json");
+  if (durableStatusPath === nextPath && hasLoaded)
+    return;
+  durableStatusPath = nextPath;
+  hasLoaded = false;
+  loadDurableStatus(durableStatusPath);
+}
+function getWorktreeMergeFailure(taskId) {
+  if (!hasLoaded && durableStatusPath) {
+    loadDurableStatus(durableStatusPath);
+  }
+  return failuresByTask.get(taskId);
+}
+function getAllWorktreeMergeFailures() {
+  if (!hasLoaded && durableStatusPath) {
+    loadDurableStatus(durableStatusPath);
+  }
+  return failuresByTask.entries();
+}
+
+export { scanWorktreeMergeFailuresForRecovery, initDurableStatusPath, getWorktreeMergeFailure, getAllWorktreeMergeFailures };

package/dist/cli/{index-3s9rfnqq.js → index-baawkm48.js}

@@ -6,24 +6,24 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-q27bajqb.js";
+} from "./index-cfkvc5q9.js";
+import {
+  atomicWriteFile
+} from "./index-dd7ttx8x.js";
 import {
   init_knowledge_types,
   isActiveStatus
 } from "./index-bk5tah7q.js";
-import {
-  init_logger,
-  log
-} from "./index-zgwm4ryv.js";
-import {
-  atomicWriteFile
-} from "./index-7mkpsw6g.js";
 import {
   readCachedParsedFile
 } from "./index-fsrp8wp3.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
+import {
+  init_logger,
+  log
+} from "./index-zgwm4ryv.js";
 import {
   __require,
   __toESM
@@ -702,7 +702,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const recovered = touched.filter((e) => e.confidence > CONFIDENCE_FLOOR + FLOOR_EPSILON && e.confidence_floor_demoted);
   if (atFloor.length === 0 && recovered.length === 0)
     return;
-  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-gpqc62jr.js");
+  const { readKnowledgeCounterRollups, effectiveRetrievalOutcomes } = await import("./knowledge-events-jjc9qbe0.js");
   const rollups = await readKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -769,11 +769,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-007smap6.js");
-    const { KnowledgeConfigSchema } = await import("./schema-023gwne7.js");
+    const { quarantineEntry } = await import("./knowledge-validator-h1nrn2pk.js");
+    const { KnowledgeConfigSchema } = await import("./schema-bjb0yzsq.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-y5qp59rc.js");
+      const { loadPluginConfigWithMeta } = await import("./index-kapharv7.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-fgcmxjp7.js → index-c3e0ymrg.js}

@@ -2,7 +2,7 @@
 import {
   redactPath,
   redactShellCommand
-} from "./index-yvv1wt2h.js";
+} from "./index-hgh01f6h.js";
 
 // src/services/guardrail-log-service.ts
 import * as fs from "fs/promises";

package/dist/cli/{index-q27bajqb.js → index-cfkvc5q9.js}

@@ -1,11 +1,11 @@
 // @bun
+import {
+  atomicWriteFile
+} from "./index-dd7ttx8x.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
-import {
-  atomicWriteFile
-} from "./index-7mkpsw6g.js";
 
 // src/hooks/knowledge-link.ts
 import {

package/dist/cli/{index-7mkpsw6g.js → index-dd7ttx8x.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-fsrp8wp3.js";
 import {
   withEvidenceLock
-} from "./index-76kvm9z5.js";
+} from "./index-5nybajn9.js";
 import {
   bunWrite
 } from "./index-qe3v54nb.js";

package/dist/cli/{index-jgfcp9bh.js → index-dgxgvzab.js}

@@ -4,17 +4,17 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-q27bajqb.js";
-import {
-  init_logger,
-  warn
-} from "./index-zgwm4ryv.js";
+} from "./index-cfkvc5q9.js";
 import {
   atomicWriteFile
-} from "./index-7mkpsw6g.js";
+} from "./index-dd7ttx8x.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
 import {
   __require,
   __toESM
@@ -608,7 +608,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
       deltas.push({ id, delta });
     }
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-ggxr3ww5.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-9e0w1kxm.js");
       await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-8d3m0ge3.js → index-eedq2y40.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-k4tmx21m.js";
+} from "./index-rkyhv4p5.js";
 import {
   handleGuardrailLog
-} from "./index-fgcmxjp7.js";
+} from "./index-c3e0ymrg.js";
 import {
   COMMAND_REGISTRY,
   SWARM_COMMAND_TOOL_ALLOWLIST,
@@ -69,6 +69,7 @@ import {
   handleResetCommand,
   handleResetSessionCommand,
   handleRetrieveCommand,
+  handleReviewCommand,
   handleRollbackCommand,
   handleSddCommand,
   handleSddProjectCommand,
@@ -83,28 +84,30 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-f6480ee6.js";
-import"./index-yvv1wt2h.js";
-import"./index-630badhp.js";
-import"./index-03zyn94g.js";
+} from "./index-3dtjhr26.js";
+import"./index-13xxjfhn.js";
+import"./index-hgh01f6h.js";
+import"./index-g87ty4wp.js";
+import"./index-k742ecbm.js";
 import"./index-4905hd2m.js";
 import"./index-134d35c1.js";
-import"./index-9f71ye47.js";
-import"./index-9cf1yr67.js";
-import"./index-mwkwyej1.js";
-import"./index-djwemsjn.js";
+import"./index-j6ywarjp.js";
+import"./index-jpkxjmfw.js";
+import"./index-m2s0gbzt.js";
 import"./index-vxv732ex.js";
 import"./index-c8s9a3zh.js";
 import"./index-9ss2m4rs.js";
-import"./index-g4mnf3p5.js";
-import"./index-6ccynjv3.js";
-import"./index-rt5jgktq.js";
+import"./index-wk1h5ec2.js";
+import"./index-1j3682j8.js";
+import"./index-2njes601.js";
+import"./index-y0kk3rtv.js";
 import"./index-rtry5xyf.js";
-import"./index-3s9rfnqq.js";
-import"./index-jgfcp9bh.js";
+import"./index-baawkm48.js";
+import"./index-dgxgvzab.js";
 import"./index-ae75rja9.js";
-import"./index-q27bajqb.js";
-import"./index-jj4earrh.js";
+import"./index-cfkvc5q9.js";
+import"./index-dd7ttx8x.js";
+import"./index-xfejq1p9.js";
 import"./index-k5jrywpr.js";
 import"./index-n832052r.js";
 import {
@@ -113,29 +116,29 @@ import {
   init_constants,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-bvp2v7k1.js";
+} from "./index-b5ek2cge.js";
 import"./index-bk5tah7q.js";
 import"./index-8fwhhayc.js";
 import"./index-q1exe2b3.js";
-import"./index-4ff0x4cg.js";
-import"./index-2tn5h2zp.js";
+import"./index-p8hezdtz.js";
+import"./index-4p02dp92.js";
 import"./index-1kz6da87.js";
-import"./index-w9cb5zwh.js";
+import"./index-b4z7s917.js";
+import"./index-b8zgtz81.js";
+import"./index-2t1n9k7b.js";
 import"./index-4rhhvd1a.js";
-import"./index-y2pfmd0z.js";
-import"./index-s80bsjkj.js";
-import"./index-z6xqpmqg.js";
-import"./index-zjygnfay.js";
-import"./index-zgwm4ryv.js";
-import"./index-h3k62043.js";
-import"./index-3x761jqv.js";
-import"./index-7mkpsw6g.js";
+import"./index-y3v1404y.js";
+import"./index-2ghkk9ve.js";
 import"./index-fsrp8wp3.js";
-import"./index-76kvm9z5.js";
+import"./index-5nybajn9.js";
+import"./index-7g4c7s5r.js";
 import"./index-q2rrv0cy.js";
 import"./index-bpmtbmy9.js";
-import"./index-7g4c7s5r.js";
+import"./index-z6xqpmqg.js";
+import"./index-zjygnfay.js";
 import"./index-qe3v54nb.js";
+import"./index-zgwm4ryv.js";
+import"./index-h3k62043.js";
 import"./index-a76rekgs.js";
 
 // src/commands/index.ts
@@ -263,7 +266,10 @@ function createSwarmCommandHandler(directory, agents, options = {}) {
         activeAgentName: options.getActiveAgentName?.(input.sessionID),
         packageRoot: options.packageRoot,
         registeredAgents: options.registeredAgents,
-        evaluationModelDispatcher: options.evaluationModelDispatcher
+        evaluationModelDispatcher: options.evaluationModelDispatcher,
+        reviewModelDispatcher: options.reviewModelDispatcher,
+        autoReviewConfig: options.autoReviewConfig,
+        reviewAgentModelRegistry: options.reviewAgentModelRegistry
       })
     });
     return;
@@ -278,7 +284,10 @@ async function buildSwarmCommandPrompt(args) {
     activeAgentName,
     packageRoot,
     registeredAgents,
-    evaluationModelDispatcher
+    evaluationModelDispatcher,
+    reviewModelDispatcher,
+    autoReviewConfig,
+    reviewAgentModelRegistry
   } = args;
   const resolved = _internals.resolveCommand(tokens);
   if (!resolved) {
@@ -322,7 +331,11 @@ async function buildSwarmCommandPrompt(args) {
     sessionID,
     tokens,
     packageRoot,
-    evaluationModelDispatcher
+    evaluationModelDispatcher,
+    reviewModelDispatcher,
+    autoReviewConfig,
+    activeAgentName,
+    reviewAgentModelRegistry
   });
   return formatCanonicalPromptFallback({
     original: `/swarm ${tokens.join(" ")}`.trim(),
@@ -389,6 +402,7 @@ export {
   handleSddProjectCommand,
   handleSddCommand,
   handleRollbackCommand,
+  handleReviewCommand,
   handleRetrieveCommand,
   handleResetSessionCommand,
   handleResetCommand,

package/dist/cli/{index-630badhp.js → index-g87ty4wp.js}

@@ -8,7 +8,7 @@ import {
   init_constants,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-bvp2v7k1.js";
+} from "./index-b5ek2cge.js";
 import {
   log
 } from "./index-zgwm4ryv.js";
@@ -28,7 +28,9 @@ var DEPRECATED_FIELDS = new Map([
     {
       message: "deprecated",
       replacement: "agents.skill_improver.model",
-      isDefaultValue: (v) => v === null
+      isDefaultValue: (v) => v === null,
+      deprecatedIn: 2,
+      sinceVersion: 1
     }
   ],
   [
@@ -36,7 +38,9 @@ var DEPRECATED_FIELDS = new Map([
     {
       message: "deprecated",
       replacement: "agents.skill_improver.fallback_models",
-      isDefaultValue: (v) => Array.isArray(v) && v.length === 0
+      isDefaultValue: (v) => Array.isArray(v) && v.length === 0,
+      deprecatedIn: 2,
+      sinceVersion: 1
     }
   ],
   [
@@ -44,7 +48,9 @@ var DEPRECATED_FIELDS = new Map([
     {
       message: "deprecated",
       replacement: "agents.spec_writer.model",
-      isDefaultValue: (v) => v === null
+      isDefaultValue: (v) => v === null,
+      deprecatedIn: 2,
+      sinceVersion: 1
     }
   ],
   [
@@ -52,7 +58,9 @@ var DEPRECATED_FIELDS = new Map([
     {
       message: "deprecated",
       replacement: "agents.spec_writer.fallback_models",
-      isDefaultValue: (v) => Array.isArray(v) && v.length === 0
+      isDefaultValue: (v) => Array.isArray(v) && v.length === 0,
+      deprecatedIn: 2,
+      sinceVersion: 1
     }
   ]
 ]);
@@ -283,6 +291,36 @@ function collectRawValueConstraintFindings(directory) {
   }
   return findings;
 }
+function collectRawAutoReviewCompatibilityFindings(directory) {
+  const findings = [];
+  const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
+  for (const configPath of [userConfigPath, projectConfigPath]) {
+    if (!fs.existsSync(configPath))
+      continue;
+    try {
+      const stats = fs.statSync(configPath);
+      if (stats.size > CONFIG_DOCTOR_MAX_CONFIG_FILE_BYTES)
+        continue;
+      const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (!isPlainObject(raw) || !isPlainObject(raw.auto_review))
+        continue;
+      const autoReview = raw.auto_review;
+      if (autoReview.structured_findings === false && isPlainObject(autoReview.final_review) && autoReview.final_review.mode === "gate") {
+        findings.push({
+          id: "invalid-auto-review-gate-compatibility",
+          title: "Invalid auto-review gate configuration",
+          description: 'auto_review.final_review.mode="gate" requires auto_review.structured_findings=true so gate evidence is machine-verifiable.',
+          severity: "error",
+          path: "auto_review.structured_findings",
+          currentValue: false,
+          autoFixable: false
+        });
+        break;
+      }
+    } catch {}
+  }
+  return findings;
+}
 function emitWorktreeIsolationLayeringAdvisory(config, findings) {
   const parallelization = config.parallelization;
   const worktreePolicy = config.worktree?.policy ?? "auto";
@@ -497,6 +535,20 @@ function validateConfigKey(path2, value) {
       }
       break;
     }
+    case "config_format_version": {
+      if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+        findings.push({
+          id: "type-mismatch",
+          title: `Config field "${path2}" has wrong type`,
+          description: `Expected non-negative integer, got ${typeof value === "number" ? Number.isInteger(value) ? value : `${value} (non-integer)` : typeof value}`,
+          severity: "error",
+          path: path2,
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
     case "guardrails.enabled": {
       if (value === false) {
         findings.push({
@@ -1146,6 +1198,7 @@ function runConfigDoctor(config, directory) {
   findings.push(...collectRawGatesConfigFindings(directory));
   findings.push(...collectRawStrictSectionFindings(directory));
   findings.push(...collectRawValueConstraintFindings(directory));
+  findings.push(...collectRawAutoReviewCompatibilityFindings(directory));
   emitWorktreeIsolationLayeringAdvisory(config, findings);
   const summary = {
     info: findings.filter((f) => f.severity === "info").length,
@@ -1160,12 +1213,27 @@ function runConfigDoctor(config, directory) {
   } else if (fs.existsSync(userConfigPath)) {
     configSource = userConfigPath;
   }
+  const rawConfigVersion = config.config_format_version;
+  const configVersion = typeof rawConfigVersion === "number" && Number.isFinite(rawConfigVersion) && Number.isInteger(rawConfigVersion) && rawConfigVersion >= 0 ? rawConfigVersion : 1;
+  const availableMigrations = [];
+  for (const [depPath, depInfo] of DEPRECATED_FIELDS) {
+    if (configVersion < depInfo.deprecatedIn) {
+      availableMigrations.push({
+        field: depPath,
+        replacement: depInfo.replacement,
+        deprecatedIn: depInfo.deprecatedIn,
+        sinceVersion: depInfo.sinceVersion,
+        currentFormatVersion: configVersion
+      });
+    }
+  }
   return {
     findings,
     summary,
     hasAutoFixableIssues,
     timestamp: Date.now(),
-    configSource
+    configSource,
+    ...availableMigrations.length > 0 ? { availableMigrations } : {}
   };
 }
 var DANGEROUS_PATH_SEGMENTS = new Set([
@@ -1265,6 +1333,81 @@ function applySafeAutoFixes(directory, result, options = {}) {
         break;
     }
   }
+  if (applyLossy && result.availableMigrations && result.availableMigrations.length > 0) {
+    for (const migration of result.availableMigrations) {
+      if (!isPathSafe(migration.field) || !isPathSafe(migration.replacement)) {
+        continue;
+      }
+      const legacyParts = migration.field.split(".");
+      let legacyParent = config;
+      let legacyNavigated = true;
+      for (let i = 0;i < legacyParts.length - 1; i++) {
+        const part = legacyParts[i];
+        if (legacyParent === null || legacyParent === undefined || typeof legacyParent !== "object" || Array.isArray(legacyParent)) {
+          legacyNavigated = false;
+          break;
+        }
+        const obj = legacyParent;
+        if (obj[part] === undefined || obj[part] === null) {
+          legacyNavigated = false;
+          break;
+        }
+        legacyParent = obj[part];
+      }
+      if (!legacyNavigated) {
+        continue;
+      }
+      const legacyKey = legacyParts[legacyParts.length - 1];
+      const legacyHolder = legacyParent;
+      if (!(legacyKey in legacyHolder)) {
+        continue;
+      }
+      const legacyValue = legacyHolder[legacyKey];
+      const depInfo = DEPRECATED_FIELDS.get(migration.field);
+      if (!depInfo || depInfo.isDefaultValue(legacyValue)) {
+        continue;
+      }
+      const replParts = migration.replacement.split(".");
+      let replParent = config;
+      let replNavigated = true;
+      for (let i = 0;i < replParts.length - 1; i++) {
+        const part = replParts[i];
+        if (replParent === null || replParent === undefined || typeof replParent !== "object" || Array.isArray(replParent)) {
+          replNavigated = false;
+          break;
+        }
+        const obj = replParent;
+        if (obj[part] === undefined) {
+          obj[part] = {};
+        } else if (obj[part] === null || typeof obj[part] !== "object") {
+          replNavigated = false;
+          break;
+        }
+        replParent = obj[part];
+      }
+      if (!replNavigated) {
+        continue;
+      }
+      const replKey = replParts[replParts.length - 1];
+      replParent[replKey] = legacyValue;
+      delete legacyHolder[legacyKey];
+      appliedFixes.push({
+        type: "update",
+        path: migration.replacement,
+        value: legacyValue,
+        description: `Migrate deprecated field \`${migration.field}\` \u2192 \`${migration.replacement}\``,
+        risk: "low",
+        lossy: true
+      });
+      appliedFixes.push({
+        type: "remove",
+        path: migration.field,
+        description: `Remove deprecated field \`${migration.field}\` (migrated to \`${migration.replacement}\`)`,
+        risk: "low",
+        lossy: true
+      });
+    }
+  }
   if (appliedFixes.length > 0) {
     const configDir = path.dirname(configPath);
     if (!fs.existsSync(configDir)) {

package/dist/cli/{index-yvv1wt2h.js → index-hgh01f6h.js}

@@ -3,7 +3,7 @@ import {
   init_constants,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-bvp2v7k1.js";
+} from "./index-b5ek2cge.js";
 import {
   init_logger,
   warn
@@ -2212,6 +2212,28 @@ function isInDeclaredScope(filePath, scopeEntries, cwd) {
     return rel.length > 0 && !rel.startsWith("..") && !path.isAbsolute(rel);
   });
 }
+var MAX_ALLOWED_HINT_ENTRIES = 20;
+function formatAllowedHints(rules) {
+  const fmt = (items) => {
+    if (!items || items.length === 0)
+      return "(none)";
+    if (items.length <= MAX_ALLOWED_HINT_ENTRIES)
+      return items.join(", ");
+    const omitted = items.length - MAX_ALLOWED_HINT_ENTRIES;
+    return `${items.slice(0, MAX_ALLOWED_HINT_ENTRIES).join(", ")}, \u2026 (+${omitted} more)`;
+  };
+  const parts = [];
+  if (rules.allowedExact && rules.allowedExact.length > 0) {
+    parts.push(`Allowed exact paths: ${fmt(rules.allowedExact)}`);
+  }
+  parts.push(`Allowed prefixes: ${fmt(rules.allowedPrefix)}`);
+  parts.push(`Allowed globs: ${fmt(rules.allowedGlobs)}`);
+  if (rules.allowedCaseSensitiveGlobs && rules.allowedCaseSensitiveGlobs.length > 0) {
+    parts.push(`Allowed case-sensitive globs: ${fmt(rules.allowedCaseSensitiveGlobs)}`);
+  }
+  parts.push("Block rules (blocked zones/prefixes/globs/exact) and universal deny paths still apply.");
+  return parts.join(" ");
+}
 function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, options) {
   const normalizedAgent = agentName.toLowerCase();
   const strippedAgent = stripKnownSwarmPrefix(agentName).toLowerCase();
@@ -2321,13 +2343,13 @@ function checkFileAuthorityWithRules(agentName, filePath, cwd, effectiveRules, o
       if (!isAllowed) {
         return {
           allowed: false,
-          reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}`
+          reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}. ${formatAllowedHints(rules)}`
         };
       }
     } else if (rules.allowedPrefix != null && rules.allowedPrefix.length === 0) {
       return {
         allowed: false,
-        reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}`
+        reason: `Path ${normalizedPath} not in allowed list for ${normalizedAgent}. ${formatAllowedHints(rules)}`
       };
     }
   }