opencode-swarm 7.145.1 → 7.145.2

package/dist/cli/{index-bst6epnr.js → index-cb2qtetk.js}

@@ -6,16 +6,16 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-34tawmyx.js";
+} from "./index-0a0asz2s.js";
 import {
   stableCanonicalStringify
-} from "./index-ymyke19q.js";
+} from "./index-1g87esfp.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-tw8ck794.js";
+} from "./index-612rr70a.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -60,7 +60,7 @@ import {
   updateTaskStatus,
   validateProjectRoot,
   validateSymlinkBoundary
-} from "./index-kxzgnz2h.js";
+} from "./index-917z76qr.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -77,7 +77,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-fwnhh6s7.js";
+} from "./index-nsr5b69r.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -103,12 +103,12 @@ import {
 } from "./index-y8552snf.js";
 import {
   readRecentEscalations
-} from "./index-sfemjcb8.js";
+} from "./index-ncfjxz9n.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-evpgszmp.js";
+} from "./index-np4ytvvv.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -157,7 +157,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-gey2257h.js";
+} from "./index-5e5a1y2r.js";
 import {
   BUNDLED_PROJECT_SKILL_ROOT,
   DEFAULT_SKILL_MIN_CONFIDENCE,
@@ -178,7 +178,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-mrkgxfeh.js";
+} from "./index-jgb7mq2y.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -189,11 +189,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-8ef23wex.js";
+} from "./index-jpppcckq.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-2qrd8mfa.js";
+} from "./index-4p3qfb05.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -212,7 +212,7 @@ import {
   findByBatchId,
   readDelegations,
   sweepStaleDelegations
-} from "./index-rtkttser.js";
+} from "./index-97psh79d.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
@@ -242,18 +242,18 @@ import {
   startupOrphanRecovery,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-41t3hgaa.js";
+} from "./index-n55a28zr.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-zpp507z0.js";
+} from "./index-rk80jhef.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-90w06fqr.js";
+} from "./index-vav705md.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -262,11 +262,12 @@ import {
   derivePlanIdentityHash,
   getOrAdoptPlanEpochUnderLock,
   initLedger,
+  ledgerExists,
   readLedgerEvents,
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-cqfp05jb.js";
+} from "./index-673axbjx.js";
 import {
   isPathWithinDeclaredScope,
   sanitizeDiagnosticText
@@ -317,7 +318,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-qpke2x5h.js";
+} from "./index-6wf75rcm.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -331,10 +332,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-ff66fbjt.js";
+} from "./index-cxn95n7q.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-neh8azwc.js";
+} from "./index-czde45km.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -344,7 +345,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-17e73wac.js";
+} from "./index-2vefr1f8.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -358,7 +359,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-7axx11dt.js";
+} from "./index-gpnv14kq.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -372,7 +373,7 @@ import {
   init_agent_names,
   init_constants,
   init_tool_metadata
-} from "./index-v3y3qg48.js";
+} from "./index-cpg98bh1.js";
 import {
   init_git_executable,
   resolveGitExecutable,
@@ -409,10 +410,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-dzan8czb.js";
+} from "./index-x8pm918t.js";
 import {
   atomicWriteFile
-} from "./index-mpf01swm.js";
+} from "./index-j20fzn0w.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -424,7 +425,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-4evasm2b.js";
+} from "./index-kggqpefz.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -432,12 +433,12 @@ import {
   listActiveLocks,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-gf03198s.js";
+} from "./index-bghwrr59.js";
 import {
   emit,
   getLastHeartbeat,
   telemetry
-} from "./index-dppzthm9.js";
+} from "./index-qyvjp0bq.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -464,7 +465,7 @@ import {
 
 // src/hooks/delegation-gate/worktree-isolation.ts
 init_constants();
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import * as fs53 from "fs/promises";
 import * as path113 from "path";
 init_executor();
@@ -4192,7 +4193,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-j4qb7mgb.js");
+  } = await import("./worktree-isolation-ajzyp2gm.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -4294,7 +4295,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-j4qb7mgb.js");
+        } = await import("./worktree-isolation-ajzyp2gm.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -15557,7 +15558,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-b7ntt9cw.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9gt8g2qj.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -16641,7 +16642,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-ctskfct2.js");
+        const skillModule = await import("./skill-generator-gsa6qwwt.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -17101,7 +17102,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-s6acdpwj.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-22apj3dj.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -17920,7 +17921,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-hdzhqwzj.js");
+      const { getScanStatus } = await import("./scan-cursor-6ksgv514.js");
       const scanStatus = await getScanStatus(directory);
       if (scanStatus.remaining_estimate > 0) {
         warnings.push(`Fair scan: reviewed ${knowledgeSummary.length} entries this sweep (generation ${scanStatus.generation}); ${scanStatus.remaining_estimate} more eligible entries will be visited in future curation sweeps.`);
@@ -18092,9 +18093,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-pg85z06v.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-mpcm7nje.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-b7ntt9cw.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9gt8g2qj.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -18102,11 +18103,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-59hzdxrv.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-gk2kmrk1.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-nnnx5692.js");
+    const { checkHivePromotions } = await import("./hive-promoter-ay8a7sct.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -18115,7 +18116,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-ctskfct2.js");
+    } = await import("./skill-generator-gsa6qwwt.js");
     const result = {
       approved: [],
       rejected: [],
@@ -19451,9 +19452,9 @@ function hashContent(content) {
   return createHash7("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-pg85z06v.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-mpcm7nje.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-b7ntt9cw.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9gt8g2qj.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -28527,12 +28528,20 @@ async function executeWriteRetro(args, directory) {
     }
   }
   const taskId = args.task_id ?? `retro-${phase}`;
+  if (args.verdict !== "pass" && args.verdict !== "fail") {
+    return JSON.stringify({
+      success: false,
+      phase,
+      reason: "RETRO_VERDICT_REQUIRED",
+      message: 'Invalid verdict: write_retro requires an explicit verdict of "pass" or "fail".'
+    }, null, 2);
+  }
   const retroEntry = {
     task_id: taskId,
     type: "retrospective",
     timestamp: new Date().toISOString(),
     agent: "architect",
-    verdict: "pass",
+    verdict: args.verdict,
     summary,
     metadata: args.metadata,
     phase_number: phase,
@@ -28621,6 +28630,7 @@ var write_retro = createSwarmTool({
   description: "Write a retrospective evidence bundle for a completed phase. " + "Accepts flat retro fields and writes a correctly-wrapped EvidenceBundle to " + ".swarm/evidence/retro-{phase}/evidence.json. " + "Use this instead of manually writing retro JSON to avoid schema validation failures in phase_complete.",
   args: {
     phase: exports_external.number().int().min(1).max(99).describe("The phase number being completed (e.g., 1, 2, 3)"),
+    verdict: exports_external.enum(["pass", "fail"]).describe("Explicit retrospective verdict for the phase"),
     summary: exports_external.string().describe("Human-readable summary of the phase"),
     task_count: exports_external.number().int().min(1).max(9999).describe("Count of tasks completed in this phase"),
     task_complexity: exports_external.enum(["trivial", "simple", "moderate", "complex"]).describe("Complexity level of the completed tasks"),
@@ -28642,6 +28652,7 @@ var write_retro = createSwarmTool({
     try {
       const writeRetroArgs = {
         phase: Number(args.phase),
+        verdict: args.verdict,
         summary: String(args.summary ?? ""),
         task_count: Number(args.task_count),
         task_complexity: args.task_complexity,
@@ -29374,6 +29385,7 @@ async function runFinalizeStage(ctx) {
       try {
         retroResult = await executeWriteRetro({
           phase: phase.id,
+          verdict: ctx.isForced ? "fail" : "pass",
           summary: ctx.isForced ? `Phase force-closed via /swarm close --force` : `Phase closed via /swarm close`,
           task_count: Math.max(1, (phase.tasks ?? []).length),
           task_complexity: "simple",
@@ -29421,6 +29433,7 @@ async function runFinalizeStage(ctx) {
     try {
       const sessionRetroResult = await executeWriteRetro({
         phase: 1,
+        verdict: ctx.isForced ? "fail" : "pass",
         task_id: "retro-session",
         summary: ctx.isForced ? "Plan-free session force-closed via /swarm close --force" : "Plan-free session closed via /swarm close",
         task_count: 1,
@@ -29673,7 +29686,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-pg85z06v.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-mpcm7nje.js");
     const { config: pmLoadedConfig } = _internals38.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -30531,7 +30544,7 @@ var _internals38 = {
   closePlanTerminalState: reconcileCloseTerminalStateForPlan,
   endAgentSession,
   flushAndDrainTelemetry: async () => {
-    const { flushAndDrainTelemetry } = await import("./telemetry-c21dgffc.js");
+    const { flushAndDrainTelemetry } = await import("./telemetry-t109dhv7.js");
     return flushAndDrainTelemetry();
   }
 };
@@ -31937,9 +31950,9 @@ var _internals43 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-pg85z06v.js"),
-      import("./curator-59hzdxrv.js"),
-      import("./curator-llm-factory-g794pv51.js")
+      import("./schema-mpcm7nje.js"),
+      import("./curator-gk2kmrk1.js"),
+      import("./curator-llm-factory-sat3mn5n.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -32893,7 +32906,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-hdzhqwzj.js");
+    const { getScanStatus } = await import("./scan-cursor-6ksgv514.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -32901,19 +32914,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-zvtmj756.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-82ew2yc4.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-pg85z06v.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-mpcm7nje.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-b7ntt9cw.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9gt8g2qj.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
         config = KnowledgeConfigSchema2.parse({});
       }
       const { cohortConfigFingerprint: cohortConfigFingerprint2 } = await import("./config-fingerprint-v22xh5a2.js");
-      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-smyc2mrm.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-xv0j8zyt.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -34189,7 +34202,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-96jmxr7s.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-j1r33f4q.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -34227,7 +34240,7 @@ async function handleDoctorCommand(directory, args) {
 `;
   }
   try {
-    const { runModelPreflight } = await import("./model-preflight-77dwxfv5.js");
+    const { runModelPreflight } = await import("./model-preflight-7ea00h34.js");
     const preflight = await runModelPreflight(config, swarmState.opencodeClient);
     if (preflight.catalogAvailable) {
       const unresolved = preflight.resolutions.filter((resolution) => resolution.status === "unresolved");
@@ -35129,7 +35142,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-41m0cna6.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-0mhx0t0v.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -56537,6 +56550,9 @@ var DEFAULT_MAX_UNTRACKED_FILE_BYTES = 64 * 1024;
 var MAX_REVIEW_BYTES = 8 * 1024 * 1024;
 var MAX_UNTRACKED_FILE_BYTES = 1024 * 1024;
 var MAX_TIMEOUT_MS2 = 60000;
+var WORKTREE_IDENTITY_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var WORKTREE_IDENTITY_TOTAL_BYTES = 8 * 1024 * 1024;
+var WORKTREE_IDENTITY_MAX_DURATION_MS = 2000;
 var METADATA_OUTPUT_LIMIT = 256 * 1024;
 var STDERR_OUTPUT_LIMIT = 64 * 1024;
 var MAX_REF_LENGTH = 200;
@@ -56919,6 +56935,204 @@ function selectorKey(selector) {
       return "working-tree";
   }
 }
+function reviewTargetKind(selector) {
+  switch (selector.kind) {
+    case "range":
+      return "exact-committed-range";
+    case "working-tree":
+      return "checkout-index-working-tree";
+    default:
+      return "checkout-history-index-working-tree";
+  }
+}
+function compareUtf8Bytes(left, right) {
+  return Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+}
+function uniqueSkipCodes(skipReasons) {
+  return [...new Set(skipReasons.map((item) => item.code))].sort();
+}
+function hashManifestPayload(payload) {
+  return createHash17("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+}
+function parseObjectFormat(stdout) {
+  const objectFormat = stdout.trim();
+  return objectFormat.length > 0 && !hasControlCharacter(objectFormat) ? objectFormat : null;
+}
+function parseLsTreeBlobId(stdout, expectedPath) {
+  const trimmed = stdout.endsWith("\x00") ? stdout.slice(0, -1) : stdout;
+  if (!trimmed)
+    return null;
+  const tabIndex = trimmed.indexOf("\t");
+  if (tabIndex === -1)
+    return null;
+  const metadata = trimmed.slice(0, tabIndex).trim().split(/\s+/);
+  const actualPath = normalizeRelativePath(trimmed.slice(tabIndex + 1));
+  if (metadata.length < 3 || metadata[1] !== "blob" || actualPath !== expectedPath || !SHA_PATTERN.test(metadata[2] ?? "")) {
+    return null;
+  }
+  return metadata[2];
+}
+async function resolveGitObjectFormat(root, timeoutMs) {
+  const result = await runGit2(root, ["rev-parse", "--show-object-format"], {
+    timeoutMs,
+    maxStdoutBytes: METADATA_OUTPUT_LIMIT
+  });
+  return result.ok ? parseObjectFormat(result.stdout) : null;
+}
+async function readGitBlobIdentity(root, treeish, relativePath2, timeoutMs, objectFormat) {
+  const result = await runGit2(root, ["ls-tree", "-z", treeish, "--", relativePath2], {
+    timeoutMs,
+    maxStdoutBytes: METADATA_OUTPUT_LIMIT
+  });
+  if (!result.ok)
+    return null;
+  const blobId = parseLsTreeBlobId(result.stdout, relativePath2);
+  if (!blobId)
+    return null;
+  return {
+    algorithm: "git-blob",
+    git_blob_oid: blobId,
+    git_object_format: objectFormat
+  };
+}
+function compareStats(left, right) {
+  return sameFileIdentity(left, right) && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+function hashWorkingTreeIdentity(root, rawPath, budget) {
+  const normalized = normalizeRelativePath(rawPath);
+  if (!normalized)
+    return { identity: null };
+  const candidate = path89.resolve(root, ...normalized.split("/"));
+  if (!isContained(root, candidate))
+    return { identity: null };
+  let handle;
+  const deadlineExceeded = (detail) => ({
+    identity: null,
+    failure: {
+      code: "UNREADABLE_FILE",
+      path: normalized,
+      detail
+    }
+  });
+  try {
+    if (_internals78.now() > budget.deadlineMs) {
+      return deadlineExceeded("working-tree content identity deadline expired before file hashing started");
+    }
+    const pathStat = _internals78.lstatBigIntSync(candidate);
+    if (!pathStat.isFile() || pathStat.isSymbolicLink())
+      return { identity: null };
+    const canonicalBeforeOpen = _internals78.realpathSync(candidate);
+    if (!isContained(root, canonicalBeforeOpen))
+      return { identity: null };
+    handle = _internals78.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals78.fstatBigIntSync(handle);
+    const canonicalAfterOpen = _internals78.realpathSync(candidate);
+    if (!openedBeforeRead.isFile() || !compareStats(pathStat, openedBeforeRead) || !samePath(canonicalBeforeOpen, canonicalAfterOpen) || !isContained(root, canonicalAfterOpen)) {
+      return { identity: null };
+    }
+    if (openedBeforeRead.size > BigInt(Number.MAX_SAFE_INTEGER)) {
+      return deadlineExceeded("working-tree content identity byte length exceeds safe integer bounds");
+    }
+    if (openedBeforeRead.size > BigInt(WORKTREE_IDENTITY_MAX_FILE_BYTES)) {
+      return deadlineExceeded(`working-tree content identity exceeded the ${WORKTREE_IDENTITY_MAX_FILE_BYTES}-byte per-file cap`);
+    }
+    const fileBytes = Number(openedBeforeRead.size);
+    if (fileBytes > budget.remainingBytes) {
+      return deadlineExceeded(`working-tree content identity exceeded the ${WORKTREE_IDENTITY_TOTAL_BYTES}-byte aggregate cap`);
+    }
+    const hash2 = createHash17("sha256");
+    const buffer = Buffer.alloc(64 * 1024);
+    let offset = 0;
+    while (offset < fileBytes) {
+      if (_internals78.now() > budget.deadlineMs) {
+        return deadlineExceeded("working-tree content identity deadline expired while hashing file content");
+      }
+      const read = _internals78.readSync(handle, buffer, 0, Math.min(buffer.byteLength, fileBytes - offset), offset);
+      if (read === 0)
+        break;
+      hash2.update(buffer.subarray(0, read));
+      offset += read;
+    }
+    const openedAfterRead = _internals78.fstatBigIntSync(handle);
+    const canonicalAfterRead = _internals78.realpathSync(candidate);
+    if (!compareStats(openedBeforeRead, openedAfterRead) || !samePath(canonicalBeforeOpen, canonicalAfterRead) || !isContained(root, canonicalAfterRead) || offset !== fileBytes) {
+      return { identity: null };
+    }
+    budget.remainingBytes -= fileBytes;
+    return {
+      identity: {
+        algorithm: "sha256",
+        sha256: hash2.digest("hex"),
+        byte_length: Number(openedAfterRead.size)
+      }
+    };
+  } catch {
+    return { identity: null };
+  } finally {
+    if (handle !== undefined) {
+      try {
+        _internals78.closeSync(handle);
+      } catch {}
+    }
+  }
+}
+async function buildReviewManifest(root, selector, files, completeness, timeoutMs, revisionContext, contentHash) {
+  const objectFormat = await resolveGitObjectFormat(root, timeoutMs) ?? "sha1";
+  const pathRecords = [];
+  const identityFailures = [];
+  const missingIdentityBindings = new Set;
+  const workingTreeBudget = selector.kind === "range" ? undefined : {
+    remainingBytes: WORKTREE_IDENTITY_TOTAL_BYTES,
+    deadlineMs: _internals78.now() + Math.min(timeoutMs, WORKTREE_IDENTITY_MAX_DURATION_MS)
+  };
+  const orderedScopes = [...files.values()].sort((left, right) => compareUtf8Bytes(left.newPath ?? left.oldPath ?? "", right.newPath ?? right.oldPath ?? ""));
+  const oldTreeForSelector = selector.kind === "working-tree" ? revisionContext.headSha : selector.kind === "range" ? selector.operator === "..." ? revisionContext.mergeBase : revisionContext.baseSha : revisionContext.mergeBase;
+  const newTreeForSelector = selector.kind === "range" ? revisionContext.rangeToSha : undefined;
+  for (const scope of orderedScopes) {
+    const record = {
+      kind: scope.kind,
+      old_path: scope.oldPath,
+      new_path: scope.newPath
+    };
+    if (scope.kind !== "added" && scope.oldPath && oldTreeForSelector) {
+      record.old_identity = await readGitBlobIdentity(root, oldTreeForSelector, scope.oldPath, timeoutMs, objectFormat) ?? undefined;
+    }
+    if (scope.newPath) {
+      if (selector.kind === "range" && newTreeForSelector) {
+        record.new_identity = await readGitBlobIdentity(root, newTreeForSelector, scope.newPath, timeoutMs, objectFormat) ?? undefined;
+      } else if (workingTreeBudget) {
+        const hashed = hashWorkingTreeIdentity(root, scope.newPath, workingTreeBudget);
+        record.new_identity = hashed.identity ?? undefined;
+        if (hashed.failure) {
+          identityFailures.push(hashed.failure);
+          missingIdentityBindings.add(`new:${scope.newPath}`);
+        }
+      }
+    }
+    pathRecords.push(record);
+  }
+  const payload = {
+    schema_version: 2,
+    content_hash: contentHash,
+    selector,
+    selector_key: selectorKey(selector),
+    review_target_kind: reviewTargetKind(selector),
+    completeness: {
+      complete: completeness.complete,
+      truncated: completeness.truncated,
+      skip_reason_codes: uniqueSkipCodes(completeness.skipReasons)
+    },
+    path_records: pathRecords
+  };
+  return {
+    manifest: {
+      ...payload,
+      hash: hashManifestPayload(payload)
+    },
+    identityFailures,
+    missingIdentityBindings
+  };
+}
 function boundedPositiveInteger(value, fallback, maximum) {
   if (value === undefined || !Number.isFinite(value))
     return fallback;
@@ -57407,6 +57621,11 @@ async function collectReviewDiff(options) {
     fileListFallback: fileListFallback ?? null
   });
   const scopeHash = createHash17("sha256").update(hashPayload, "utf8").digest("hex");
+  const reviewContentHash = createHash17("sha256").update(JSON.stringify({
+    selector,
+    canonicalText,
+    fileListFallback: fileListFallback ?? null
+  }), "utf8").digest("hex");
   const completeness = {
     complete: skipReasons.length === 0 && !truncated,
     truncated,
@@ -57420,6 +57639,39 @@ async function collectReviewDiff(options) {
     includesWorkingTree,
     scopeHash
   };
+  const { manifest, identityFailures, missingIdentityBindings } = await buildReviewManifest(root, selector, parsed.files, completeness, timeoutMs, {
+    headSha,
+    mergeBase,
+    baseSha,
+    rangeToSha
+  }, reviewContentHash);
+  skipReasons.push(...identityFailures);
+  for (const record of manifest.path_records) {
+    if (record.kind !== "added" && record.old_path && !record.old_identity) {
+      skipReasons.push({
+        code: "UNREADABLE_FILE",
+        path: record.old_path,
+        detail: "could not bind the reviewed old-side file to a complete content identity"
+      });
+    }
+    if (record.kind !== "deleted" && record.new_path && !record.new_identity && !missingIdentityBindings.has(`new:${record.new_path}`)) {
+      skipReasons.push({
+        code: "UNREADABLE_FILE",
+        path: record.new_path,
+        detail: "could not bind the reviewed new-side file to a complete content identity"
+      });
+    }
+  }
+  if (skipReasons.length > manifest.completeness.skip_reason_codes.length) {
+    completeness.complete = false;
+    manifest.completeness = {
+      complete: false,
+      truncated: completeness.truncated,
+      skip_reason_codes: uniqueSkipCodes(skipReasons)
+    };
+    const { hash: _oldHash, ...manifestPayload } = manifest;
+    manifest.hash = hashManifestPayload(manifestPayload);
+  }
   const scope = {
     selector,
     canonicalText,
@@ -57434,7 +57686,8 @@ async function collectReviewDiff(options) {
     deletedLines: parsed.deletedLines,
     files: parsed.files,
     completeness,
-    staleness
+    staleness,
+    manifest
   };
   const clean = canonicalText.trim().length === 0 && untrackedCount === 0 && skipReasons.length === 0;
   return { status: clean ? "clean" : "ok", ...scope };
@@ -57447,7 +57700,8 @@ var _internals78 = {
   fstatBigIntSync: (fd) => fs40.fstatSync(fd, { bigint: true }),
   readSync: fs40.readSync,
   closeSync: fs40.closeSync,
-  resolveGitExecutable: resolveGitExecutableAsync
+  resolveGitExecutable: resolveGitExecutableAsync,
+  now: () => Date.now()
 };
 
 // src/review/engine.ts
@@ -58993,8 +59247,22 @@ var _internals82 = {
 };
 
 // src/review/evidence.ts
+import { createHash as createHash21 } from "crypto";
 import * as fs44 from "fs";
 import * as path93 from "path";
+function computeAutoReviewManifestHash(manifest) {
+  return createHash21("sha256").update(JSON.stringify({
+    schema_version: manifest.schema_version,
+    content_hash: manifest.content_hash,
+    plan_requirements_hash: manifest.plan_requirements_hash,
+    review_policy_digest: manifest.review_policy_digest,
+    selector: manifest.selector,
+    selector_key: manifest.selector_key,
+    review_target_kind: manifest.review_target_kind,
+    completeness: manifest.completeness,
+    path_records: manifest.path_records
+  }), "utf8").digest("hex");
+}
 function autoReviewEvidenceRelativePath(trigger, scopeHash, phase) {
   if ((trigger === "phase_completion" || trigger === "plan_completion") && Number.isInteger(phase) && (phase ?? 0) > 0) {
     return path93.join("evidence", String(phase), "auto-review.json");
@@ -59046,7 +59314,7 @@ function isAutoReviewEvidence(value) {
   if (!value || typeof value !== "object")
     return false;
   const candidate = value;
-  if (!(candidate.schema_version === 1 && typeof candidate.timestamp === "string" && [
+  if (!((candidate.schema_version === 1 || candidate.schema_version === 2) && typeof candidate.timestamp === "string" && [
     "task_completion",
     "phase_completion",
     "plan_completion",
@@ -59054,8 +59322,91 @@ function isAutoReviewEvidence(value) {
   ].includes(String(candidate.trigger)) && typeof candidate.session_id === "string" && Boolean(candidate.scope) && typeof candidate.scope?.hash === "string" && typeof candidate.scope?.head_sha === "string" && Boolean(candidate.scope?.selector) && Boolean(candidate.scope?.completeness) && Boolean(candidate.policy) && (candidate.policy?.mode === "advisory" || candidate.policy?.mode === "gate") && typeof candidate.policy?.min_confidence === "number" && typeof candidate.policy?.structured_findings === "boolean" && typeof candidate.policy?.validate_findings === "boolean" && Array.isArray(candidate.findings) && Array.isArray(candidate.blocking_finding_ids) && typeof candidate.validation_complete === "boolean" && Boolean(candidate.review) && ["completed", "clean", "error"].includes(String(candidate.review?.status)))) {
     return false;
   }
+  if (candidate.schema_version === 2) {
+    if (!candidate.scope?.manifest || candidate.scope.manifest.schema_version !== 2 || typeof candidate.scope.manifest.content_hash !== "string" || typeof candidate.scope.manifest.plan_requirements_hash !== "string" || typeof candidate.scope.manifest.review_policy_digest !== "string" || typeof candidate.scope.manifest.hash !== "string" || typeof candidate.policy?.digest !== "string") {
+      return false;
+    }
+    const { hash: hash2, ...manifestPayload } = candidate.scope.manifest;
+    if (hash2 !== computeAutoReviewManifestHash(manifestPayload)) {
+      return false;
+    }
+  }
   return candidate.findings.every(isAutoReviewEvidenceFinding);
 }
+async function computePlanRequirementsHash(directory) {
+  const plan = await loadReviewRequirementsPlan(directory);
+  return plan ? computeReviewPlanRequirementsHash(plan) : "plan:none";
+}
+function computeAutoReviewPolicyDigest(config) {
+  return createHash21("sha256").update(JSON.stringify({
+    mode: config.final_review.mode,
+    min_confidence: config.min_confidence,
+    structured_findings: config.structured_findings,
+    validate_findings: config.validate_findings,
+    final_review: {
+      on_phase_complete: config.final_review.on_phase_complete,
+      on_plan_complete: config.final_review.on_plan_complete,
+      max_diff_bytes: config.final_review.max_diff_bytes,
+      timeout_ms: config.final_review.timeout_ms,
+      model: config.final_review.model
+    },
+    validation_timeout_ms: config.validation_timeout_ms,
+    validation_model: config.validation_model
+  }), "utf8").digest("hex");
+}
+async function materializeAutoReviewManifest(directory, manifest, config) {
+  const planRequirementsHash = await computePlanRequirementsHash(directory);
+  const policyDigest = computeAutoReviewPolicyDigest(config);
+  const payload = {
+    ...manifest,
+    plan_requirements_hash: planRequirementsHash,
+    review_policy_digest: policyDigest
+  };
+  const hash2 = computeAutoReviewManifestHash(payload);
+  return { ...payload, hash: hash2 };
+}
+async function loadReviewRequirementsPlan(directory) {
+  if (!await ledgerExists(directory)) {
+    return loadPlanJsonOnly(directory);
+  }
+  let replayed;
+  try {
+    replayed = await replayFromLedgerWithStatus(directory);
+  } catch (error2) {
+    throw new Error(`authoritative plan ledger replay failed for final-review requirements: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+  if (replayed.truncated) {
+    throw new Error("authoritative plan ledger replay is truncated; final-review requirements are unavailable");
+  }
+  if (!replayed.plan) {
+    throw new Error("authoritative plan ledger replay returned no plan; final-review requirements are unavailable");
+  }
+  return replayed.plan;
+}
+function computeReviewPlanRequirementsHash(plan) {
+  return createHash21("sha256").update(JSON.stringify({
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    migration_status: plan.migration_status,
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      type: phase.type,
+      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        fr_refs: task.fr_refs ? [...task.fr_refs].sort() : undefined
+      }))
+    }))
+  }), "utf8").digest("hex");
+}
 function baseFinding(finding) {
   return {
     title: finding.title,
@@ -59176,13 +59527,9 @@ function scopeFreshnessMismatches(reviewed, current) {
   };
   compare("status", reviewed.status, current.status);
   compare("scopeHash", reviewed.scopeHash, current.scopeHash);
+  compare("manifestHash", reviewed.manifest.hash, current.manifest.hash);
   compare("canonicalText", reviewed.canonicalText, current.canonicalText);
   compare("reviewTextBytes", reviewed.reviewTextBytes, current.reviewTextBytes);
-  compare("headSha", reviewed.headSha, current.headSha);
-  compare("baseRef", reviewed.baseRef, current.baseRef);
-  compare("baseSha", reviewed.baseSha, current.baseSha);
-  compare("mergeBase", reviewed.mergeBase, current.mergeBase);
-  compare("rangeToSha", reviewed.rangeToSha, current.rangeToSha);
   compare("selector", JSON.stringify(reviewed.selector), JSON.stringify(current.selector));
   compare("completeness", JSON.stringify(reviewed.completeness), JSON.stringify(current.completeness));
   compare("includesWorkingTree", reviewed.staleness.includesWorkingTree, current.staleness.includesWorkingTree);
@@ -59208,6 +59555,7 @@ async function stalePersistenceResult(input, maxBytes, message, modelCalls) {
   result.modelCalls = modelCalls;
   if (current.status !== "error") {
     result.scopeHash = current.scopeHash;
+    result.manifestHash = current.manifest.hash;
     result.scopeComplete = current.completeness.complete;
     Object.assign(result, scopeResultFields(current));
   }
@@ -59273,14 +59621,14 @@ var REVIEW_SYSTEM_PROMPT = [
 function renderReviewPrompt(input, renderedFallbackFiles, omittedFallbackFiles) {
   const { diff } = input;
   const exactRange = diff.selector.kind === "range";
-  const reviewTargetKind = diff.selector.kind === "range" ? "exact-committed-range" : diff.selector.kind === "working-tree" ? "checkout-index-working-tree" : "checkout-history-index-working-tree";
+  const reviewTargetKind2 = diff.selector.kind === "range" ? "exact-committed-range" : diff.selector.kind === "working-tree" ? "checkout-index-working-tree" : "checkout-history-index-working-tree";
   const fallback = diff.completeness.fileListFallback;
   const promptFallbackComplete = fallback?.complete && omittedFallbackFiles === 0;
   return [
     `TASK: Review the complete ${input.trigger.replaceAll("_", " ")} diff.`,
     input.phase ? `PHASE: ${input.phase}` : "",
     `REVIEW_SELECTOR: ${JSON.stringify(diff.selector)}`,
-    `REVIEW_TARGET_KIND: ${reviewTargetKind}`,
+    `REVIEW_TARGET_KIND: ${reviewTargetKind2}`,
     `SCOPE_HASH: ${diff.scopeHash}`,
     `BASE_REF: ${diff.baseRef ?? "none"}`,
     `BASE_SHA: ${diff.baseSha ?? "none"}`,
@@ -59497,7 +59845,7 @@ function addCost(evidence2, dispatches) {
 }
 function baseEvidence(input, diff, status) {
   return {
-    schema_version: 1,
+    schema_version: 2,
     timestamp: new Date().toISOString(),
     trigger: input.trigger,
     session_id: input.sessionID,
@@ -59517,7 +59865,8 @@ function baseEvidence(input, diff, status) {
       mode: input.config.final_review.mode,
       min_confidence: input.config.min_confidence,
       structured_findings: input.config.structured_findings,
-      validate_findings: input.config.validate_findings
+      validate_findings: input.config.validate_findings,
+      digest: undefined
     },
     review: { status },
     findings: [],
@@ -59576,6 +59925,8 @@ function emptyResult2(status, message, blocked, blockReason) {
 }
 async function persistErrorResult(input, diff, result, error2, dispatches, promptRequest) {
   const evidence2 = baseEvidence(input, diff, "error");
+  evidence2.scope.manifest = await materializeAutoReviewManifest(input.directory, diff.manifest, input.config);
+  evidence2.policy.digest = evidence2.scope.manifest.review_policy_digest;
   evidence2.review.error = error2;
   addCost(evidence2, dispatches);
   try {
@@ -59587,6 +59938,7 @@ async function persistErrorResult(input, diff, result, error2, dispatches, promp
     }
   }
   result.scopeHash = diff.scopeHash;
+  result.manifestHash = evidence2.scope.manifest.hash;
   result.scopeComplete = diff.completeness.complete;
   Object.assign(result, scopeResultFields(diff, promptRequest));
   return result;
@@ -59607,6 +59959,8 @@ async function runReviewEngine(input) {
   }
   if (diff.status === "clean") {
     const evidence3 = baseEvidence(input, diff, "clean");
+    evidence3.scope.manifest = await materializeAutoReviewManifest(input.directory, diff.manifest, input.config);
+    evidence3.policy.digest = evidence3.scope.manifest.review_policy_digest;
     let evidencePath2;
     try {
       evidencePath2 = await _internals83.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
@@ -59620,6 +59974,7 @@ async function runReviewEngine(input) {
       ...emptyResult2("clean", "Review scope is clean.", blocked2, blocked2 ? "EVIDENCE_PERSISTENCE_FAILED" : undefined),
       validationComplete: true,
       scopeHash: diff.scopeHash,
+      manifestHash: evidence3.scope.manifest.hash,
       scopeComplete: diff.completeness.complete,
       ...scopeResultFields(diff),
       evidencePath: evidencePath2
@@ -59630,6 +59985,7 @@ async function runReviewEngine(input) {
     diff,
     phase: input.phase
   });
+  const reviewManifest = await materializeAutoReviewManifest(input.directory, diff.manifest, input.config);
   if (input.phase !== undefined && (input.trigger === "phase_completion" || input.trigger === "plan_completion")) {
     const existing = _internals83.readPhaseEvidence(input.directory, input.phase);
     const integrity = existing ? validateAutoReviewEvidenceIntegrity(input.directory, existing, {
@@ -59644,7 +60000,7 @@ async function runReviewEngine(input) {
       },
       scopeContent: diff.canonicalText
     }) : undefined;
-    if (existing?.review.status === "completed" && existing.scope.head_sha === diff.headSha && integrity?.ok && integrity.receipt) {
+    if (existing?.review.status === "completed" && existing.schema_version === 2 && existing.scope.manifest?.hash === reviewManifest.hash && integrity?.ok && integrity.receipt) {
       const validationsById = new Map((integrity.receipt.finding_validations ?? []).map((validation) => [
         validation.finding_id,
         validation
@@ -59673,6 +60029,7 @@ async function runReviewEngine(input) {
         receiptPath: existing.receipt_path,
         evidencePath: path94.join(input.directory, ".swarm", "evidence", String(input.phase), "auto-review.json"),
         scopeHash: existing.scope.hash,
+        manifestHash: existing.scope.manifest?.hash,
         scopeComplete: diff.completeness.complete,
         ...scopeResultFields(diff, promptRequest),
         reviewModel: existing.review.model,
@@ -59779,6 +60136,8 @@ async function runReviewEngine(input) {
   }
   const blockingFindings = findings.filter((finding) => finding.anchored && isGateSeverity(finding.effective_severity) && finding.validation?.disposition === "CONFIRMED");
   const evidence2 = baseEvidence(input, diff, "completed");
+  evidence2.scope.manifest = reviewManifest;
+  evidence2.policy.digest = reviewManifest.review_policy_digest;
   evidence2.review = {
     status: "completed",
     output_mode: parsed.outputMode,
@@ -59896,6 +60255,7 @@ async function runReviewEngine(input) {
     receiptPath,
     evidencePath,
     scopeHash: diff.scopeHash,
+    manifestHash: reviewManifest.hash,
     scopeComplete: diff.completeness.complete,
     ...scopeResultFields(diff, promptRequest),
     reviewModel: dispatched.result.modelId,
@@ -61032,7 +61392,7 @@ import {
 import * as path99 from "path";
 
 // src/services/skill-optimizer/store.ts
-import { createHash as createHash21, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID12 } from "crypto";
 import {
   closeSync as closeSync16,
   existsSync as existsSync55,
@@ -61057,10 +61417,10 @@ function canonicalJson3(value) {
   return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson3(v)}`).join(",")}}`;
 }
 function computeStateHash(value) {
-  return createHash21("sha256").update(canonicalJson3(value), "utf8").digest("hex");
+  return createHash22("sha256").update(canonicalJson3(value), "utf8").digest("hex");
 }
 function computeContentHash2(content) {
-  return createHash21("sha256").update(content, "utf8").digest("hex");
+  return createHash22("sha256").update(content, "utf8").digest("hex");
 }
 function computeEventHash(event) {
   return computeStateHash({
@@ -62412,7 +62772,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
       if (!input.dispatcher) {
         throw new Error("no evaluation dispatcher available (cannot run validation)");
       }
-      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-ra9pjhp2.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-pqsf809k.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await _internals91.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -64183,6 +64543,7 @@ Writes a retrospective evidence bundle for a completed phase.
 \`\`\`json
 {
   "phase": 1,
+  "verdict": "pass",
   "summary": "Phase summary here",
   "task_count": 3,
   "task_complexity": "simple",
@@ -64201,6 +64562,8 @@ Writes a retrospective evidence bundle for a completed phase.
 - \`task_id\`: string (defaults to \`retro-{phase}\`)
 - \`metadata\`: Record<string, unknown>
 
+### verdict values: pass | fail
+
 ### task_complexity values: trivial | simple | moderate | complex`;
   }
   let parsedArgs;
@@ -64315,7 +64678,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-xz4x17z0.js");
+    const { buildHelpText } = await import("./index-9080b3de.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -64324,7 +64687,7 @@ async function handleHelpCommand(ctx) {
     return _internals94.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals94.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-xz4x17z0.js");
+  const { buildHelpText: fullHelp } = await import("./index-9080b3de.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -64501,7 +64864,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-j88dhm6w.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-r50fery8.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -64511,7 +64874,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-j88dhm6w.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-r50fery8.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -64521,7 +64884,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-xcb3ke8s.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-p69eys6d.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -71515,7 +71878,7 @@ function getDisplayBudget() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-2ahy8g87.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-2xn238xt.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -71931,7 +72294,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-f7se4wbf.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-2jtg2my1.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -72079,7 +72442,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-w78pc1hh.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-c2zrd384.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -72175,7 +72538,7 @@ async function preserveBackgroundWorktreeOwnershipForCallId(callID) {
   }
   const session = Buffer.from(dispatch.handle.sessionId, "utf8").toString("base64url");
   const lane = Buffer.from(dispatch.handle.id, "utf8").toString("base64url");
-  const callDigest = createHash22("sha256").update(callID).digest("hex").slice(0, 12);
+  const callDigest = createHash23("sha256").update(callID).digest("hex").slice(0, 12);
   const tag = `swarm-preserved-owner/${session}/${lane}/${callDigest}`;
   let tagProc;
   try {
@@ -72737,7 +73100,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-w78pc1hh.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-c2zrd384.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);