opencode-swarm 7.146.0 → 7.146.2

package/dist/cli/{index-pz2py5v7.js → index-rfph0nhf.js}

@@ -6,16 +6,16 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-0a0asz2s.js";
+} from "./index-w5r84rd1.js";
 import {
   stableCanonicalStringify
-} from "./index-vk15nbh4.js";
+} from "./index-c9jr4j2q.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-bma2wrqx.js";
+} from "./index-yxhcy5cm.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -38,6 +38,7 @@ import {
   isGitRepo,
   isGlobalFile,
   isProtectedPath,
+  isSecretscanEvidence,
   isStateUnreadable,
   isTransientSpawnError,
   isValidEvidenceType,
@@ -60,7 +61,7 @@ import {
   updateTaskStatus,
   validateProjectRoot,
   validateSymlinkBoundary
-} from "./index-d4e6wpkg.js";
+} from "./index-z5ppkn8y.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -77,7 +78,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-nsr5b69r.js";
+} from "./index-zkaz3fhw.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -103,12 +104,12 @@ import {
 } from "./index-y8552snf.js";
 import {
   readRecentEscalations
-} from "./index-f17j50dx.js";
+} from "./index-vmfaafte.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-gxbhp7sx.js";
+} from "./index-jv9xs6mb.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -178,7 +179,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-g3xt1d16.js";
+} from "./index-vj9bba5k.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -189,11 +190,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-q2mvacjr.js";
+} from "./index-n4k0pt5f.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-4p3qfb05.js";
+} from "./index-e1hjd15c.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -233,27 +234,30 @@ import {
   isGitBinaryMissing,
   isSpawnCwdMissing,
   isSpawnCwdUnreadable,
+  isStrictTaskId,
   listRecoveryRecords,
   parseTaskEvidence,
   postMergeCleanup,
   pruneStaleWorktreeMetadata,
+  readTaskEvidence,
   readWorkflowWalFile,
   reconcileLandedMerge,
   startupOrphanRecovery,
+  transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-92cxd0r1.js";
+} from "./index-tj861zhd.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-zsmsy1dh.js";
+} from "./index-cx67qa9g.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-kwxp0z0n.js";
+} from "./index-46cypnz3.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -267,7 +271,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-fzqhn96z.js";
+} from "./index-p0m03xa6.js";
 import {
   isPathWithinDeclaredScope,
   sanitizeDiagnosticText
@@ -318,7 +322,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-kfmee1cr.js";
+} from "./index-42nq97rb.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -332,10 +336,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-zd1mfygt.js";
+} from "./index-cr90rcg3.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-jfcgnvg6.js";
+} from "./index-y3hmyvt6.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -345,7 +349,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-5qwmpamg.js";
+} from "./index-01ybcsa5.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -359,7 +363,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-fay8h6v8.js";
+} from "./index-z9ed68jt.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -410,10 +414,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-x8pm918t.js";
+} from "./index-w0cj7zyd.js";
 import {
   atomicWriteFile
-} from "./index-j20fzn0w.js";
+} from "./index-qbpxrw95.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -425,7 +429,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-kggqpefz.js";
+} from "./index-ycgm9pzg.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -4193,7 +4197,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-1v2mythh.js");
+  } = await import("./worktree-isolation-87j70zg1.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -4295,7 +4299,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-1v2mythh.js");
+        } = await import("./worktree-isolation-87j70zg1.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -4438,6 +4442,8 @@ async function listCoderSettlementWalStates(directory) {
         transitionId: wal.transitionId,
         processId: wal.processId,
         recordedAt: wal.recordedAt,
+        accepted: wal.accepted === true ? true : undefined,
+        declaredFiles: wal.context?.declaredFiles ?? null,
         ownedInProcess: liveDispatches.has(dispatchKey(directory, taskId, wal.transitionId)),
         ownedByLiveForeignPid: wal.processId !== process.pid && isProcessAlive(wal.processId)
       });
@@ -6810,6 +6816,8 @@ var PR_REVIEW_MICRO_LANE_FLOORS = {
 var GATE_SCHEMA_VERSION = 1;
 var MAX_TRACKED_SESSIONS3 = 200;
 var MAX_WORKFLOW_BATCHES = 128;
+var MAX_PR_REVIEW_BASE_LANES_PER_BATCH = PR_REVIEW_BASE_DIMENSION_IDS.length;
+var MAX_PR_REVIEW_RESILIENCE_CIRCUIT_CONTRIBUTORS = MAX_WORKFLOW_BATCHES * MAX_PR_REVIEW_BASE_LANES_PER_BATCH;
 var MAX_RETIRED_REVIEWER_SESSION_IDS = 1024;
 var MAX_RETIRED_CONSOLIDATED_LANES = 64;
 var MAX_RETIRED_FEEDBACK_ITEM_OWNERS = 4096;
@@ -6845,9 +6853,39 @@ var PrReviewBaseDispatchRecordSchema = exports_external.object({
     laneId: exports_external.string().min(1),
     workflowLane: PrReviewBaseDimensionIdSchema,
     ownedWorkflowLanes: exports_external.array(PrReviewBaseDimensionIdSchema).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length).optional()
-  }).strict()).min(1),
+  }).strict()).min(1).max(MAX_PR_REVIEW_BASE_LANES_PER_BATCH),
   validatedAt: exports_external.string().min(1)
 }).strict();
+var PrReviewResiliencePolicyRecordSchema = exports_external.object({
+  enabled: exports_external.boolean(),
+  canaryProbeMs: exports_external.number().int().positive(),
+  statusProbeTimeoutMs: exports_external.number().int().positive(),
+  correlatedFailureThreshold: exports_external.number().int().min(2).max(8),
+  maxRetryAttemptsAfterInitial: exports_external.number().int().min(0).max(2)
+}).strict();
+var PrReviewResilienceAttemptRecordSchema = exports_external.object({
+  attempt: exports_external.union([exports_external.literal(0), exports_external.literal(1), exports_external.literal(2)]),
+  targetDimensions: exports_external.array(PrReviewBaseDimensionIdSchema).min(1).max(PR_REVIEW_BASE_DIMENSION_IDS.length),
+  canaryBatchId: exports_external.string().min(1),
+  canaryLaneId: exports_external.string().min(1),
+  canaryWorkflowLane: PrReviewBaseDimensionIdSchema,
+  admittedAt: exports_external.string().min(1),
+  fanoutBatchId: exports_external.string().min(1).optional()
+}).strict();
+var PrReviewResilienceCircuitRecordSchema = exports_external.object({
+  signature: exports_external.string().min(1).max(512),
+  count: exports_external.number().int().min(2).max(MAX_PR_REVIEW_RESILIENCE_CIRCUIT_CONTRIBUTORS),
+  contributors: exports_external.array(exports_external.object({
+    batchId: exports_external.string().min(1),
+    laneId: exports_external.string().min(1)
+  }).strict()).min(2).max(MAX_PR_REVIEW_RESILIENCE_CIRCUIT_CONTRIBUTORS),
+  openedAt: exports_external.string().min(1)
+}).strict();
+var PrReviewResilienceStateRecordSchema = exports_external.object({
+  policy: PrReviewResiliencePolicyRecordSchema,
+  attempts: exports_external.array(PrReviewResilienceAttemptRecordSchema).max(3),
+  circuit: PrReviewResilienceCircuitRecordSchema.optional()
+}).strict();
 var PrFeedbackLaneOwnershipSchema = exports_external.object({
   laneId: exports_external.string().min(1),
   ownedItemIds: exports_external.array(exports_external.string().min(1)).min(1)
@@ -6998,6 +7036,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   }).strict().optional(),
   prReviewBaseDispatches: exports_external.array(PrReviewBaseDispatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prReviewBaseDispatch: PrReviewBaseDispatchRecordSchema.optional(),
+  prReviewResilience: PrReviewResilienceStateRecordSchema.optional(),
   prReviewTriggerLedger: exports_external.array(PrReviewInlineTriggerRowSchema).length(PR_REVIEW_REQUIRED_TRIGGER_IDS.length).optional(),
   prReviewTriggerEvalPath: exports_external.string().min(1).optional(),
   prReviewTriggerEvalRunId: exports_external.string().min(1).optional(),
@@ -8020,6 +8059,7 @@ var _test_exports = {
   resolvePrReviewDiffStatsAsync,
   resolvePrWorkflowRevisionDigest,
   MAX_WORKFLOW_BATCHES,
+  MAX_PR_REVIEW_RESILIENCE_CIRCUIT_CONTRIBUTORS,
   MAX_RETIRED_REVIEWER_SESSION_IDS,
   MAX_RETIRED_CONSOLIDATED_LANES,
   MAX_RETIRED_FEEDBACK_ITEM_OWNERS,
@@ -15558,7 +15598,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-n6ke10ck.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -16642,7 +16682,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-5s0p3y8k.js");
+        const skillModule = await import("./skill-generator-fwvmcv8m.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -17102,7 +17142,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-c9p3w12b.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-mn4sx4qd.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -17921,7 +17961,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-znhqb8xa.js");
+      const { getScanStatus } = await import("./scan-cursor-p7t5mb4x.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.`);
@@ -18093,9 +18133,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-dnnm0p40.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-n6ke10ck.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -18103,11 +18143,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-5bxh1djq.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-cvy1s7wd.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-mmmfszv8.js");
+    const { checkHivePromotions } = await import("./hive-promoter-3tex870c.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -18116,7 +18156,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-5s0p3y8k.js");
+    } = await import("./skill-generator-fwvmcv8m.js");
     const result = {
       approved: [],
       rejected: [],
@@ -19452,9 +19492,9 @@ function hashContent(content) {
   return createHash7("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-dnnm0p40.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-n6ke10ck.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -30048,7 +30088,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-dnnm0p40.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-t8bmshhj.js");
     const { config: pmLoadedConfig } = _internals38.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -32312,9 +32352,9 @@ var _internals43 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-dnnm0p40.js"),
-      import("./curator-5bxh1djq.js"),
-      import("./curator-llm-factory-pe6skby4.js")
+      import("./schema-t8bmshhj.js"),
+      import("./curator-cvy1s7wd.js"),
+      import("./curator-llm-factory-6bra0bfd.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -33268,7 +33308,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-znhqb8xa.js");
+    const { getScanStatus } = await import("./scan-cursor-p7t5mb4x.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -33276,19 +33316,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-82ew2yc4.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-8pr02pza.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-dnnm0p40.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-n6ke10ck.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.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-xv0j8zyt.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-x19e8bqc.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -34564,7 +34604,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-vs6hvbew.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-vstrprja.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -35504,7 +35544,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-6m9jmzk8.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-yhap2xph.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -55730,6 +55770,172 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 `);
 }
 
+// src/workflow/stage-a-repair.ts
+import { appendFile as appendFile10, mkdir as mkdir24, readdir as readdir7 } from "fs/promises";
+import { dirname as dirname36 } from "path";
+init_logger();
+var MAX_STAGE_A_REPAIR_SCAN = 200;
+var RETRYABLE_EVENT_CODES = new Set(["EBUSY", "EPERM"]);
+async function appendStageARepairEvent(directory, payload) {
+  const line = `${JSON.stringify({
+    type: "stage_a_repair",
+    timestamp: new Date().toISOString(),
+    ...payload
+  })}
+`;
+  try {
+    const eventsPath = validateSwarmPath(directory, "events.jsonl");
+    await mkdir24(dirname36(eventsPath), { recursive: true });
+    await appendFile10(eventsPath, line, "utf-8");
+  } catch (error2) {
+    const code = error2.code;
+    if (code && RETRYABLE_EVENT_CODES.has(code)) {
+      try {
+        const eventsPath = validateSwarmPath(directory, "events.jsonl");
+        await appendFile10(eventsPath, line, "utf-8");
+        return;
+      } catch (retryError) {
+        criticalWarn(`[stage-a-repair] audit event write failed after retry: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+        return;
+      }
+    }
+    criticalWarn(`[stage-a-repair] audit event write failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
+  }
+}
+async function hasGreenPostSettlementPreCheck(directory, settledAfterMs) {
+  let sawSecretscanGreen = false;
+  let sawSastGreen = false;
+  for (const evidenceType of ["secretscan", "sast_scan"]) {
+    let result;
+    try {
+      result = await loadEvidence(directory, evidenceType, { migrate: false });
+    } catch {
+      continue;
+    }
+    if (result.status !== "found")
+      continue;
+    const entryTypeTag = evidenceType === "sast_scan" ? "sast" : evidenceType;
+    const typed = result.bundle.entries.filter((entry) => entry.type === entryTypeTag);
+    if (typed.length === 0)
+      continue;
+    const last = typed[typed.length - 1];
+    const ts = Date.parse(String(last.timestamp ?? ""));
+    if (settledAfterMs !== null && Number.isFinite(ts) && ts < settledAfterMs) {
+      return { green: false, reason: "pre_check_failed_or_stale" };
+    }
+    if (evidenceType === "secretscan") {
+      if ((last.verdict === "pass" || last.verdict === "approved" || last.verdict === "info") && isSecretscanEvidence(last) && (last.incomplete_files ?? 0) === 0 && (last.files_scanned ?? 0) > 0 && (last.findings_count ?? 0) === 0) {
+        sawSecretscanGreen = true;
+        continue;
+      }
+    } else if (last.verdict === "pass" || last.verdict === "approved" || last.verdict === "info") {
+      sawSastGreen = true;
+      continue;
+    }
+    if (last.verdict === "fail" || last.verdict === "rejected") {
+      return { green: false, reason: "pre_check_failed_or_stale" };
+    }
+  }
+  if (!sawSecretscanGreen || !sawSastGreen) {
+    return { green: false, reason: "no_pre_check_bundles" };
+  }
+  return { green: true };
+}
+async function repairWedgedStageA(directory, options) {
+  const requested = options?.taskIds;
+  let entries;
+  try {
+    const evidenceDir = validateSwarmPath(directory, "evidence");
+    entries = await readdir7(evidenceDir);
+  } catch {
+    return { results: [], truncated: false };
+  }
+  const candidates = entries.filter((entry) => entry.endsWith(".json") && isStrictTaskId(entry.slice(0, -".json".length)));
+  const selected = requested?.length ? candidates.filter((entry) => requested.includes(entry.slice(0, -".json".length))) : candidates;
+  const truncated = !requested?.length && candidates.length > MAX_STAGE_A_REPAIR_SCAN;
+  const results = [];
+  for (const entry of selected.sort().slice(0, MAX_STAGE_A_REPAIR_SCAN)) {
+    const taskId = entry.slice(0, -".json".length);
+    try {
+      const evidence2 = await readTaskEvidence(directory, taskId);
+      const workflow = getTaskWorkflowSnapshot(evidence2);
+      if (workflow.state !== "coder_delegated") {
+        results.push({
+          taskId,
+          outcome: "skipped_not_wedged",
+          state: workflow.state
+        });
+        continue;
+      }
+      if (evidence2?.gates?.pre_check) {
+        results.push({
+          taskId,
+          outcome: "skipped_not_wedged",
+          state: workflow.state
+        });
+        continue;
+      }
+      let settledAfterMs = null;
+      try {
+        const { states } = await listCoderSettlementWalStates(directory);
+        for (const state of states) {
+          if (state.taskId !== taskId)
+            continue;
+          if (state.state !== "COMMITTED")
+            continue;
+          if (state.recordedAt === undefined)
+            continue;
+          const parsed = Date.parse(state.recordedAt);
+          if (!Number.isFinite(parsed))
+            continue;
+          settledAfterMs = settledAfterMs === null ? parsed : Math.max(settledAfterMs, parsed);
+        }
+      } catch {}
+      if (settledAfterMs === null) {
+        const fallbackTs = Date.parse(workflow.updatedAt);
+        if (Number.isFinite(fallbackTs))
+          settledAfterMs = fallbackTs;
+      }
+      const greenness = await hasGreenPostSettlementPreCheck(directory, settledAfterMs);
+      if (!greenness.green) {
+        results.push({
+          taskId,
+          outcome: "skipped_not_green",
+          reason: greenness.reason
+        });
+        continue;
+      }
+      const transitionId = `stage-a-repair:${taskId}:${workflow.generation}`;
+      await transitionTaskWorkflowEvidence(directory, taskId, {
+        type: "stage_a_passed",
+        expectedGeneration: workflow.generation,
+        transitionId
+      });
+      await appendStageARepairEvent(directory, {
+        action: "repaired",
+        taskId,
+        transitionId,
+        generation: workflow.generation
+      });
+      results.push({
+        taskId,
+        outcome: "repaired",
+        generation: workflow.generation,
+        transitionId
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      await appendStageARepairEvent(directory, {
+        action: "repair-failed",
+        taskId,
+        message: sanitizeDiagnosticText(message, 512)
+      });
+      results.push({ taskId, outcome: "error", message });
+    }
+  }
+  return { results, truncated };
+}
+
 // src/commands/recover.ts
 function renderOutcome(outcome) {
   switch (outcome.outcome) {
@@ -55749,6 +55955,20 @@ function renderOutcome(outcome) {
       return `\u274C Task ${outcome.taskId}: unknown outcome`;
   }
 }
+function renderStageARepairOutcome(outcome) {
+  switch (outcome.outcome) {
+    case "repaired":
+      return `\u2705 Task ${outcome.taskId}: Stage A repaired \u2014 stage_a_passed written at generation ${outcome.generation} without re-running the coder`;
+    case "skipped_not_wedged":
+      return `\u23ED\uFE0F Task ${outcome.taskId}: workflow state is ${outcome.state} with pre_check proof present or not settled \u2014 nothing to repair`;
+    case "skipped_not_green":
+      return `\u23ED\uFE0F Task ${outcome.taskId}: no green post-settlement pre-check evidence (${outcome.reason === "no_pre_check_bundles" ? "missing or non-green secretscan/SAST bundle \u2014 run pre_check_batch first" : "latest pre-check run failed or predates the settlement"}) \u2014 refusing to mark Stage A passed without proof`;
+    case "error":
+      return `\u274C Task ${outcome.taskId}: Stage A repair failed \u2014 ${sanitizeDiagnosticText(outcome.message, 512)}`;
+    default:
+      return `\u274C Task ${outcome.taskId}: unknown repair outcome`;
+  }
+}
 async function handleRecoverCommand(directory, args) {
   const force = args.includes("--force");
   const positional = args.filter((arg) => !arg.startsWith("--"));
@@ -55763,44 +55983,41 @@ async function handleRecoverCommand(directory, args) {
 `);
   }
   const { states: listed, truncated: listTruncated } = await listCoderSettlementWalStates(directory);
+  const report = ["## Coder Settlement Recovery", ""];
+  const hasKnownWal = listed.length > 0 && (!taskId || listed.some((entry) => entry.taskId === taskId));
   if (listed.length === 0) {
-    return [
-      "## Coder Settlement Recovery",
-      "",
-      taskId ? `\u274C No settlement WAL for task ${taskId} (no settlement WALs found in .swarm/coder-settlements/).` : "No coder settlement WALs found in .swarm/coder-settlements/ \u2014 nothing to recover."
-    ].join(`
-`);
-  }
-  if (taskId) {
-    const target = listed.find((entry) => entry.taskId === taskId);
-    if (!target) {
-      return [
-        "## Coder Settlement Recovery",
-        "",
-        `\u274C No settlement WAL for task ${taskId}. Known tasks: ${listed.map((entry) => entry.taskId).join(", ")}`
-      ].join(`
-`);
+    report.push(taskId ? `\u274C No settlement WAL for task ${taskId} (no settlement WALs found in .swarm/coder-settlements/).` : "No coder settlement WALs found in .swarm/coder-settlements/ \u2014 nothing to recover.");
+  } else if (taskId && !hasKnownWal) {
+    report.push(`\u274C No settlement WAL for task ${taskId}. Known tasks: ${listed.map((entry) => entry.taskId).join(", ")}`);
+  } else {
+    const { results, truncated: recoverTruncated } = await recoverStaleCoderSettlements(directory, {
+      ...taskId ? { taskIds: [taskId] } : {},
+      force
+    });
+    const lines = results.map((outcome) => renderOutcome(outcome));
+    const recoveredCount = results.filter((r) => r.outcome === "recovered").length;
+    const blockedCount = results.filter((r) => r.outcome === "owned_in_process" || r.outcome === "owned_by_live_foreign_pid").length;
+    report.push(...lines, "", `Recovered ${recoveredCount} settlement(s)${blockedCount > 0 ? `; ${blockedCount} still owned by a live dispatch (see above for the exact remediation)` : ""}.`);
+    if (listTruncated || recoverTruncated) {
+      report.push("", "\u26A0\uFE0F More settlement WALs exist than the recovery scan cap (200) \u2014 older settlements were NOT listed or processed. Re-run after the tasks above are settled to reach the rest.");
+    }
+    if (force && recoveredCount > 0) {
+      report.push("", "\u26A0\uFE0F --force released in-process ownership before recovery. If any of these dispatches was genuinely still running, its completion will report CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT \u2014 that error is expected and safe to ignore; the settlement is already durably recovered.");
     }
   }
-  const { results, truncated: recoverTruncated } = await recoverStaleCoderSettlements(directory, {
-    ...taskId ? { taskIds: [taskId] } : {},
-    force
-  });
-  const lines = results.map((outcome) => renderOutcome(outcome));
-  const recoveredCount = results.filter((r) => r.outcome === "recovered").length;
-  const blockedCount = results.filter((r) => r.outcome === "owned_in_process" || r.outcome === "owned_by_live_foreign_pid").length;
-  const report = [
-    "## Coder Settlement Recovery",
-    "",
-    ...lines,
-    "",
-    `Recovered ${recoveredCount} settlement(s)${blockedCount > 0 ? `; ${blockedCount} still owned by a live dispatch (see above for the exact remediation)` : ""}.`
-  ];
-  if (listTruncated || recoverTruncated) {
-    report.push("", "\u26A0\uFE0F More settlement WALs exist than the recovery scan cap (200) \u2014 older settlements were NOT listed or processed. Re-run after the tasks above are settled to reach the rest.");
-  }
-  if (force && recoveredCount > 0) {
-    report.push("", "\u26A0\uFE0F --force released in-process ownership before recovery. If any of these dispatches was genuinely still running, its completion will report CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT \u2014 that error is expected and safe to ignore; the settlement is already durably recovered.");
+  try {
+    const { results: repairResults, truncated: repairTruncated } = await repairWedgedStageA(directory, {
+      ...taskId ? { taskIds: [taskId] } : {}
+    });
+    const repaired = repairResults.filter((r) => r.outcome === "repaired");
+    if (repairResults.length > 0) {
+      report.push("", "## Wedged Stage A Repair", "", ...repairResults.map(renderStageARepairOutcome), "", repaired.length === 0 ? "No wedged tasks repaired." : `Repaired ${repaired.length} wedged task(s); reviewer/test_engineer dispatch is now permitted for them.`);
+      if (repairTruncated) {
+        report.push("", "\u26A0\uFE0F More evidence files exist than the repair scan cap (200) \u2014 re-run after the tasks above are processed to reach the rest.");
+      }
+    }
+  } catch (err) {
+    report.push("", `\u26A0\uFE0F Wedged Stage A repair failed (settlement recovery above is unaffected): ${sanitizeDiagnosticText(err instanceof Error ? err.message : String(err), 512)}`);
   }
   return report.join(`
 `);
@@ -63212,7 +63429,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-pqsf809k.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-e7z9cf5y.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await _internals91.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -63734,7 +63951,7 @@ init_loader();
 init_schema();
 
 // src/consensus/store.ts
-import { readdir as readdir7, unlink as unlink6 } from "fs/promises";
+import { readdir as readdir8, unlink as unlink6 } from "fs/promises";
 import * as path106 from "path";
 
 // src/consensus/contracts.ts
@@ -63914,7 +64131,7 @@ function swarmPath(directory, ...segments) {
 async function countConsensusReportFiles(directory) {
   const root = swarmPath(directory, CONSENSUS_RELATIVE_DIR);
   try {
-    const entries = await readdir7(root, { withFileTypes: true });
+    const entries = await readdir8(root, { withFileTypes: true });
     return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json") && REPORT_ID_RE.test(entry.name.slice(0, -".json".length))).length;
   } catch (error2) {
     if (error2.code === "ENOENT")
@@ -64657,8 +64874,8 @@ async function countProposals(directory) {
     const proposalsDir = validateSwarmPath(directory, "skills/proposals");
     if (!fsSync3.existsSync(proposalsDir))
       return 0;
-    const { readdir: readdir8 } = await import("fs/promises");
-    const entries = await readdir8(proposalsDir);
+    const { readdir: readdir9 } = await import("fs/promises");
+    const entries = await readdir9(proposalsDir);
     return entries.filter((f) => f.endsWith(".md")).length;
   } catch {
     return 0;
@@ -65118,7 +65335,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-j43qndgc.js");
+    const { buildHelpText } = await import("./index-r46q6996.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -65127,7 +65344,7 @@ async function handleHelpCommand(ctx) {
     return _internals94.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals94.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-j43qndgc.js");
+  const { buildHelpText: fullHelp } = await import("./index-r46q6996.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -65304,7 +65521,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-jhbxq8yb.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-h8cnwa02.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -65314,7 +65531,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-jhbxq8yb.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-h8cnwa02.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -65324,7 +65541,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-vpbp3rm4.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-syb7tz2w.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -65984,7 +66201,7 @@ Subcommands:
   recover: {
     handler: (ctx) => handleRecoverCommand(ctx.directory, ctx.args),
     description: "Recover wedged coder settlements [task_id] [--force]",
-    details: "Settles stale coder-settlement WALs in .swarm/coder-settlements/ \u2014 the CODER_DISPATCH_IN_PROGRESS wedge where a dispatch's completion never fired (issue #2268). Safe mode recovers settlements whose owner process is gone. --force also releases ownership keys held by this process: use only when no dispatch is genuinely running (a late completion then reports CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT, safe to ignore). Never interrupts another live OpenCode process. Human-only.",
+    details: "Settles stale coder-settlement WALs in .swarm/coder-settlements/ \u2014 the CODER_DISPATCH_IN_PROGRESS wedge where a dispatch's completion never fired (issue #2268). Safe mode recovers settlements whose owner process is gone. --force also releases ownership keys held by this process: use only when no dispatch is genuinely running (a late completion then reports CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT, safe to ignore). Never interrupts another live OpenCode process. Also repairs tasks wedged at coder_delegated with unattributed green pre_check evidence \u2014 the post-reset TASK_WORKFLOW_STAGE_A_REQUIRED wedge \u2014 by writing the missing stage_a_passed transition directly (audit events land in .swarm/events.jsonl); pass [task_id] to scope both phases to one task. Human-only.",
     args: "[task_id] [--force]",
     category: "utility",
     toolPolicy: "human-only"
@@ -66501,7 +66718,7 @@ If a tool modifies a file, it is a CODER tool. Delegate.
    Separate parallel-mode exception (distinct from the Stage B exception above, and the ONLY case where more than one coder may be dispatched before waiting): when an active \`[PARALLEL EXECUTION PROFILE]\` directive is present in your context (parallelization_enabled=true), you MAY dispatch multiple {{AGENT_PREFIX}}coder agents in a single message \u2014 up to the stated max_concurrent_tasks \u2014 but ONLY for distinct, dependency-ready tasks whose declared file scopes do NOT overlap. Each coder still requires its own \`declare_scope\` call and carries exactly ONE task (Rule 3 still holds: never batch multiple objectives into one coder). Parallel coders each run in an isolated git worktree, so their writes never collide and are merged back automatically. If no \`[PARALLEL EXECUTION PROFILE]\` directive is present, dispatch coders one at a time.
 
     > **WORKTREE ISOLATION IS BASELINE.** Standard parallel coders use isolated git worktrees by default; this is governed by the top-level \`worktree.policy\` setting (default \`auto\`) in \`PluginConfig\` \u2014 a sibling of \`parallelization:\`, not nested under it \u2014 and is active whenever the plan's \`parallelization_enabled=true\`. \`turbo.lean.worktree_isolation\` is a separate, Lean-Turbo-internal flag (default \`false\`); it is one possible SOURCE but NOT the recommended one. Do NOT recommend Lean Turbo (or Epic) SOLELY to obtain worktree isolation; recommend them only for what they add beyond baseline (Lean Turbo: lane planning, file locks, phase reviewer, integrated diff; Epic: co-change awareness + auto-decide). Lean Turbo users can also enable isolation via \`turbo.lean.worktree_isolation: true\`, but this is the secondary/legacy path \u2014 the recommended path is \`worktree.policy\`.
-   Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes \u2014 \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane \u2014 use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts \u2014 do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). The lane mechanism is a SINGLE \`dispatch_lanes_async\` call carrying all lane specs \u2014 NOT a per-agent Task/run-in-background pattern. Call \`dispatch_lanes_async\` with all lane specs in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Poll incrementally with \`collect_lane_results\` without \`wait\` (or with \`wait: false\`) to harvest lanes as they settle; process completed lane output immediately while other lanes remain pending/running, then continue independent work between polls. Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. A settled lane's inline \`output\` is delivered only once: if you poll the same lane again after already receiving its output, the repeat poll returns \`output_omitted_repeat: true\` with no \`output\` (not a sign the result was lost) \u2014 use the accompanying \`output_ref\` with \`retrieve_lane_output\` if you need the text again, and do not re-dispatch the lane. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt \u2014 inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
+   Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes \u2014 \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane \u2014 use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts \u2014 do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). Ordinarily, each lane wave is one \`dispatch_lanes_async\` call carrying that wave's complete lane specs \u2014 NOT a per-agent Task/run-in-background pattern. The explicit exception is an active PR_REVIEW with enabled tier-M/L staged resilience: send the singleton canary as one call, then send only its unresolved fanout as a second call after canary admission. For each admissible wave, call \`dispatch_lanes_async\` with all specs for that wave in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Poll incrementally with \`collect_lane_results\` without \`wait\` (or with \`wait: false\`) to harvest lanes as they settle; process completed lane output immediately while other lanes remain pending/running, then continue independent work between polls. Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. A settled lane's inline \`output\` is delivered only once: if you poll the same lane again after already receiving its output, the repeat poll returns \`output_omitted_repeat: true\` with no \`output\` (not a sign the result was lost) \u2014 use the accompanying \`output_ref\` with \`retrieve_lane_output\` if you need the text again, and do not re-dispatch the lane. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt \u2014 inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
 3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
 3a. PRE-DELEGATION SCOPE CALL (required): BEFORE every {{AGENT_PREFIX}}coder delegation, you MUST call \`declare_scope\` with { taskId, files, replace_existing: true } listing the exact file(s) this task will modify (including generated/lockfile paths). No \`declare_scope\` call \u2192 no coder delegation. See Rule 1a.
 3b. PRE-DELEGATION SCOPE CALL (test_engineer): BEFORE any {{AGENT_PREFIX}}test_engineer delegation that will CREATE or MODIFY test files, you MUST call \`declare_scope\` with { taskId, files, replace_existing: true } listing the exact test file path(s) to write. Omitting this call leaves the write scope undeclared and will block the write. See Rule 1a.
@@ -67256,9 +67473,9 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - FOLLOW THE SKILL EXACTLY: execute every phase of the loaded SKILL.md in order with no shortcuts, no phase-skipping, and no premature synthesis. If a required coverage phase cannot complete, apply the skill's coverage gate (retry or verified equivalent alternative). If the gap still cannot be closed, stop and surface the lane failure to the user as BLOCKED; do not produce a degraded review, partial verdict, or final synthesis.
 - CHECK OUT THE EXACT PR HEAD LOCALLY before dispatching explorer lanes: resolve the authoritative full PR head SHA, verify the working tree is clean (git status --porcelain), and if it is dirty call \`prepare_pr_workflow_checkout\` before checkout \u2014 either with no \`paths\` to auto-discover and preserve every dirty and untracked change in one auditable stash, or with an explicit exact dirty tracked path set. It returns the stash OID and recovery command; an already-clean tree is a no-op. Do NOT run \`git stash\` through shell. Then use standalone commands: fetch the PR head, verify it portably with \`git rev-parse --verify <full_pr_head_sha>^0\` followed by \`git cat-file -t <full_pr_head_sha>\` (which must print \`commit\`), run \`git switch --detach <full_pr_head_sha>\`, confirm HEAD equals that SHA, and bind it through the PR-review controller. Do not use \`--track FETCH_HEAD\`. Explorers read the working-tree filesystem (Read/Glob/Grep), so without this checkout they read the base branch and produce invalid candidates. Always pass the base..head commit range in explorer delegations. Under Profile A, do not create a scratch context-pack file after the gate activates: put bounded shared scope, obligations, and deterministic signals in \`common_prompt\`; every lane must inspect the exact bound diff itself.
 - Treat the controller Git-state result as final for the attempt: \`clean\` proceeds; \`stashable\` permits one preparation call; \`recovery-required\` or \`indeterminate\` means report the typed \`required_action\`, abort/clear any already-active gate, and STOP unless \`retryable: true\`. Never loop on stash against an unmerged index or in-progress Git operation.
-- RUN ALL BASE LANES: the default PR_REVIEW path always launches exactly six repository-agnostic base check-type lanes from the skill. Use \`mode: "swarm-pr-review:base"\` and the exact six \`workflow_lane\` identifiers. The runtime rejects partial, duplicate, or mislabelled waves. Do not collapse, omit, or scale down the base lanes for a small, docs-only, or CI-only PR.
-- RETRY STRUCTURALLY: retry only failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected. After the second failed retry, collect every lane to settlement, do not probe downstream writers or micro lanes, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a non-empty one-line \`reason\` naming the failed lane and exhausted retries, then call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before reporting the blocker.
-- USE ASYNC DISPATCH WITHOUT IDLING: launch the base lanes with one \`dispatch_lanes_async\` call when available, record the \`batch_id\`, then keep doing non-dependent architect work while they run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
+- RUN ALL BASE LANES: the default PR_REVIEW path covers all six repository-agnostic base dimensions from the skill on every PR. Use \`mode: "swarm-pr-review:base"\`, the exact \`workflow_lane\` identifiers, and the exact bound \`pr_head_sha\`. With the default \`pr_review_resilience\` policy enabled, depth tier M/L MUST stage attempt 0 as one singleton \`pr_review_wave_stage: "canary"\` batch followed by a \`"fanout"\` batch whose combined canary+fanout ownership partitions all six dimensions exactly once; tier L still requires six singleton combined lanes, and tier S keeps the legacy one-wave path. If a project disables \`pr_review_resilience\`, stay on the legacy one-wave base dispatch. The runtime rejects omitted stage metadata, partial, duplicate, mislabelled, or structurally invalid waves.
+- RETRY STRUCTURALLY: retry only unresolved failed base obligations in later \`swarm-pr-review:base\` async batches with the same exact \`pr_head_sha\`. Under staged resilience, attempts are numbered by \`pr_review_wave_attempt\`: attempt 0 plus at most two retry attempts (1 and 2), each with one singleton canary batch and then its matching fanout batch when obligations remain. Blocking \`dispatch_lanes\` and direct Task explorer/reviewer/critic dispatch are not provenance-equivalent and are rejected. If the runtime returns typed \`retry_exhausted\` or \`circuit_open\`, or if the second retry still cannot close coverage, collect every lane to settlement, do not probe downstream writers or micro lanes, call \`abort_pr_workflow\` with \`mode: "PR_REVIEW"\`, \`kind: "recovery"\`, and a non-empty one-line \`reason\` naming the failed lane or correlated failure and exhausted retries, then call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before reporting the blocker.
+- USE ASYNC DISPATCH WITHOUT IDLING: each admissible base wave uses one \`dispatch_lanes_async\` call. With enabled tier-M/L staged resilience, this means one singleton canary call followed by one unresolved-only fanout call after canary admission; it never means one legacy call carrying the whole initial base wave. Record each \`batch_id\`, then keep doing non-dependent architect work while its lanes run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
 - EVALUATE ALL RISK FAMILIES: after the base explorer lanes settle, evaluate every repository-agnostic trigger row against the exact diff/context pack. Record applicable families as \`MATCHED\` and inapplicable families as provenance-free \`NOT_TRIGGERED\` with concrete absence evidence; \`unclassified-risk\` always remains \`MATCHED\`. Launch \`swarm-pr-review:micro\` lanes only for the \`MATCHED\` IDs. The first micro dispatch MUST pass the complete exact eleven-row \`trigger_evaluation\`, which freezes it for this session; any subsequent same-session micro batch may omit it and reuse the frozen ledger, while an explicitly supplied copy must remain exactly identical. Use each dispatched trigger ID as \`workflow_lane\`. Missing an evaluation row or a matched-family attestation is BLOCKED; a \`NOT_TRIGGERED\` family must not create a micro artifact.
 - RUN HEAD-BOUND VALIDATION: dispatch independent reviewers with \`mode: "swarm-pr-review:reviewer"\` and critics with \`mode: "swarm-pr-review:critic"\`, unique \`workflow_lane\` obligations, role-correct agents, and the same exact \`pr_head_sha\`. Critic dispatch is blocked until all declared reviewer obligations have successful artifacts.
 - COMPLETE EXPLICITLY: after final artifacts and synthesis, call \`complete_pr_workflow\` with \`mode: "PR_REVIEW"\` and the bound \`pr_head_sha\`; never leave the session trapped in a stale workflow gate. When completion reports checkout restoration is required, call \`prepare_pr_workflow_checkout\` with \`operation: "restore"\` before returning to the user.
@@ -71071,6 +71288,11 @@ var GUARDED_TOOLS = new Set([
 ]);
 var selfDevelopmentWorkspaces = new Map;
 // src/hooks/guardrails/index.ts
+var durableAttributionAdvisoryBySession = new Map;
+var STAGE_A_ATTRIBUTION_MISS_CODES = new Set([
+  "TASK_WORKFLOW_CODER_MUTATION_REQUIRED",
+  "TASK_WORKFLOW_STAGE_A_REQUIRED"
+]);
 var SPEC_DRIFT_BLOCKED_TOOLS = new Set([
   "save_plan",
   "update_task_status",
@@ -72890,7 +73112,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-jvvm935f.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-3wzpwe5z.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -73548,7 +73770,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-jvvm935f.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-3wzpwe5z.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);