opencode-swarm 7.156.0 → 7.157.0

package/dist/cli/{index-ppx8bnzd.js → index-gk6wpq41.js}

@@ -6,21 +6,22 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-4m3j9q9z.js";
+} from "./index-t0kxka8n.js";
 import {
   finalizeShellAuditForClose,
   isPolicyProtectedPath,
+  normalizeToolName,
   normalizeToolNameLowerCase,
   protectedRoots,
   redactDecisionLineForArchive,
   stableCanonicalStringify
-} from "./index-wn0xm2e8.js";
+} from "./index-4kd1nqd2.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-68098cfj.js";
+} from "./index-nd22bsnt.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -67,7 +68,7 @@ import {
   validateProjectRoot,
   validateSymlinkBoundary,
   validateTargetWithinRoot
-} from "./index-q2khkey7.js";
+} from "./index-93ymj3j5.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -84,7 +85,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-gthnsbzf.js";
+} from "./index-ngn6jmad.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -110,12 +111,12 @@ import {
 } from "./index-txdagbh7.js";
 import {
   readRecentEscalations
-} from "./index-6g6qwr8z.js";
+} from "./index-g0j2hnse.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-sm2t1awr.js";
+} from "./index-1dzy1j4v.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -139,7 +140,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-fjcm6wwf.js";
+} from "./index-91ybfvy2.js";
 import {
   clearWorktreeMergeStatus,
   getAllWorktreeMergeFailures,
@@ -151,12 +152,12 @@ import {
   listCoderSettlementWalStates,
   recoverCoderSettlement,
   recoverStaleCoderSettlements
-} from "./index-zdgdf0e9.js";
+} from "./index-vbqssmbs.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
   removeWorktreeProvisioningOwner
-} from "./index-0q8kywcf.js";
+} from "./index-dwkrdpz2.js";
 import {
   BUNDLED_PROJECT_SKILL_ROOT,
   DEFAULT_SKILL_MIN_CONFIDENCE,
@@ -177,7 +178,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-sfdg1xg5.js";
+} from "./index-n6ayyadp.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -188,11 +189,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-9n555qz4.js";
+} from "./index-tvtvhjh0.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-aqg7c1z9.js";
+} from "./index-gpf3cjre.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -223,12 +224,12 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-5r3zrw81.js";
+} from "./index-61nkp124.js";
 import {
   makeWorktreeBranchName,
   provisionWorktree,
   removeWorktree
-} from "./index-za6bb2fd.js";
+} from "./index-p0by16z8.js";
 import {
   DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
   DELEGATION_COMPACTION_HIGH_WATER_BYTES,
@@ -243,7 +244,7 @@ import {
   scanBackgroundCoderReservationsForAdmission,
   scanDelegationsForRecovery,
   sweepStaleDelegations
-} from "./index-fpg4tzf7.js";
+} from "./index-12e2hztp.js";
 import {
   compositeSessionKey,
   sessionKeySuffix
@@ -254,6 +255,7 @@ import {
   resolveCommitCountSinceAsync,
   resolveCurrentGitHead,
   resolveCurrentGitHeadAsync,
+  resolveCurrentLocalHeadRefAsync,
   resolveCurrentUpstreamPushTarget,
   resolveCurrentUpstreamPushTargetAsync,
   resolveCurrentUpstreamRemoteRef,
@@ -271,15 +273,17 @@ import {
   resolvePrWorkflowRevisionDigestDetailedAsync,
   resolveRemoteRefsContainingHead,
   resolveRemoteRefsContainingHeadAsync,
+  resolveRemoteUrlIdentity,
+  resolveRemoteUrlIdentityAsync,
   switchPrFeedbackTrackingCandidateAsync
-} from "./index-vnn7qq8c.js";
+} from "./index-3f7hqtgg.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-fd7wj6fy.js";
+} from "./index-n7gv8m7v.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -294,7 +298,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-mdypz60w.js";
+} from "./index-79k7p589.js";
 import {
   CORE_EVENT_LOCKED,
   appendCoreEventSync,
@@ -304,7 +308,7 @@ import {
   hasSpecDriftAuditEvent,
   hasTaskRepairAuditEvent,
   readCoreEvents
-} from "./index-xdy28ngt.js";
+} from "./index-nwkr6tvv.js";
 import {
   sanitizeDiagnosticText
 } from "./index-556ja8an.js";
@@ -353,7 +357,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-dfmr6pj5.js";
+} from "./index-j3egsxa1.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -369,10 +373,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-98j6z038.js";
+} from "./index-3vqdt1sx.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-164c64z8.js";
+} from "./index-q94gt4n9.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -395,7 +399,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-b91qwpms.js";
+} from "./index-2e60kmzg.js";
 import {
   DEFAULT_HARNESS_EVOLUTION_CONFIG,
   DEFAULT_PR_REVIEW_RESILIENCE_CONFIG,
@@ -411,7 +415,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-5w87j6j4.js";
+} from "./index-4w20thrc.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -425,7 +429,7 @@ import {
   init_agent_names,
   init_constants,
   init_tool_metadata
-} from "./index-myt57pht.js";
+} from "./index-9r7gp6cp.js";
 import {
   init_git_executable,
   resolveGitExecutable,
@@ -451,10 +455,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-85p1850w.js";
+} from "./index-b5xm177r.js";
 import {
   atomicWriteFile
-} from "./index-ew6fykvv.js";
+} from "./index-xe6zbfps.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -466,7 +470,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-6bqqzfbe.js";
+} from "./index-6sbx96v6.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -6915,7 +6919,7 @@ async function commitTaskTerminalUnderPlanLock(options) {
 
 // src/hooks/pr-workflow-gate.ts
 init_zod();
-import { createHash as createHash6, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID2 } from "crypto";
 import { readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import * as fsp2 from "fs/promises";
 import * as path12 from "path";
@@ -9121,6 +9125,108 @@ var _internals15 = {
   parsePorcelainV2: parsePorcelainV2Snapshot
 };
 
+// src/memory/redaction.ts
+import { createHash as createHash6 } from "crypto";
+var SECRET_PATTERNS = [
+  { type: "openai_api_key", pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+  {
+    type: "github_token",
+    pattern: /\b(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}\b/g
+  },
+  { type: "aws_access_key_id", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
+  {
+    type: "private_key_block",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
+  },
+  {
+    type: "authorization_bearer",
+    pattern: /\bAuthorization\s*:\s*Bearer\s+[A-Za-z0-9._~+/=-]{12,}/gi
+  },
+  {
+    type: "env_secret",
+    pattern: /\b(?:[A-Z][A-Z0-9]+_)+(?:KEY|TOKEN|SECRET|PASSWORD)\b\s*=\s*["']?[^\s"'`]{8,}["']?/gi
+  },
+  { type: "gitlab_token", pattern: /\bgl(?:pat|ptt)-[A-Za-z0-9_-]{15,}\b/g },
+  { type: "slack_token", pattern: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g },
+  {
+    type: "jwt_token",
+    pattern: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g
+  },
+  {
+    type: "aws_secret_access_key",
+    pattern: /\b(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY|secret_access_key|SecretAccessKey)"?\s*[=:]\s*["']?[A-Za-z0-9/+=]{40}\b/g
+  },
+  {
+    type: "aws_secret_access_key_context",
+    pattern: /\bAKIA[0-9A-Z]{16}\b[^\n]{0,200}?\b[A-Za-z0-9/+=]{40}\b/g
+  },
+  {
+    type: "stripe_secret_key",
+    pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{24,}\b/g
+  },
+  { type: "google_api_key", pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+  {
+    type: "openssh_private_key_block",
+    pattern: /-----BEGIN[ ]OPENSSH[ ]PRIVATE[ ]KEY-----[\s\S]*?-----END[ ]OPENSSH[ ]PRIVATE[ ]KEY-----/g
+  }
+];
+var REDACTION_POLICY_SALT = 2;
+function computeRedactionPolicyVersion(policy) {
+  return REDACTION_POLICY_SALT * 1e6 + SECRET_PATTERNS.length * 2 + (policy.rejectDurableSecrets ? 1 : 0) + (policy.detectPii ? 4 : 0) + (policy.rejectDurablePii ? 8 : 0) + (policy.piiDetector === "ner" ? 16 : 0);
+}
+var FINGERPRINT_ALGORITHM_VERSION = 2;
+var LEGACY_FINGERPRINT_ALGORITHM_VERSION = 1;
+var _internals16 = {
+  currentAlgorithmVersion: FINGERPRINT_ALGORITHM_VERSION
+};
+function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVersion = _internals16.currentAlgorithmVersion) {
+  const storedVersion = rawStoredVersion === undefined ? LEGACY_FINGERPRINT_ALGORITHM_VERSION : rawStoredVersion;
+  if (typeof storedVersion !== "number" || !Number.isFinite(storedVersion)) {
+    return { status: "unknown" };
+  }
+  return storedVersion === currentVersion ? { status: "comparable" } : { status: "mismatch", storedVersion, currentVersion };
+}
+function computeMemoryCohortFingerprint(input) {
+  const canonical = stableCanonicalStringify(input);
+  return createHash6("sha256").update(canonical).digest("hex").slice(0, 12);
+}
+function buildMemoryCohortFingerprintInput(config) {
+  return {
+    provider: config.provider,
+    redaction_policy_version: computeRedactionPolicyVersion({
+      rejectDurableSecrets: config.redaction.rejectDurableSecrets,
+      detectPii: config.redaction.detectPii,
+      rejectDurablePii: config.redaction.rejectDurablePii,
+      piiDetector: config.redaction.piiDetector
+    }),
+    embedding_model: config.embeddings.model,
+    embedding_dimension: config.embeddings.dimension,
+    embedding_version: config.embeddings.version ?? "default"
+  };
+}
+function findSecrets(text) {
+  const findings = [];
+  for (const { type, pattern } of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of text.matchAll(pattern)) {
+      if (match[0])
+        findings.push({ type, match: match[0] });
+    }
+  }
+  return findings;
+}
+function containsSecret(text) {
+  return findSecrets(text).length > 0;
+}
+function redactSecrets(text) {
+  let redacted = text;
+  for (const { type, pattern } of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    redacted = redacted.replace(pattern, `[REDACTED:${type}]`);
+  }
+  return redacted;
+}
+
 // src/hooks/pr-workflow-gate.ts
 init_tool_metadata();
 init_logger();
@@ -9229,6 +9335,10 @@ var PR_REVIEW_MICRO_LANE_FLOORS = {
   M: 6,
   L: PR_REVIEW_REQUIRED_MICRO_LANE_IDS.length
 };
+var MAX_PUBLICATION_HISTORY_GENERATIONS = 4;
+var MAX_PUBLICATION_ATTEMPTS = 8;
+var MAX_PUSH_ATTEMPT_DIAGNOSTIC_CHARS = 500;
+var PUBLICATION_SCHEMA_VERSION = 1;
 var GATE_SCHEMA_VERSION = 1;
 var MAX_TRACKED_SESSIONS3 = 200;
 var MAX_WORKFLOW_BATCHES = 128;
@@ -9375,6 +9485,86 @@ var PrFeedbackReadyToPublishRecordSchema = exports_external.object({
   remoteRef: exports_external.string().startsWith("refs/remotes/"),
   validatedAt: exports_external.string().min(1)
 }).strict();
+var PrFeedbackPublicationEvidenceJoinSchema = exports_external.object({
+  stageAValidatedAt: exports_external.string().min(1),
+  batches: exports_external.array(exports_external.object({
+    phase: exports_external.enum([
+      "stage-b-reviewer",
+      "stage-b-test",
+      "closeout-reviewer",
+      "closeout-critic"
+    ]),
+    batchId: exports_external.string().min(1),
+    laneId: exports_external.string().min(1)
+  }).strict())
+}).strict();
+var PrFeedbackPublicationGenerationSchema = exports_external.object({
+  schemaVersion: exports_external.literal(PUBLICATION_SCHEMA_VERSION),
+  generation: exports_external.number().int().positive(),
+  state: exports_external.enum([
+    "reviewing",
+    "armed",
+    "invalidated",
+    "push_in_flight",
+    "published",
+    "cancelled_without_publication"
+  ]),
+  workspaceIdentity: exports_external.string().min(1),
+  sessionID: exports_external.string().min(1),
+  prTargetUrl: exports_external.string().min(1).optional(),
+  intakeHeadSha: exports_external.string().min(1),
+  localHeadRef: exports_external.string().min(1),
+  localHead: exports_external.string().min(1),
+  remoteName: exports_external.string().min(1),
+  remoteUrlIdentity: exports_external.string().min(1).optional(),
+  remoteBranchRef: exports_external.string().startsWith("refs/heads/"),
+  remoteRef: exports_external.string().startsWith("refs/remotes/"),
+  revisionDigest: exports_external.string().min(1),
+  evidence: PrFeedbackPublicationEvidenceJoinSchema,
+  invalidationReason: exports_external.string().min(1).optional(),
+  supersededByGeneration: exports_external.number().int().positive().optional(),
+  createdAt: exports_external.string().min(1),
+  armedAt: exports_external.string().min(1).optional(),
+  invalidatedAt: exports_external.string().min(1).optional(),
+  publishedAt: exports_external.string().min(1).optional(),
+  cancelledAt: exports_external.string().min(1).optional()
+}).strict();
+var PrFeedbackPushAttemptSchema = exports_external.object({
+  attemptId: exports_external.string().min(1),
+  generation: exports_external.number().int().positive(),
+  sessionID: exports_external.string().min(1),
+  callID: exports_external.string().min(1).optional(),
+  intentDigest: exports_external.string().regex(/^[0-9a-f]{64}$/),
+  intent: exports_external.object({
+    remote: exports_external.string().min(1),
+    sourceSha: exports_external.string().min(1),
+    destRef: exports_external.string().startsWith("refs/heads/")
+  }).strict(),
+  prePush: exports_external.object({
+    localHead: exports_external.string().min(1),
+    worktreeClean: exports_external.boolean(),
+    remoteName: exports_external.string().min(1),
+    remoteBranchRef: exports_external.string().startsWith("refs/heads/"),
+    observedRemoteHead: exports_external.string().min(1).nullable()
+  }).strict(),
+  startedAt: exports_external.string().min(1),
+  result: exports_external.object({
+    outcome: exports_external.enum(["completed", "rejected", "uncertain", "cancelled"]),
+    exitStatus: exports_external.union([exports_external.number().int(), exports_external.literal("not-observed")]),
+    diagnostic: exports_external.string().max(MAX_PUSH_ATTEMPT_DIAGNOSTIC_CHARS),
+    postPush: exports_external.object({
+      localHead: exports_external.string().min(1).nullable(),
+      observedRemoteHead: exports_external.string().min(1).nullable()
+    }).strict(),
+    completedAt: exports_external.string().min(1)
+  }).strict().optional()
+}).strict();
+var PrFeedbackPublicationStateSchema = exports_external.object({
+  schemaVersion: exports_external.literal(PUBLICATION_SCHEMA_VERSION),
+  active: PrFeedbackPublicationGenerationSchema.optional(),
+  history: exports_external.array(PrFeedbackPublicationGenerationSchema).max(MAX_PUBLICATION_HISTORY_GENERATIONS),
+  attempts: exports_external.array(PrFeedbackPushAttemptSchema).max(MAX_PUBLICATION_ATTEMPTS)
+}).strict();
 var PrFeedbackInventoryAmendmentRecordSchema = exports_external.object({
   entry: exports_external.string().min(1),
   amendedAt: exports_external.string().min(1),
@@ -9483,6 +9673,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prFeedbackStageA: PrFeedbackStageARecordSchema.optional(),
   prFeedbackGateBatches: exports_external.array(PrFeedbackGateBatchRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prFeedbackReadyToPublish: PrFeedbackReadyToPublishRecordSchema.optional(),
+  prFeedbackPublication: PrFeedbackPublicationStateSchema.optional(),
   prFeedbackRebindCount: exports_external.number().int().nonnegative().optional(),
   prFeedbackScopes: exports_external.array(PrFeedbackScopeDeclarationRecordSchema).max(MAX_WORKFLOW_BATCHES).optional()
 }).passthrough();
@@ -9785,14 +9976,49 @@ async function finalizeOverriddenProbeRetainedLanes(directory, sessionID, correl
 }
 async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery", reason: "" }) {
   const recovery = await readPrWorkflowGateStateForRecovery(directory, sessionID);
-  if (!recovery)
+  if (!recovery) {
+    if (options.cancelPublication) {
+      if (!options.reason.trim()) {
+        throw new Error("BLOCKED: cancel_publication requires a non-empty reason; the cancellation reason is part of the durable audit trail");
+      }
+      const dangling = findDanglingLivePublicationGeneration(directory, sessionID);
+      if (!dangling)
+        throw noActiveGateError(sessionID);
+      appendPublicationEvent(directory, {
+        type: "pr_feedback_publication_cancelled",
+        sessionID: normalizeSessionID(sessionID),
+        generation: dangling.generation,
+        reason: options.reason.trim(),
+        stateFileAbsent: true
+      });
+      return {
+        mode: "PR_FEEDBACK",
+        openLanes: 0,
+        stateSalvaged: false,
+        stateSalvageDisclosure: "The gate state file was already absent; the live publication generation in the audit trail was recorded as cancelled_without_publication (event-only terminal)."
+      };
+    }
     throw noActiveGateError(sessionID);
+  }
   const state = recovery.state;
+  let cancelRevision = null;
   if (options.expectedMode && state.mode !== options.expectedMode) {
     throw wrongModeError(state, options.expectedMode);
   }
-  if (state.prFeedbackReadyToPublish || recovery.armedShapeUnreadable) {
-    throw new Error(`BLOCKED: ${state.mode} is armed for publication; abort is blocked. Complete the workflow with complete_pr_workflow (or push the bound commit first) before aborting.` + (recovery.armedShapeUnreadable ? " The publication-arming record is itself unreadable, so it is treated as armed (fail-closed)." : ""));
+  if (options.cancelPublication) {
+    if (options.kind === "force") {
+      throw new Error('BLOCKED: cancel_publication cannot be combined with kind "force"; use kind "cancel-publication" with a reason');
+    }
+    if (!options.reason.trim()) {
+      throw new Error("BLOCKED: cancel_publication requires a non-empty reason; the cancellation reason is part of the durable audit trail");
+    }
+    if (state.mode !== "PR_FEEDBACK" || !state.prFeedbackReadyToPublish && !recovery.armedShapeUnreadable && !state.prFeedbackPublication?.active) {
+      throw new Error("BLOCKED: cancel_publication applies only to a PR_FEEDBACK workflow with a publication generation (armed, push_in_flight, or invalidated)");
+    }
+    cancelRevision = await cancelPrFeedbackPublication(directory, sessionID, options.reason.trim());
+  }
+  if ((state.prFeedbackReadyToPublish || recovery.armedShapeUnreadable) && !options.cancelPublication) {
+    throw new Error(`BLOCKED: ${state.mode} is armed for publication; abort is blocked. Complete the workflow with complete_pr_workflow (or push the bound commit first) before aborting, or use the audited cancellation (abort_pr_workflow with cancel_publication and a reason).` + (recovery.armedShapeUnreadable ? " The publication-arming record is itself unreadable, so it is treated as armed (fail-closed)." : ""));
   }
   const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
   const probeRetainedLanes = laneSettlement.probedAliveLaneIds ?? [];
@@ -9841,7 +10067,7 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
   const casEscape = recovery.salvaged && !recovery.revisionSalvageable;
   await _test_exports2.beforeAbortClear?.();
   try {
-    await clearPrWorkflowGateState(directory, sessionID, casEscape ? undefined : state.revision, { allowSalvagedRead: recovery.salvaged });
+    await clearPrWorkflowGateState(directory, sessionID, casEscape ? undefined : cancelRevision ?? state.revision, { allowSalvagedRead: recovery.salvaged });
   } catch (error2) {
     try {
       appendCoreEventSync(directory, {
@@ -10079,7 +10305,7 @@ async function readAndVerifyCoverageDisclosure(directory, state) {
     throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure path does not match its bound run");
   }
   const raw = await readBoundedSwarmRegularFile(directory, relativePath, PR_REVIEW_COVERAGE_DISCLOSURE_MAX_BYTES, "PR_REVIEW partial base coverage disclosure");
-  const digest2 = createHash6("sha256").update(raw, "utf8").digest("hex");
+  const digest2 = createHash7("sha256").update(raw, "utf8").digest("hex");
   if (digest2 !== expectedDigest) {
     throw new Error("BLOCKED: PR_REVIEW partial base coverage disclosure digest does not match durable state");
   }
@@ -10159,6 +10385,897 @@ async function assertPrReviewValidationSettled(directory, sessionID, phase, gate
   }
   return state;
 }
+var PR_FEEDBACK_PHASE_ORDER = [
+  "stage-b-reviewer",
+  "stage-b-test",
+  "closeout-reviewer",
+  "closeout-critic"
+];
+async function verifyPublicationIdentityComponent(directory, state, active, component) {
+  switch (component) {
+    case "digest": {
+      try {
+        const digest2 = await currentPrFeedbackRevisionDigest(directory, state);
+        return digest2 === active.revisionDigest ? { kind: "intact" } : {
+          kind: "drift",
+          component,
+          detail: `approved revision digest ${active.revisionDigest} vs current ${digest2}`
+        };
+      } catch (error2) {
+        return {
+          kind: "unresolvable",
+          component,
+          detail: String(error2?.message ?? error2)
+        };
+      }
+    }
+    case "head": {
+      const head = (await _test_exports2.resolveCurrentGitHeadAsync(directory))?.trim();
+      if (!head)
+        return {
+          kind: "unresolvable",
+          component,
+          detail: "HEAD resolution returned empty"
+        };
+      return head === active.localHead ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: `approved head ${active.localHead} vs current ${head}`
+      };
+    }
+    case "worktree": {
+      const clean = await _test_exports2.resolveIsWorkingTreeCleanAsync(directory);
+      if (clean !== true && clean !== false)
+        return {
+          kind: "unresolvable",
+          component,
+          detail: "clean-status resolution failed"
+        };
+      return clean === true ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: "working tree or index is dirty"
+      };
+    }
+    case "upstream": {
+      const target = await _test_exports2.resolveCurrentUpstreamPushTargetAsync(directory);
+      if (!target)
+        return {
+          kind: "unresolvable",
+          component,
+          detail: "upstream target resolution returned empty"
+        };
+      return target.remoteName === active.remoteName && target.remoteBranchRef === active.remoteBranchRef && target.remoteTrackingRef === active.remoteRef ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: `approved target ${active.remoteName}/${active.remoteBranchRef}/${active.remoteRef} vs current ${target.remoteName}/${target.remoteBranchRef}/${target.remoteTrackingRef}`
+      };
+    }
+    case "remote-url": {
+      if (!active.remoteUrlIdentity) {
+        return {
+          kind: "unresolvable",
+          component,
+          detail: "armed generation carries no remote URL identity"
+        };
+      }
+      const url = await _test_exports2.resolveRemoteUrlIdentityAsync(directory, active.remoteName);
+      if (!url)
+        return {
+          kind: "unresolvable",
+          component,
+          detail: `remote "${active.remoteName}" URL could not be resolved`
+        };
+      return url === active.remoteUrlIdentity ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: `approved remote URL identity ${active.remoteUrlIdentity} vs current ${url}`
+      };
+    }
+    case "workspace-identity": {
+      const identity = canonicalWorkspaceIdentity(directory);
+      if (!identity)
+        return {
+          kind: "unresolvable",
+          component,
+          detail: "canonical workspace identity could not be resolved"
+        };
+      return identity === active.workspaceIdentity ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: `generation is bound to a different workspace`
+      };
+    }
+    case "evidence-join": {
+      return publicationEvidenceJoinIntact(state, active) ? { kind: "intact" } : {
+        kind: "drift",
+        component,
+        detail: "the receipt set recorded at arming is no longer the active one"
+      };
+    }
+    default:
+      return { kind: "unresolvable", component, detail: "unknown component" };
+  }
+}
+var PUBLICATION_IDENTITY_COMPONENTS = [
+  "digest",
+  "head",
+  "worktree",
+  "upstream",
+  "remote-url",
+  "workspace-identity"
+];
+async function checkPublicationIdentity(directory, state, active) {
+  for (const component of PUBLICATION_IDENTITY_COMPONENTS) {
+    const check = await verifyPublicationIdentityComponent(directory, state, active, component);
+    if (check.kind !== "intact")
+      return check;
+  }
+  if (!publicationEvidenceJoinIntact(state, active)) {
+    return {
+      kind: "drift",
+      component: "evidence-join",
+      detail: "the receipt set recorded at arming is no longer the active one"
+    };
+  }
+  return { kind: "intact" };
+}
+function publicationEvidenceJoinIntact(state, active) {
+  if (state.prFeedbackStageA?.validatedAt !== active.evidence.stageAValidatedAt)
+    return false;
+  for (const join11 of active.evidence.batches) {
+    const batch = [...state.prFeedbackGateBatches ?? []].reverse().find((candidate) => candidate.phase === join11.phase);
+    if (!batch || batch.batchId !== join11.batchId || batch.laneId !== join11.laneId)
+      return false;
+  }
+  return true;
+}
+function buildPublicationEvidenceJoin(state, currentDigest) {
+  const stageA = state.prFeedbackStageA;
+  if (!stageA || stageA.revisionDigest !== currentDigest || !stageA.validatedAt)
+    return null;
+  const batches = [];
+  for (const phase of PR_FEEDBACK_PHASE_ORDER) {
+    const batch = [...state.prFeedbackGateBatches ?? []].reverse().find((candidate) => candidate.phase === phase && candidate.revisionDigest === currentDigest);
+    if (!batch)
+      return null;
+    batches.push({ phase, batchId: batch.batchId, laneId: batch.laneId });
+  }
+  return { stageAValidatedAt: stageA.validatedAt, batches };
+}
+function appendPublicationEvent(directory, event) {
+  try {
+    appendCoreEventSync(directory, { ...event, timestamp: isoNow() });
+  } catch {}
+}
+function boundPublicationDiagnostic(text) {
+  const redacted = redactSecrets(text);
+  return redacted.length > MAX_PUSH_ATTEMPT_DIAGNOSTIC_CHARS ? `${redacted.slice(0, MAX_PUSH_ATTEMPT_DIAGNOSTIC_CHARS - 3)}...` : redacted;
+}
+function nextPublicationContainer(previous, active, historyAppends = [], attempts = []) {
+  const history = [...previous?.history ?? [], ...historyAppends].slice(-MAX_PUBLICATION_HISTORY_GENERATIONS);
+  return {
+    schemaVersion: PUBLICATION_SCHEMA_VERSION,
+    active,
+    history,
+    attempts: attempts.slice(-MAX_PUBLICATION_ATTEMPTS)
+  };
+}
+async function invalidatePublicationGeneration(directory, sessionID, reason, options = {}) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  return withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    if (!state || state.mode !== "PR_FEEDBACK") {
+      throw new Error("BLOCKED: PR_FEEDBACK publication invalidation requires an active PR_FEEDBACK gate");
+    }
+    return applyPublicationInvalidationWhileLocked(directory, state, reason, options);
+  });
+}
+async function applyPublicationInvalidationWhileLocked(directory, state, reason, options = {}) {
+  {
+    const active = state.prFeedbackPublication?.active;
+    const legacyRecord = active ? undefined : state.prFeedbackReadyToPublish;
+    if (!active && !legacyRecord) {
+      throw new Error("BLOCKED: no armed publication generation to invalidate");
+    }
+    if (active && active.state !== "armed" && active.state !== "push_in_flight") {
+      throw new Error(`BLOCKED: publication generation ${active.generation} is already ${active.state}`);
+    }
+    if (options.driftReverification && options.drift && active) {
+      const recheck = await verifyPublicationIdentityComponent(directory, state, active, options.drift.component);
+      if (recheck.kind !== "drift") {
+        throw new Error(`BLOCKED: PR_FEEDBACK publication drift on ${options.drift.component} did not re-confirm under the state lock (${recheck.kind}); no invalidation was recorded \u2014 retry from current state`);
+      }
+      options.drift = { component: recheck.component, detail: recheck.detail };
+    }
+    const now = isoNow();
+    let attempts = (state.prFeedbackPublication?.attempts ?? []).map((attempt) => attempt.result ? attempt : {
+      ...attempt,
+      result: {
+        outcome: options.finalizeInFlightAs ?? "uncertain",
+        exitStatus: "not-observed",
+        diagnostic: `finalized by publication invalidation (${reason})`,
+        postPush: { localHead: null, observedRemoteHead: null },
+        completedAt: now
+      }
+    });
+    let invalidated;
+    if (active) {
+      invalidated = {
+        ...active,
+        state: "invalidated",
+        invalidatedAt: now,
+        invalidationReason: reason
+      };
+    } else if (legacyRecord) {
+      invalidated = {
+        schemaVersion: PUBLICATION_SCHEMA_VERSION,
+        generation: 1,
+        state: "invalidated",
+        workspaceIdentity: canonicalWorkspaceIdentity(directory) ?? "unresolvable",
+        sessionID: state.sessionID,
+        intakeHeadSha: state.prHeadSha ?? "unknown",
+        localHeadRef: "unknown",
+        localHead: legacyRecord.localHead,
+        remoteName: legacyRecord.remoteName,
+        remoteUrlIdentity: undefined,
+        remoteBranchRef: legacyRecord.remoteBranchRef,
+        remoteRef: legacyRecord.remoteRef,
+        revisionDigest: legacyRecord.revisionDigest,
+        evidence: {
+          stageAValidatedAt: state.prFeedbackStageA?.validatedAt ?? "unknown",
+          batches: (state.prFeedbackGateBatches ?? []).map((batch) => ({
+            phase: batch.phase,
+            batchId: batch.batchId,
+            laneId: batch.laneId
+          }))
+        },
+        invalidationReason: reason,
+        createdAt: legacyRecord.validatedAt,
+        armedAt: legacyRecord.validatedAt,
+        invalidatedAt: now
+      };
+    } else {
+      throw new Error("BLOCKED: no armed publication generation to invalidate");
+    }
+    if (!active) {
+      attempts = [];
+    }
+    const nextState = {
+      ...state,
+      updatedAt: now,
+      prFeedbackStageA: undefined,
+      prFeedbackVerifications: undefined,
+      prFeedbackGateBatches: undefined,
+      prFeedbackScopes: undefined,
+      prFeedbackReadyToPublish: undefined,
+      prFeedbackPublication: nextPublicationContainer(state.prFeedbackPublication, invalidated, [], attempts)
+    };
+    await writeStateWhileLocked(directory, nextState);
+    appendPublicationEvent(directory, {
+      type: "pr_feedback_publication_invalidated",
+      sessionID: state.sessionID,
+      generation: invalidated.generation,
+      reason,
+      previousState: active?.state ?? "armed",
+      drift: options.drift ?? null,
+      revisionDigest: invalidated.revisionDigest,
+      localHead: invalidated.localHead,
+      remoteName: invalidated.remoteName,
+      remoteBranchRef: invalidated.remoteBranchRef,
+      supersededBatchIds: invalidated.evidence.batches.map((b) => b.batchId)
+    });
+    return { generation: invalidated, state: nextState };
+  }
+}
+async function ensurePublicationGenerationCurrent(directory, sessionID) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  const state = await readPrWorkflowGateState(directory, normalizedSessionID);
+  if (!state || state.mode !== "PR_FEEDBACK")
+    return state;
+  if (state.prFeedbackPublication || !state.prFeedbackReadyToPublish) {
+    return state;
+  }
+  const legacy = state.prFeedbackReadyToPublish;
+  return withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const locked = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    if (!locked || locked.mode !== "PR_FEEDBACK")
+      return locked ?? state;
+    if (locked.prFeedbackPublication || !locked.prFeedbackReadyToPublish) {
+      return locked;
+    }
+    const now = isoNow();
+    const base = {
+      schemaVersion: PUBLICATION_SCHEMA_VERSION,
+      generation: 1,
+      sessionID: locked.sessionID,
+      prTargetUrl: locked.prFeedbackTargetUrl,
+      intakeHeadSha: locked.prHeadSha ?? "unknown",
+      revisionDigest: legacy.revisionDigest,
+      evidence: buildPublicationEvidenceJoin(locked, legacy.revisionDigest) ?? {
+        stageAValidatedAt: "unknown",
+        batches: []
+      },
+      createdAt: legacy.validatedAt,
+      armedAt: legacy.validatedAt
+    };
+    const mismatch = async (reason) => {
+      const invalidated = {
+        ...base,
+        evidence: base.evidence.batches.length > 0 ? base.evidence : {
+          stageAValidatedAt: locked.prFeedbackStageA?.validatedAt ?? "unknown",
+          batches: (locked.prFeedbackGateBatches ?? []).map((batch) => ({
+            phase: batch.phase,
+            batchId: batch.batchId,
+            laneId: batch.laneId
+          }))
+        },
+        state: "invalidated",
+        workspaceIdentity: canonicalWorkspaceIdentity(directory) ?? "unresolvable",
+        localHeadRef: "unknown",
+        localHead: legacy.localHead,
+        remoteName: legacy.remoteName,
+        remoteUrlIdentity: undefined,
+        remoteBranchRef: legacy.remoteBranchRef,
+        remoteRef: legacy.remoteRef,
+        invalidationReason: reason,
+        invalidatedAt: now
+      };
+      const nextState2 = {
+        ...locked,
+        updatedAt: now,
+        prFeedbackStageA: undefined,
+        prFeedbackVerifications: undefined,
+        prFeedbackGateBatches: undefined,
+        prFeedbackScopes: undefined,
+        prFeedbackReadyToPublish: undefined,
+        prFeedbackPublication: nextPublicationContainer(locked.prFeedbackPublication, invalidated)
+      };
+      await writeStateWhileLocked(directory, nextState2);
+      appendPublicationEvent(directory, {
+        type: "pr_feedback_publication_migrated",
+        sessionID: locked.sessionID,
+        generation: 1,
+        outcome: "invalidated",
+        reason
+      });
+      return nextState2;
+    };
+    if (locked.prFeedbackStageA?.revisionDigest !== legacy.revisionDigest || !(locked.prFeedbackGateBatches ?? []).some((batch) => batch.revisionDigest === legacy.revisionDigest)) {
+      return mismatch("legacy-migration-receipt-mismatch");
+    }
+    const workspaceIdentity = canonicalWorkspaceIdentity(directory);
+    if (!workspaceIdentity)
+      return mismatch("legacy-migration-unresolvable");
+    let digest2;
+    try {
+      digest2 = await currentPrFeedbackRevisionDigest(directory, locked);
+    } catch {
+      return mismatch("legacy-migration-unresolvable");
+    }
+    const head = (await _test_exports2.resolveCurrentGitHeadAsync(directory))?.trim();
+    const target = await _test_exports2.resolveCurrentUpstreamPushTargetAsync(directory);
+    const localHeadRef = await resolveCurrentLocalHeadRefAsync(directory);
+    const remoteUrlIdentity = await _test_exports2.resolveRemoteUrlIdentityAsync(directory, legacy.remoteName);
+    if (digest2 !== legacy.revisionDigest || head !== legacy.localHead || !target || target.remoteName !== legacy.remoteName || target.remoteBranchRef !== legacy.remoteBranchRef || target.remoteTrackingRef !== legacy.remoteRef || !localHeadRef || !remoteUrlIdentity) {
+      return mismatch("legacy-migration-identity-mismatch");
+    }
+    const evidenceJoin = buildPublicationEvidenceJoin(locked, legacy.revisionDigest);
+    if (!evidenceJoin) {
+      return mismatch("legacy-migration-receipt-mismatch");
+    }
+    const upgraded = {
+      ...base,
+      evidence: evidenceJoin,
+      state: "armed",
+      workspaceIdentity,
+      localHeadRef,
+      localHead: legacy.localHead,
+      remoteName: legacy.remoteName,
+      remoteUrlIdentity,
+      remoteBranchRef: legacy.remoteBranchRef,
+      remoteRef: legacy.remoteRef
+    };
+    const nextState = {
+      ...locked,
+      updatedAt: now,
+      prFeedbackPublication: nextPublicationContainer(locked.prFeedbackPublication, upgraded)
+    };
+    await writeStateWhileLocked(directory, nextState);
+    appendPublicationEvent(directory, {
+      type: "pr_feedback_publication_migrated",
+      sessionID: locked.sessionID,
+      generation: 1,
+      outcome: "armed",
+      reason: "legacy-record-proven-equivalent"
+    });
+    return nextState;
+  });
+}
+async function reconcileForeignInFlightAttempt(directory, sessionID, currentCallId) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  return withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    const publication = state?.prFeedbackPublication;
+    const active = publication?.active;
+    if (!state || !publication || !active || active.state !== "push_in_flight" || !publication.attempts.some((attempt) => !attempt.result)) {
+      return state;
+    }
+    const now = isoNow();
+    const localHead = (await _test_exports2.resolveCurrentGitHeadAsync(directory))?.trim();
+    const observedRemoteHead = await _test_exports2.resolveExactRemoteBranchHeadAsync(directory, active.remoteName, active.remoteBranchRef);
+    const attempts = publication.attempts.map((attempt) => attempt.result ? attempt : {
+      ...attempt,
+      result: {
+        outcome: "uncertain",
+        exitStatus: "not-observed",
+        diagnostic: boundPublicationDiagnostic(`recovered without an observed result${currentCallId && attempt.callID === currentCallId ? " (same call)" : ""}`),
+        postPush: { localHead: localHead ?? null, observedRemoteHead },
+        completedAt: now
+      }
+    });
+    const nextState = {
+      ...state,
+      updatedAt: now,
+      prFeedbackPublication: nextPublicationContainer(publication, { ...active, state: "armed" }, [], attempts)
+    };
+    await writeStateWhileLocked(directory, nextState);
+    appendPublicationEvent(directory, {
+      type: "pr_feedback_push_attempt_result",
+      sessionID: state.sessionID,
+      generation: active.generation,
+      outcome: "uncertain",
+      by: "reaper",
+      observedRemoteHead
+    });
+    return nextState;
+  });
+}
+async function invalidatePrFeedbackPublication(directory, sessionID, reason) {
+  const trimmed = reason.trim();
+  if (!trimmed) {
+    throw new Error("BLOCKED: invalidate_pr_feedback_publication requires a non-empty reason; the reason is part of the durable audit trail");
+  }
+  await ensurePublicationGenerationCurrent(directory, sessionID);
+  await reconcileForeignInFlightAttempt(directory, sessionID);
+  const result = await invalidatePublicationGeneration(directory, sessionID, `controller-rework:${trimmed}`);
+  return result.generation;
+}
+function describePrWorkflowPublicationSection(state) {
+  const active = state.prFeedbackPublication?.active;
+  const history = state.prFeedbackPublication?.history ?? [];
+  const attempts = state.prFeedbackPublication?.attempts ?? [];
+  if (!active && !state.prFeedbackReadyToPublish && history.length === 0) {
+    return null;
+  }
+  const lines = [];
+  if (state.prFeedbackReadyToPublish && !active) {
+    lines.push("publication: legacy armed record awaiting generation migration (fail-closed until the next gated interaction migrates it)");
+  }
+  if (active) {
+    lines.push(`publication: generation ${active.generation} state=${active.state}`);
+    lines.push(`  approved: ${active.localHead} -> ${active.remoteName} ${active.remoteBranchRef} (digest ${active.revisionDigest.slice(0, 12)}\u2026)`);
+    if (active.remoteUrlIdentity) {
+      lines.push(`  remote url identity: ${active.remoteUrlIdentity}`);
+    }
+    if (active.state === "invalidated" && active.invalidationReason) {
+      lines.push(`  invalidated because: ${active.invalidationReason}`);
+    }
+    if (active.supersededByGeneration) {
+      lines.push(`  superseded by generation ${active.supersededByGeneration}`);
+    }
+    const generationAttempts = attempts.filter((attempt) => attempt.generation === active.generation);
+    if (generationAttempts.length > 0) {
+      const outcomes = generationAttempts.map((attempt) => attempt.result?.outcome ?? "in-flight");
+      lines.push(`  push attempts: ${generationAttempts.length} (${outcomes.join(", ")})`);
+    }
+    switch (active.state) {
+      case "armed":
+        lines.push("  next: run the exact approved push, then complete_pr_workflow");
+        break;
+      case "push_in_flight":
+        lines.push("  next: a push attempt is in flight; the next gated interaction reconciles it (uncertain) and re-verifies the remote before any retry");
+        break;
+      case "invalidated":
+        lines.push("  next: rerun Stage A and every independent gate on the corrected content, then arm a fresh generation with complete_pr_workflow; the exact scoped rework path reopens via prepare_pr_feedback_scope");
+        break;
+      case "published":
+        lines.push("  terminal: published (verified remote head)");
+        break;
+      case "cancelled_without_publication":
+        lines.push("  terminal: cancelled without publication");
+        break;
+      default:
+        lines.push("  next: continue the ordered gates");
+    }
+  }
+  if (history.length > 0) {
+    const summary = history.map((generation) => `gen ${generation.generation}: ${generation.state}${generation.supersededByGeneration ? ` -> ${generation.supersededByGeneration}` : ""}`).join("; ");
+    lines.push(`  superseded generations: ${summary}`);
+  }
+  lines.push("  audit: full publication trail in the .swarm events store (pr_feedback_publication_*, pr_feedback_push_attempt_*, pr_feedback_published)");
+  return lines.join(`
+`);
+}
+var PUBLICATION_EVENT_TYPES = new Set([
+  "pr_feedback_publication_armed",
+  "pr_feedback_publication_migrated",
+  "pr_feedback_push_attempt_started",
+  "pr_feedback_publication_invalidated",
+  "pr_feedback_published",
+  "pr_feedback_publication_cancelled"
+]);
+function findDanglingLivePublicationGeneration(directory, sessionID) {
+  let text;
+  try {
+    text = readCoreEvents(directory).text;
+  } catch {
+    return null;
+  }
+  if (!text.trim())
+    return null;
+  let dangling = null;
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (typeof event.type !== "string" || !PUBLICATION_EVENT_TYPES.has(event.type) || event.sessionID !== sessionID) {
+      continue;
+    }
+    const generation = typeof event.generation === "number" ? event.generation : null;
+    switch (event.type) {
+      case "pr_feedback_publication_armed":
+      case "pr_feedback_push_attempt_started":
+        dangling = generation ? { generation } : dangling;
+        break;
+      case "pr_feedback_publication_migrated":
+        if (event.outcome === "armed") {
+          dangling = generation ? { generation } : dangling;
+        } else {
+          dangling = null;
+        }
+        break;
+      default:
+        dangling = null;
+        break;
+    }
+  }
+  return dangling;
+}
+function supersedeLivePublicationInPendingState(pending, reason) {
+  const publication = pending.prFeedbackPublication;
+  const active = publication?.active;
+  const live = pending.prFeedbackReadyToPublish != null || active?.state === "armed" || active?.state === "push_in_flight";
+  if (!live)
+    return { state: pending, invalidationEvent: null };
+  const now = isoNow();
+  const attempts = (publication?.attempts ?? []).map((attempt) => attempt.result ? attempt : {
+    ...attempt,
+    result: {
+      outcome: "uncertain",
+      exitStatus: "not-observed",
+      diagnostic: `finalized by publication invalidation (${reason})`,
+      postPush: { localHead: null, observedRemoteHead: null },
+      completedAt: now
+    }
+  });
+  const invalidatedActive = active ? {
+    ...active,
+    state: "invalidated",
+    invalidatedAt: now,
+    invalidationReason: reason
+  } : undefined;
+  const nextState = {
+    ...pending,
+    updatedAt: now,
+    prFeedbackReadyToPublish: undefined,
+    prFeedbackVerifications: undefined,
+    prFeedbackGateBatches: undefined,
+    prFeedbackScopes: undefined,
+    prFeedbackPublication: active ? nextPublicationContainer(publication, invalidatedActive, [], attempts) : pending.prFeedbackPublication
+  };
+  const invalidationEvent = active ? {
+    type: "pr_feedback_publication_invalidated",
+    sessionID: pending.sessionID,
+    generation: active.generation,
+    reason,
+    previousState: active.state,
+    drift: null,
+    revisionDigest: active.revisionDigest,
+    localHead: active.localHead,
+    remoteName: active.remoteName,
+    remoteBranchRef: active.remoteBranchRef,
+    supersededBatchIds: active.evidence.batches.map((b) => b.batchId)
+  } : null;
+  return { state: nextState, invalidationEvent };
+}
+function parseExactBoundPushIntent(command, armed) {
+  if (hasUnsafeShellControlSyntax(command)) {
+    return { ok: false, reason: "shell-syntax" };
+  }
+  if (!armed.remoteBranchRef.startsWith("refs/heads/")) {
+    return { ok: false, reason: "unbound-target" };
+  }
+  const tokens = command.trim().split(/\s+/);
+  if (tokens.length !== 4 || tokens[0].toLowerCase() !== "git" || tokens[1].toLowerCase() !== "push" || tokens.some((token) => /["'\\]/.test(token))) {
+    return { ok: false, reason: "token-shape" };
+  }
+  const [remoteToken, refspecToken] = [tokens[2], tokens[3]];
+  if (remoteToken.startsWith("-") || refspecToken.startsWith("-")) {
+    return { ok: false, reason: "flag-or-option" };
+  }
+  if (/[:@]/.test(remoteToken) || remoteToken.includes("://")) {
+    return { ok: false, reason: "credential-bearing-remote" };
+  }
+  const refspecParts = refspecToken.split(":");
+  if (refspecParts.length !== 2) {
+    return {
+      ok: false,
+      reason: refspecParts.length > 2 ? "token-shape" : "invalid-dest-ref"
+    };
+  }
+  const [sourceToken, destToken] = refspecParts;
+  if (!destToken.startsWith("refs/heads/") || destToken === "refs/heads/") {
+    return { ok: false, reason: "invalid-dest-ref" };
+  }
+  if (sourceToken === "") {
+    return { ok: false, reason: "delete-refspec" };
+  }
+  if (sourceToken.includes("*") || destToken.includes("*")) {
+    return { ok: false, reason: "wildcard-refspec" };
+  }
+  if (remoteToken !== armed.remoteName) {
+    return { ok: false, reason: "remote-mismatch" };
+  }
+  if (sourceToken !== armed.localHead) {
+    return { ok: false, reason: "source-mismatch" };
+  }
+  if (destToken !== armed.remoteBranchRef) {
+    return { ok: false, reason: "branch-mismatch" };
+  }
+  const intent = {
+    remote: remoteToken,
+    sourceSha: sourceToken,
+    destRef: destToken
+  };
+  return {
+    ok: true,
+    intent,
+    digest: createHash7("sha256").update(JSON.stringify(intent), "utf8").digest("hex")
+  };
+}
+async function admitPrFeedbackPushAttempt(directory, sessionID, callID, intent, intentDigest) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  await withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    const active = state?.prFeedbackPublication?.active;
+    if (!state || state.mode !== "PR_FEEDBACK" || !active) {
+      throw new Error("BLOCKED: PR_FEEDBACK push admission requires an armed publication generation");
+    }
+    if (active.state !== "armed") {
+      throw new Error(`BLOCKED: PR_FEEDBACK push admission requires the armed state, not ${active.state}`);
+    }
+    const check = await checkPublicationIdentity(directory, state, active);
+    if (check.kind === "unresolvable") {
+      throw new Error(`BLOCKED: PR_FEEDBACK could not verify the armed publication identity component "${check.component}" (${check.detail}); the push was not admitted`);
+    }
+    if (check.kind === "drift") {
+      const invalidation = await applyPublicationInvalidationWhileLocked(directory, state, `drift:${check.component}`, { drift: check });
+      throw new Error(`BLOCKED: PR_FEEDBACK publication generation ${invalidation.generation.generation} was INVALIDATED because approved content identity drifted (${check.component}: ${check.detail}). Rerun Stage A and every independent gate, then arm a fresh generation with complete_pr_workflow.`);
+    }
+    const now = isoNow();
+    if (intent.remote !== active.remoteName || intent.sourceSha !== active.localHead || intent.destRef !== active.remoteBranchRef) {
+      throw new Error("BLOCKED: PR_FEEDBACK push intent does not match the armed publication generation under the state lock; the push was not admitted");
+    }
+    const observedRemoteHead = await _test_exports2.resolveExactRemoteBranchHeadAsync(directory, active.remoteName, active.remoteBranchRef);
+    const localHead = (await _test_exports2.resolveCurrentGitHeadAsync(directory))?.trim();
+    const worktreeClean = await _test_exports2.resolveIsWorkingTreeCleanAsync(directory);
+    const baseAttempt = {
+      attemptId: randomUUID2(),
+      generation: active.generation,
+      sessionID: state.sessionID,
+      callID,
+      intentDigest,
+      intent: {
+        remote: intent.remote,
+        sourceSha: intent.sourceSha,
+        destRef: intent.destRef
+      },
+      prePush: {
+        localHead: active.localHead,
+        worktreeClean: worktreeClean === true,
+        remoteName: active.remoteName,
+        remoteBranchRef: active.remoteBranchRef,
+        observedRemoteHead
+      },
+      startedAt: now
+    };
+    const remoteAlreadyAtApprovedHead = observedRemoteHead?.toLowerCase() === active.localHead.toLowerCase();
+    if (remoteAlreadyAtApprovedHead) {
+      const attempt = {
+        ...baseAttempt,
+        result: {
+          outcome: "completed",
+          exitStatus: "not-observed",
+          diagnostic: "remote branch already observed at the approved head (no-op push)",
+          postPush: {
+            localHead: localHead ?? null,
+            observedRemoteHead: observedRemoteHead ?? null
+          },
+          completedAt: now
+        }
+      };
+      const nextState2 = {
+        ...state,
+        updatedAt: now,
+        prFeedbackPublication: nextPublicationContainer(state.prFeedbackPublication, active, [], [...state.prFeedbackPublication?.attempts ?? [], attempt])
+      };
+      await writeStateWhileLocked(directory, nextState2);
+      appendPublicationEvent(directory, {
+        type: "pr_feedback_push_attempt_result",
+        sessionID: state.sessionID,
+        generation: active.generation,
+        outcome: "completed",
+        by: "no-op-observation",
+        observedRemoteHead
+      });
+      return;
+    }
+    const nextState = {
+      ...state,
+      updatedAt: now,
+      prFeedbackPublication: nextPublicationContainer(state.prFeedbackPublication, { ...active, state: "push_in_flight" }, [], [...state.prFeedbackPublication?.attempts ?? [], baseAttempt])
+    };
+    await writeStateWhileLocked(directory, nextState);
+    appendPublicationEvent(directory, {
+      type: "pr_feedback_push_attempt_started",
+      sessionID: state.sessionID,
+      generation: active.generation,
+      intentDigest,
+      intent,
+      observedRemoteHead
+    });
+  });
+  const publication = await readPrWorkflowGateState(directory, normalizedSessionID);
+  const attempts = publication?.prFeedbackPublication?.attempts ?? [];
+  const last = attempts[attempts.length - 1];
+  return last?.result?.outcome === "completed" ? { kind: "already-published-remotely" } : { kind: "started" };
+}
+function describeToolOutputText(output) {
+  if (typeof output === "string")
+    return output;
+  if (output && typeof output === "object" && "output" in output && typeof output.output === "string") {
+    return output.output;
+  }
+  try {
+    return JSON.stringify(output) ?? "";
+  } catch {
+    return "";
+  }
+}
+async function recordPrFeedbackPushAttemptResult(directory, input, command, output) {
+  const normalizedTool = (normalizeToolName(input.tool) ?? input.tool).toLowerCase();
+  if (normalizedTool !== "bash" && normalizedTool !== "shell")
+    return;
+  if (!/^\s*git\s+push/i.test(command))
+    return;
+  const normalizedSessionID = normalizeSessionID(input.sessionID);
+  await withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+    const publication = state?.prFeedbackPublication;
+    const active = publication?.active;
+    if (!state || !publication || !active || active.state !== "push_in_flight" || !input.callID) {
+      return;
+    }
+    const attemptIndex = publication.attempts.findIndex((attempt) => !attempt.result && attempt.callID === input.callID);
+    if (attemptIndex < 0)
+      return;
+    const now = isoNow();
+    const localHead = (await _test_exports2.resolveCurrentGitHeadAsync(directory))?.trim();
+    const observedRemoteHead = await _test_exports2.resolveExactRemoteBranchHeadAsync(directory, active.remoteName, active.remoteBranchRef);
+    const remoteVerifiedAtApprovedHead = observedRemoteHead?.toLowerCase() === active.localHead.toLowerCase();
+    const metadataExit = output?.metadata?.exitCode;
+    const exitStatus = typeof metadataExit === "number" && Number.isInteger(metadataExit) ? metadataExit : "not-observed";
+    let outcome;
+    if (remoteVerifiedAtApprovedHead) {
+      outcome = "completed";
+    } else if (exitStatus !== "not-observed" && exitStatus !== 0) {
+      outcome = "rejected";
+    } else {
+      outcome = "uncertain";
+    }
+    const diagnostic = boundPublicationDiagnostic(remoteVerifiedAtApprovedHead ? `push result observed; remote branch verified at the approved head${exitStatus !== "not-observed" && exitStatus !== 0 ? ` (shell reported nonzero exit ${exitStatus}; the verified remote head is the publication truth)` : ""}` : `push result observed without remote verification at the approved head; exit status ${exitStatus === "not-observed" ? "not observed" : exitStatus}; output: ${describeToolOutputText(output)}`);
+    const attempts = publication.attempts.map((attempt, index) => index === attemptIndex ? {
+      ...attempt,
+      result: {
+        outcome,
+        exitStatus,
+        diagnostic,
+        postPush: {
+          localHead: localHead ?? null,
+          observedRemoteHead: observedRemoteHead ?? null
+        },
+        completedAt: now
+      }
+    } : attempt);
+    const nextState = {
+      ...state,
+      updatedAt: now,
+      prFeedbackPublication: nextPublicationContainer(publication, { ...active, state: "armed" }, [], attempts)
+    };
+    await writeStateWhileLocked(directory, nextState);
+    appendPublicationEvent(directory, {
+      type: "pr_feedback_push_attempt_result",
+      sessionID: state.sessionID,
+      generation: active.generation,
+      outcome,
+      exitStatus,
+      by: "tool-after",
+      observedRemoteHead
+    });
+  });
+}
+async function cancelPrFeedbackPublication(directory, sessionID, reason) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  let nextRevision = null;
+  let cancelledGeneration = null;
+  let cancelledAttemptsFinalized = 0;
+  try {
+    await withSessionStateMutation(directory, normalizedSessionID, async () => {
+      const state = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+      const publication = state?.prFeedbackPublication;
+      const active = publication?.active;
+      if (!state || !publication || !active) {
+        return;
+      }
+      if (active.state !== "armed" && active.state !== "push_in_flight" && active.state !== "invalidated") {
+        return;
+      }
+      const now = isoNow();
+      const observedRemoteHead = await _test_exports2.resolveExactRemoteBranchHeadAsync(directory, active.remoteName, active.remoteBranchRef);
+      const attempts = publication.attempts.map((attempt) => attempt.result ? attempt : {
+        ...attempt,
+        result: {
+          outcome: "cancelled",
+          exitStatus: "not-observed",
+          diagnostic: "finalized by publication cancellation",
+          postPush: { localHead: null, observedRemoteHead },
+          completedAt: now
+        }
+      });
+      const cancelled = {
+        ...active,
+        state: "cancelled_without_publication",
+        cancelledAt: now,
+        invalidationReason: active.invalidationReason ?? `cancelled:${reason}`
+      };
+      const nextState = {
+        ...state,
+        updatedAt: now,
+        prFeedbackReadyToPublish: undefined,
+        prFeedbackPublication: nextPublicationContainer(publication, cancelled, [], attempts)
+      };
+      const written = await writeStateWhileLocked(directory, nextState);
+      nextRevision = written.revision;
+      cancelledGeneration = active.generation;
+      cancelledAttemptsFinalized = attempts.filter((attempt) => attempt.result?.outcome === "cancelled").length;
+    });
+  } catch {}
+  appendPublicationEvent(directory, {
+    type: "pr_feedback_publication_cancelled",
+    sessionID: normalizedSessionID,
+    ...cancelledGeneration !== null ? { generation: cancelledGeneration } : {},
+    reason,
+    ...cancelledAttemptsFinalized > 0 ? { attemptsFinalized: cancelledAttemptsFinalized } : {}
+  });
+  return nextRevision;
+}
 var PR_REVIEW_HANDOFF_RELATIVE_PATH_PATTERN = /^pr-review\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/feedback-handoff\.json$/;
 var PR_REVIEW_FEEDBACK_CONSENT_MAX_BYTES = 64 * 1024;
 var PR_REVIEW_RUN_RESERVATION_MAX_BYTES = 16 * 1024;
@@ -10281,7 +11398,7 @@ function prReviewFeedbackConsentRelativePath(runId) {
   return `pr-review/${runId}/feedback-consent.json`;
 }
 function hashPrReviewFindingIds(ids) {
-  return createHash6("sha256").update([...new Set(ids)].sort().join("\x00"), "utf8").digest("hex");
+  return createHash7("sha256").update([...new Set(ids)].sort().join("\x00"), "utf8").digest("hex");
 }
 async function readPrReviewRunReservation(directory, runId) {
   try {
@@ -10353,7 +11470,7 @@ async function readPrReviewFeedbackHandoffArtifact(directory, relativePath) {
   }
   return {
     artifact: parsed.data,
-    digest: createHash6("sha256").update(raw, "utf8").digest("hex")
+    digest: createHash7("sha256").update(raw, "utf8").digest("hex")
   };
 }
 var PrReviewFindingProjectionSchema = exports_external.object({
@@ -10414,7 +11531,7 @@ function assertMatchingPrReviewFeedbackConsent(record, input) {
   }
 }
 function workflowIdentity(state) {
-  return state.workflowInstanceId ?? `legacy-${createHash6("sha256").update(`${state.sessionID}\x00${state.mode}\x00${state.activatedAt}`).digest("hex").slice(0, 32)}`;
+  return state.workflowInstanceId ?? `legacy-${createHash7("sha256").update(`${state.sessionID}\x00${state.mode}\x00${state.activatedAt}`).digest("hex").slice(0, 32)}`;
 }
 function sameHandoffIds(left, right) {
   const normalizedLeft = [...new Set(left)].sort();
@@ -10687,6 +11804,21 @@ var _test_exports2 = {
   resolveCurrentUpstreamPushTarget,
   resolveCurrentUpstreamPushTargetAsync,
   resolveCurrentUpstreamRemoteRef,
+  resolveCurrentLocalHeadRefAsync,
+  resolveRemoteUrlIdentity,
+  resolveRemoteUrlIdentityAsync,
+  parseExactBoundPushIntent,
+  admitPrFeedbackPushAttempt,
+  recordPrFeedbackPushAttemptResult,
+  reconcileForeignInFlightAttempt,
+  ensurePublicationGenerationCurrent,
+  invalidatePublicationGeneration,
+  invalidatePrFeedbackPublication,
+  cancelPrFeedbackPublication,
+  buildPublicationEvidenceJoin,
+  nextPublicationContainer,
+  supersedeLivePublicationInPendingState,
+  describePrWorkflowPublicationSection,
   resolveExactRemoteBranchHead,
   resolveExactRemoteBranchHeadAsync,
   resolveCommitCountSince,
@@ -10778,6 +11910,7 @@ var PR_REVIEW_CONTROLLER_TOOLS = new Set([
   "write_pr_review_trigger_eval"
 ]);
 var PR_FEEDBACK_CONTROLLER_TOOLS = new Set([
+  "invalidate_pr_feedback_publication",
   "prepare_pr_feedback_scope",
   "run_pr_feedback_stage_a"
 ]);
@@ -10936,6 +12069,16 @@ function normalizePrHeadSha(prHeadSha) {
   }
   return normalized;
 }
+async function currentPrFeedbackRevisionDigest(directory, state) {
+  if (!state.prHeadSha) {
+    throw new Error("BLOCKED: PR_FEEDBACK revision binding requires pr_head_sha");
+  }
+  const resolved = await resolvePrWorkflowRevisionDigestForGate(directory, state.prHeadSha);
+  if (!resolved.ok) {
+    throw new Error("BLOCKED: PR_FEEDBACK could not compute a bounded current-revision digest" + ` for pr_head_sha "${state.prHeadSha}"; ${describePrWorkflowRevisionDigestFailure(resolved)}`);
+  }
+  return resolved.digest;
+}
 function describePrWorkflowRevisionDigestFailure(failure) {
   const detail = failure.detail ? ` (${failure.detail})` : "";
   switch (failure.reason) {
@@ -12016,7 +13159,7 @@ function validateReviewerVerdictFields(fields) {
   return parsed.success ? [...parsed.data] : null;
 }
 function reviewerVerdictRowDigest(fields) {
-  return createHash6("sha256").update(fields.join("\x00")).digest("hex");
+  return createHash7("sha256").update(fields.join("\x00")).digest("hex");
 }
 function parseLaneItemVerdicts(text, itemIds, phase, reviewerClaims) {
   return parsePrReviewVerdictRows(text, itemIds, phase, reviewerClaims).parsed;
@@ -12605,10 +13748,13 @@ async function readPrWorkflowGateStateForRecovery(directory, sessionID) {
   const salvagedUpdatedAt = exports_external.string().min(1).safeParse(rawRecord.updatedAt);
   const armedKeyPresent = rawRecord.prFeedbackReadyToPublish !== undefined;
   const salvagedArmed = PrFeedbackReadyToPublishRecordSchema.safeParse(rawRecord.prFeedbackReadyToPublish);
+  const publicationKeyPresent = rawRecord.prFeedbackPublication !== undefined;
+  const salvagedPublication = PrFeedbackPublicationStateSchema.safeParse(rawRecord.prFeedbackPublication);
+  const publicationShapeUnreadable = publicationKeyPresent && !salvagedPublication.success;
   const salvagedCheckoutRecovery = PrWorkflowCheckoutRecoveryRecordSchema.safeParse(rawRecord.checkoutRecovery);
-  const armedShapeUnreadable = armedKeyPresent && !salvagedArmed.success;
+  const armedShapeUnreadable = armedKeyPresent && !salvagedArmed.success || publicationShapeUnreadable;
   const schemaErrors = parsed.error.issues.slice(0, MAX_SALVAGED_SCHEMA_ERRORS).map((issue) => boundSalvagedSchemaError(`${issue.path.join(".") || "(root)"}: ${issue.message}`));
-  const disclosure = `DEGRADED: PR workflow gate state for session "${normalizedSessionID}" failed schema validation ` + `and was SALVAGED for recovery only (abort/status; write and completion paths still refuse it). ` + `Schema errors: ${schemaErrors.join("; ")}.` + (salvagedRevision.success ? "" : " state revision unsalvageable.") + (armedShapeUnreadable ? " prFeedbackReadyToPublish is present but unreadable; treated as ARMED (fail-closed)." : "");
+  const disclosure = `DEGRADED: PR workflow gate state for session "${normalizedSessionID}" failed schema validation ` + `and was SALVAGED for recovery only (abort/status; write and completion paths still refuse it). ` + `Schema errors: ${schemaErrors.join("; ")}.` + (salvagedRevision.success ? "" : " state revision unsalvageable.") + (armedShapeUnreadable ? " prFeedbackReadyToPublish is present but unreadable; treated as ARMED (fail-closed)." : "") + (publicationShapeUnreadable ? " prFeedbackPublication is present but unreadable; treated as ARMED (fail-closed)." : "");
   return {
     state: {
       schemaVersion: GATE_SCHEMA_VERSION,
@@ -12619,6 +13765,7 @@ async function readPrWorkflowGateStateForRecovery(directory, sessionID) {
       updatedAt: salvagedUpdatedAt.success ? salvagedUpdatedAt.data : isoNow(),
       ...salvagedHead.success ? { prHeadSha: salvagedHead.data } : {},
       ...salvagedArmed.success ? { prFeedbackReadyToPublish: salvagedArmed.data } : {},
+      ...salvagedPublication.success ? { prFeedbackPublication: salvagedPublication.data } : {},
       ...salvagedCheckoutRecovery.success ? { checkoutRecovery: salvagedCheckoutRecovery.data } : {}
     },
     salvaged: true,
@@ -12659,7 +13806,7 @@ function workflowGateStateRelativePath(sessionID) {
 function prWorkflowSessionFileStem(sessionID) {
   const normalized = normalizeSessionID(sessionID);
   const slug = normalized.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80) || "session";
-  const digest2 = createHash6("sha256").update(normalized).digest("hex").slice(0, 12);
+  const digest2 = createHash7("sha256").update(normalized).digest("hex").slice(0, 12);
   return `${slug}-${digest2}`;
 }
 function normalizeSessionID(sessionID) {
@@ -12829,6 +13976,14 @@ var USAGE = [
   "Refuses while the workflow is armed for publication (call complete_pr_workflow",
   "instead) or while PR workflow lanes are still in flight (collect their results first).",
   "",
+  "Armed publication (issue #2108): to CHANGE approved content after arming, the agent",
+  "should use the invalidate_pr_feedback_publication tool (audited invalidation; the",
+  "full Stage A + independent-gate ladder re-runs). To CANCEL an armed PR_FEEDBACK",
+  'workflow without publication, the agent tool supports kind "cancel-publication" with',
+  "cancel_publication: true and a reason \u2014 the publication generation is recorded as",
+  "cancelled_without_publication (terminal; never grants push authority) before the gate",
+  "clears. A plain (recovery or force) abort never clears an armed window.",
+  "",
   "Lane liveness (issue #2251): a lane past the 30-minute staleness horizon whose",
   "session the host still reports as busy or retrying is RETAINED rather than settled,",
   "and keeps blocking every exit. Because nothing ever makes such a lane go idle on a",
@@ -12881,11 +14036,11 @@ ${USAGE}`;
 }
 
 // src/services/spec-drift-recovery.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { mkdir as mkdir4, readFile as readFile4, unlink as unlink2 } from "fs/promises";
 import { dirname as dirname10 } from "path";
 var SPEC_DRIFT_RECOVERY_AGENT = "spec-drift-recovery";
-var _internals16 = {
+var _internals17 = {
   appendEvent,
   assertProjectRoot,
   bunWrite,
@@ -12910,7 +14065,7 @@ function now() {
   return new Date().toISOString();
 }
 function sha2562(text) {
-  return createHash7("sha256").update(text, "utf-8").digest("hex");
+  return createHash8("sha256").update(text, "utf-8").digest("hex");
 }
 function parseMarker(raw) {
   try {
@@ -12969,22 +14124,22 @@ async function writeWal3(walPath, wal) {
 }
 async function verifySnapshot(snapshotPath, currentSpec) {
   if (!currentSpec) {
-    await _internals16.unlinkIfExists(snapshotPath);
-    const stillExists = await _internals16.readFileText(snapshotPath) !== null;
+    await _internals17.unlinkIfExists(snapshotPath);
+    const stillExists = await _internals17.readFileText(snapshotPath) !== null;
     if (stillExists) {
       throw new Error("spec snapshot verification failed: snapshot still exists after delete");
     }
     return;
   }
   await atomicWriteFile(snapshotPath, currentSpec.content);
-  const written = await _internals16.readFileText(snapshotPath);
+  const written = await _internals17.readFileText(snapshotPath);
   if (written !== currentSpec.content) {
     throw new Error("spec snapshot verification failed: snapshot content does not match effective spec");
   }
 }
 async function ensureSnapshotEvent(directory, plan, transitionId) {
-  const ledgerPath = _internals16.validateSwarmPath(directory, "plan-ledger.jsonl");
-  const raw = await _internals16.readFileText(ledgerPath);
+  const ledgerPath = _internals17.validateSwarmPath(directory, "plan-ledger.jsonl");
+  const raw = await _internals17.readFileText(ledgerPath);
   if (raw !== null) {
     for (const line of raw.split(`
 `)) {
@@ -13004,17 +14159,17 @@ async function ensureSnapshotEvent(directory, plan, transitionId) {
       }
     }
   }
-  await _internals16.takeSnapshotEvent(directory, plan, {
+  await _internals17.takeSnapshotEvent(directory, plan, {
     source: "spec_drift_recovery",
     approvalMetadata: { specDriftTransitionId: transitionId }
   });
 }
 async function appendEvent(directory, event) {
-  const existing = await _internals16.verifyEventPresence(directory, event.type, event.transitionId);
+  const existing = await _internals17.verifyEventPresence(directory, event.type, event.transitionId);
   if (existing)
     return;
   appendCoreEventSync(directory, { ...event }, { dedupeOnAuthorityKey: true });
-  const verified = await _internals16.verifyEventPresence(directory, event.type, event.transitionId);
+  const verified = await _internals17.verifyEventPresence(directory, event.type, event.transitionId);
   if (!verified) {
     throw new Error(`spec drift audit verification failed for transition ${event.transitionId}`);
   }
@@ -13036,7 +14191,7 @@ function buildRecoveryEvent(args) {
   if (args.mode === "acknowledge") {
     return {
       type: "spec_drift_acknowledged",
-      timestamp: _internals16.now(),
+      timestamp: _internals17.now(),
       phase: args.phase,
       planTitle: args.planTitle,
       acknowledgedBy: args.actor === "spec_write" ? "unknown" : args.actor,
@@ -13048,7 +14203,7 @@ function buildRecoveryEvent(args) {
   }
   return {
     type: "spec_drift_repaired",
-    timestamp: _internals16.now(),
+    timestamp: _internals17.now(),
     phase: args.phase,
     planTitle: args.planTitle,
     repairedBy: args.actor,
@@ -13059,11 +14214,11 @@ function buildRecoveryEvent(args) {
   };
 }
 async function reconcileSpecDrift(directory, options) {
-  _internals16.assertProjectRoot(directory);
-  const markerPath = _internals16.validateSwarmPath(directory, "spec-staleness.json");
-  const walPath = _internals16.validateSwarmPath(directory, "spec-drift-recovery.json");
-  const snapshotPath = _internals16.validateSwarmPath(directory, "spec-snapshot.md");
-  const markerMaybe = await _internals16.readFileText(markerPath);
+  _internals17.assertProjectRoot(directory);
+  const markerPath = _internals17.validateSwarmPath(directory, "spec-staleness.json");
+  const walPath = _internals17.validateSwarmPath(directory, "spec-drift-recovery.json");
+  const snapshotPath = _internals17.validateSwarmPath(directory, "spec-snapshot.md");
+  const markerMaybe = await _internals17.readFileText(markerPath);
   if (markerMaybe === null) {
     return {
       status: "no_marker",
@@ -13071,7 +14226,7 @@ async function reconcileSpecDrift(directory, options) {
       message: "No spec drift detected."
     };
   }
-  const specLockResult = options.specLockAlreadyHeld ? null : await _internals16.tryAcquireLock(directory, "spec.md", SPEC_DRIFT_RECOVERY_AGENT, `spec-${options.mode}-${Date.now()}`);
+  const specLockResult = options.specLockAlreadyHeld ? null : await _internals17.tryAcquireLock(directory, "spec.md", SPEC_DRIFT_RECOVERY_AGENT, `spec-${options.mode}-${Date.now()}`);
   if (specLockResult && !specLockResult.acquired) {
     return {
       status: "retry_later",
@@ -13081,7 +14236,7 @@ async function reconcileSpecDrift(directory, options) {
   }
   let lockResult;
   try {
-    lockResult = await _internals16.tryAcquireLock(directory, "plan.json", SPEC_DRIFT_RECOVERY_AGENT, `${options.mode}-${Date.now()}`);
+    lockResult = await _internals17.tryAcquireLock(directory, "plan.json", SPEC_DRIFT_RECOVERY_AGENT, `${options.mode}-${Date.now()}`);
   } catch (error2) {
     if (specLockResult?.acquired && specLockResult.lock._release) {
       await specLockResult.lock._release().catch(() => {});
@@ -13107,7 +14262,7 @@ async function reconcileSpecDrift(directory, options) {
   let errorNewHash;
   try {
     try {
-      const authoritativeMarkerRaw = await _internals16.readFileText(markerPath);
+      const authoritativeMarkerRaw = await _internals17.readFileText(markerPath);
       if (authoritativeMarkerRaw === null) {
         return {
           status: "no_marker",
@@ -13115,14 +14270,14 @@ async function reconcileSpecDrift(directory, options) {
           message: "No spec drift detected."
         };
       }
-      const marker = _internals16.parseMarker(authoritativeMarkerRaw);
+      const marker = _internals17.parseMarker(authoritativeMarkerRaw);
       if (!marker) {
         return buildCorruptMarkerResult(options.mode);
       }
       errorMarker = marker;
       const markerHash = sha2562(authoritativeMarkerRaw);
-      const existingWalRaw = await _internals16.readFileText(walPath);
-      const existingWal = existingWalRaw === null ? null : _internals16.parseWal(existingWalRaw);
+      const existingWalRaw = await _internals17.readFileText(walPath);
+      const existingWal = existingWalRaw === null ? null : _internals17.parseWal(existingWalRaw);
       if (existingWalRaw !== null && !existingWal) {
         return {
           status: "failed",
@@ -13132,7 +14287,7 @@ async function reconcileSpecDrift(directory, options) {
           planTitle: marker.planTitle
         };
       }
-      const currentSpec = _internals16.readEffectiveSpecSync(directory);
+      const currentSpec = _internals17.readEffectiveSpecSync(directory);
       const proposedNewHash = currentSpec?.hash ?? null;
       const proposedTransitionId = buildTransitionId(options.mode, markerHash, marker.specHash_plan, proposedNewHash);
       const proposedWal = {
@@ -13147,7 +14302,7 @@ async function reconcileSpecDrift(directory, options) {
         newHash: proposedNewHash,
         specContent: currentSpec?.content ?? null,
         actor: options.actor,
-        recordedAt: _internals16.now()
+        recordedAt: _internals17.now()
       };
       const markerReplacedDuringPrepared = existingWal?.state === "PREPARED" && existingWal.markerHash !== markerHash;
       const wal = existingWal?.state === "PREPARED" || existingWal?.markerHash === markerHash ? existingWal : proposedWal;
@@ -13156,12 +14311,12 @@ async function reconcileSpecDrift(directory, options) {
       errorTransitionId = transitionId;
       errorNewHash = newHash;
       if (wal === proposedWal) {
-        await _internals16.writeWal(walPath, wal);
+        await _internals17.writeWal(walPath, wal);
       }
       if (wal.newHash === null !== (wal.specContent === null) || wal.specContent !== null && sha2562(wal.specContent) !== wal.newHash) {
         throw new Error(`Spec drift recovery WAL ${transitionId} has inconsistent captured spec content`);
       }
-      let plan = await _internals16.loadPlanJsonOnly(directory);
+      let plan = await _internals17.loadPlanJsonOnly(directory);
       if (!plan) {
         return {
           status: "failed",
@@ -13192,13 +14347,13 @@ async function reconcileSpecDrift(directory, options) {
         }
         if (planMatchesOld) {
           plan.specHash = newHash ?? undefined;
-          await _internals16.savePlan(directory, plan, {
+          await _internals17.savePlan(directory, plan, {
             planLockAlreadyHeld: true
           });
-          plan = await _internals16.loadPlanJsonOnly(directory) ?? plan;
+          plan = await _internals17.loadPlanJsonOnly(directory) ?? plan;
         }
-        await _internals16.ensureSnapshotEvent(directory, plan, transitionId);
-        await _internals16.verifySnapshot(snapshotPath, wal.specContent === null ? null : { content: wal.specContent });
+        await _internals17.ensureSnapshotEvent(directory, plan, transitionId);
+        await _internals17.verifySnapshot(snapshotPath, wal.specContent === null ? null : { content: wal.specContent });
         const event = buildRecoveryEvent({
           mode: wal.mode,
           actor: wal.actor,
@@ -13209,15 +14364,15 @@ async function reconcileSpecDrift(directory, options) {
           previousHash: wal.previousHash,
           transitionId
         });
-        await _internals16.appendEvent(directory, event);
-        await _internals16.writeWal(walPath, { ...wal, state: "COMMITTED" });
+        await _internals17.appendEvent(directory, event);
+        await _internals17.writeWal(walPath, { ...wal, state: "COMMITTED" });
       }
       if (markerReplacedDuringPrepared) {
         const preservedMarker = {
           ...marker,
           specHash_plan: newHash,
           reason: `prior prepared drift recovery committed before this marker: ${marker.reason}`,
-          timestamp: _internals16.now()
+          timestamp: _internals17.now()
         };
         await atomicWriteFile(markerPath, `${JSON.stringify(preservedMarker, null, 2)}
 `);
@@ -13232,7 +14387,7 @@ async function reconcileSpecDrift(directory, options) {
           transitionId
         };
       }
-      const latestSpec = _internals16.readEffectiveSpecSync(directory);
+      const latestSpec = _internals17.readEffectiveSpecSync(directory);
       if ((latestSpec?.hash ?? null) !== newHash) {
         const refreshedMarker = {
           planTitle: wal.planTitle,
@@ -13240,7 +14395,7 @@ async function reconcileSpecDrift(directory, options) {
           specHash_plan: newHash,
           specHash_current: latestSpec?.hash ?? null,
           reason: "spec changed while drift recovery was committing",
-          timestamp: _internals16.now()
+          timestamp: _internals17.now()
         };
         await atomicWriteFile(markerPath, `${JSON.stringify(refreshedMarker, null, 2)}
 `);
@@ -13256,8 +14411,8 @@ async function reconcileSpecDrift(directory, options) {
         };
       }
       try {
-        await _internals16.unlinkIfExists(markerPath);
-        _internals16.invalidateCachedArtifact(markerPath);
+        await _internals17.unlinkIfExists(markerPath);
+        _internals17.invalidateCachedArtifact(markerPath);
       } catch (error2) {
         return {
           status: "cleanup_pending",
@@ -13442,7 +14597,7 @@ ${USAGE2}`;
 
 // src/security/write-authority.ts
 import { AsyncLocalStorage } from "async_hooks";
-import { createHash as createHash8, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import * as path13 from "path";
 var DEFAULT_TTL_MS = 30 * 60 * 1000;
@@ -13549,7 +14704,7 @@ function leastPrivilege(left, right) {
   return ORIGIN_RANK[left.origin] <= ORIGIN_RANK[right.origin] ? left : right;
 }
 function computeWriteApprovalHash(input) {
-  return createHash8("sha256").update(stableSerialize(input)).digest("hex");
+  return createHash9("sha256").update(stableSerialize(input)).digest("hex");
 }
 function getCurrentWriteAuthority() {
   const extent = authorityStore.getStore();
@@ -13754,7 +14909,7 @@ ${USAGE3}`;
 
 // src/commands/archive.ts
 init_loader();
-var _internals17 = {
+var _internals18 = {
   now: () => new Date
 };
 function artifactLabel(artifact) {
@@ -13810,7 +14965,7 @@ async function handleArchiveCommand(directory, args) {
   const report = await archiveEvidence(directory, maxAgeDays, maxBundles, {
     report: true,
     dryRun,
-    now: _internals17.now(),
+    now: _internals18.now(),
     cacheMaxBytes,
     cacheMaxRecords
   });
@@ -15097,7 +16252,7 @@ var SHELL_METACHARACTERS = /[;|&$`(){}<>!'"]/;
 var SAFE_LABEL_PATTERN = /^[a-zA-Z0-9_ -]+$/;
 var CONTROL_CHAR_PATTERN = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/;
 var NON_ASCII_PATTERN = /[^\x20-\x7E]/;
-var _internals18 = {
+var _internals19 = {
   tryAcquireLock,
   loadPlan,
   gitExec,
@@ -15240,11 +16395,11 @@ function upsertTaskCompletionCheckpointEntry(directory, log2, entry, maxCheckpoi
   }
 }
 function stageAllExcludingSwarm(directory) {
-  _internals18.gitExec(["add", "--all", "--", ...NON_SWARM_COMMIT_PATHSPEC], directory);
+  _internals19.gitExec(["add", "--all", "--", ...NON_SWARM_COMMIT_PATHSPEC], directory);
 }
 function gitExec(args, cwd) {
   for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
-    const result = child_process.spawnSync(_internals18.resolveGitExecutable(), args, {
+    const result = child_process.spawnSync(_internals19.resolveGitExecutable(), args, {
       cwd,
       encoding: "utf-8",
       timeout: GIT_TIMEOUT_MS2,
@@ -15301,7 +16456,7 @@ function isGitRepo2(directory) {
   }
 }
 function findCommitByExactSubject(directory, subject) {
-  const output = _internals18.gitExec([
+  const output = _internals19.gitExec([
     "log",
     "HEAD",
     "--format=%H%x00%s",
@@ -15331,7 +16486,7 @@ async function withTaskCompletionLocksResult(input) {
     attempts++;
     let planLockResult;
     try {
-      planLockResult = await _internals18.tryAcquireLock(input.directory, PLAN_LOCK_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-plan-${input.taskId}`);
+      planLockResult = await _internals19.tryAcquireLock(input.directory, PLAN_LOCK_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-plan-${input.taskId}`);
     } catch (error2) {
       if (input.onFailure) {
         return input.onFailure(error2);
@@ -15345,13 +16500,13 @@ async function withTaskCompletionLocksResult(input) {
       if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
         break;
       }
-      await _internals18.sleep(CHECKPOINT_LOCK_DELAY_MS);
+      await _internals19.sleep(CHECKPOINT_LOCK_DELAY_MS);
       continue;
     }
     try {
       let checkpointLockResult;
       try {
-        checkpointLockResult = await _internals18.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-checkpoint-${input.taskId}`);
+        checkpointLockResult = await _internals19.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, `save-task-completion-checkpoint-${input.taskId}`);
       } catch (error2) {
         if (input.onFailure) {
           return input.onFailure(error2);
@@ -15365,7 +16520,7 @@ async function withTaskCompletionLocksResult(input) {
         if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
           break;
         }
-        await _internals18.sleep(CHECKPOINT_LOCK_DELAY_MS);
+        await _internals19.sleep(CHECKPOINT_LOCK_DELAY_MS);
         continue;
       }
       try {
@@ -15421,7 +16576,7 @@ async function withCheckpointMutationLockResult(input) {
     attempts++;
     let lockResult;
     try {
-      lockResult = await _internals18.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, input.operationKey);
+      lockResult = await _internals19.tryAcquireLock(input.directory, CHECKPOINT_LOG_PATH, CHECKPOINT_AGENT_NAME, input.operationKey);
     } catch (error2) {
       if (input.onFailure) {
         return input.onFailure(error2);
@@ -15458,7 +16613,7 @@ async function withCheckpointMutationLockResult(input) {
     if (attempts >= CHECKPOINT_LOCK_MAX_ATTEMPTS || Date.now() + CHECKPOINT_LOCK_DELAY_MS > deadline) {
       break;
     }
-    await _internals18.sleep(CHECKPOINT_LOCK_DELAY_MS);
+    await _internals19.sleep(CHECKPOINT_LOCK_DELAY_MS);
   }
   if (input.onBusy) {
     return input.onBusy(attempts);
@@ -15483,7 +16638,7 @@ function handleSave(label, directory) {
       });
     }
     const timestamp = new Date().toISOString();
-    _internals18.stageAllExcludingSwarm(directory);
+    _internals19.stageAllExcludingSwarm(directory);
     const hasStagedChanges = (() => {
       try {
         gitExec(["diff", "--cached", "--quiet"], directory);
@@ -15581,7 +16736,7 @@ async function handleSaveTaskCompletion(taskId, directory) {
     directory,
     taskId,
     run: async () => {
-      const plan = await _internals18.loadPlan(directory);
+      const plan = await _internals19.loadPlan(directory);
       if (!plan) {
         return serializeResult("save_task_completion", {
           success: false,
@@ -15601,7 +16756,7 @@ async function handleSaveTaskCompletion(taskId, directory) {
           error: `save_task_completion failed: task "${taskId}" is ${task.status}, not completed`
         });
       }
-      await _internals18.afterTaskEligibilityRead?.(directory, task.id);
+      await _internals19.afterTaskEligibilityRead?.(directory, task.id);
       const planIdentityHash = derivePlanIdentityHash(plan);
       const planId = derivePlanId(plan);
       const ledgerEvents = await readLedgerEvents(directory);
@@ -15637,12 +16792,12 @@ async function handleSaveTaskCompletion(taskId, directory) {
           message: `Checkpoint task completion already logged for "${descriptor.taskId}"`
         });
       }
-      const recoveredSha = _internals18.findCommitByExactSubject(directory, descriptor.subject);
+      const recoveredSha = _internals19.findCommitByExactSubject(directory, descriptor.subject);
       let committedSha = null;
       committedSha = recoveredSha ?? receipt.sha;
       if (!committedSha) {
-        _internals18.stageAllExcludingSwarm(directory);
-        _internals18.gitExec([
+        _internals19.stageAllExcludingSwarm(directory);
+        _internals19.gitExec([
           "commit",
           "--allow-empty",
           "-m",
@@ -15906,7 +17061,7 @@ var IPV4_PRIVATE_192 = /^192\.168\./;
 var IPV4_ZERO_NETWORK = /^0\./;
 var IPV6_LINK_LOCAL = /^fe80:/i;
 var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-var _internals19 = {
+var _internals20 = {
   spawnSync: (cmd, args, options) => {
     const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
     return child_process2.spawnSync(cmd, args, {
@@ -16024,7 +17179,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd, laneEnv) {
   try {
-    const result = _internals19.spawnSync(resolveGitExecutable(), ["remote", "get-url", "origin"], {
+    const result = _internals20.spawnSync(resolveGitExecutable(), ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -16193,7 +17348,7 @@ init_logger();
 var GIT_TIMEOUT_MS3 = 30000;
 var VALIDATION_TIMEOUT_MS = 5 * 60 * 1000;
 var OUTPUT_LIMIT_BYTES = 12000;
-var _internals20 = {
+var _internals21 = {
   runExternalTool,
   getDefaultBaseBranch,
   detectDefaultRemoteBranch,
@@ -16207,8 +17362,8 @@ var _internals20 = {
   }
 };
 async function runGit(args, cwd, timeoutMs = GIT_TIMEOUT_MS3) {
-  const result = await _internals20.runExternalTool({
-    executable: _internals20.resolveGitExecutable(),
+  const result = await _internals21.runExternalTool({
+    executable: _internals21.resolveGitExecutable(),
     args,
     cwd,
     timeoutMs,
@@ -16225,7 +17380,7 @@ async function runGit(args, cwd, timeoutMs = GIT_TIMEOUT_MS3) {
 }
 async function runValidationCommand(cmd, cwd, timeoutMs = VALIDATION_TIMEOUT_MS) {
   const [executable, ...args] = cmd;
-  const result = await _internals20.runExternalTool({
+  const result = await _internals21.runExternalTool({
     executable,
     args,
     cwd,
@@ -16253,9 +17408,9 @@ async function getCurrentBranchOrRef(directory) {
   return hashResult.stdout.trim();
 }
 async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated) {
-  const rawBase = path19.join(_internals20.osTmpdir(), "swarm-ci-simulate");
+  const rawBase = path19.join(_internals21.osTmpdir(), "swarm-ci-simulate");
   await fsPromises.mkdir(rawBase, { recursive: true });
-  const worktreeBase = _internals20.fs.realpathSync(rawBase);
+  const worktreeBase = _internals21.fs.realpathSync(rawBase);
   const worktreeName = `pr-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
   const worktreePath = path19.join(worktreeBase, worktreeName);
   const addResult = await runGit(["worktree", "add", "--detach", worktreePath, baseBranch], projectRoot);
@@ -16270,11 +17425,11 @@ async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated)
   return worktreePath;
 }
 async function cleanupWorktree(worktreePath, projectRoot) {
-  const rawBase = path19.resolve(_internals20.osTmpdir(), "swarm-ci-simulate");
-  const worktreeBase = _internals20.fs.existsSync(rawBase) ? _internals20.fs.realpathSync(rawBase) : rawBase;
-  const resolved = _internals20.fs.existsSync(worktreePath) ? _internals20.fs.realpathSync(worktreePath) : path19.resolve(worktreePath);
-  const pathEq = _internals20.platform === "win32" ? (a, b) => a.toLowerCase() === b.toLowerCase() : (a, b) => a === b;
-  const pathStartsWith = _internals20.platform === "win32" ? (a, b) => a.toLowerCase().startsWith(b.toLowerCase()) : (a, b) => a.startsWith(b);
+  const rawBase = path19.resolve(_internals21.osTmpdir(), "swarm-ci-simulate");
+  const worktreeBase = _internals21.fs.existsSync(rawBase) ? _internals21.fs.realpathSync(rawBase) : rawBase;
+  const resolved = _internals21.fs.existsSync(worktreePath) ? _internals21.fs.realpathSync(worktreePath) : path19.resolve(worktreePath);
+  const pathEq = _internals21.platform === "win32" ? (a, b) => a.toLowerCase() === b.toLowerCase() : (a, b) => a === b;
+  const pathStartsWith = _internals21.platform === "win32" ? (a, b) => a.toLowerCase().startsWith(b.toLowerCase()) : (a, b) => a.startsWith(b);
   if (!pathEq(resolved, worktreeBase) && !pathStartsWith(resolved, `${worktreeBase}${path19.sep}`)) {
     return `[ci-simulate] refusing to clean up non-contained path ${worktreePath}`;
   }
@@ -16286,11 +17441,11 @@ async function cleanupWorktree(worktreePath, projectRoot) {
     if (!line.startsWith("worktree "))
       return false;
     const raw = line.slice("worktree ".length).trim();
-    const canon = _internals20.fs.existsSync(raw) ? _internals20.fs.realpathSync(raw) : path19.resolve(raw);
+    const canon = _internals21.fs.existsSync(raw) ? _internals21.fs.realpathSync(raw) : path19.resolve(raw);
     return pathEq(canon, resolved);
   });
   if (!registered) {
-    if (!_internals20.fs.existsSync(resolved))
+    if (!_internals21.fs.existsSync(resolved))
       return null;
     return `[ci-simulate] path ${worktreePath} exists but is not a registered git worktree; remove it manually`;
   }
@@ -16389,7 +17544,7 @@ async function handleCiSimulateCommand(directory, args) {
     steps: []
   };
   try {
-    const detectedBranch = _internals20.detectDefaultRemoteBranch(directory);
+    const detectedBranch = _internals21.detectDefaultRemoteBranch(directory);
     let baseBranch = null;
     if (explicitBase) {
       const verify = await runGit(["rev-parse", "--verify", "--quiet", explicitBase], directory);
@@ -16866,7 +18021,7 @@ async function boundedSessionCall(call, timeoutMs, timeoutLabel, failureLabel, s
       })
     ]);
   } catch (error2) {
-    _internals21.log(`${failureLabel} for ephemeral session`, {
+    _internals22.log(`${failureLabel} for ephemeral session`, {
       sessionId,
       error: error2 instanceof Error ? error2.message : String(error2)
     });
@@ -16878,21 +18033,21 @@ async function boundedSessionCall(call, timeoutMs, timeoutLabel, failureLabel, s
 async function boundedAbortEphemeralSession(session, sessionId, timeoutMs = DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS) {
   if (typeof session.abort !== "function")
     return;
-  await _internals21.boundedSessionCall(() => session.abort({ path: { id: sessionId } }), timeoutMs, "ephemeral session abort timed out", "ephemeral session abort failed", sessionId);
+  await _internals22.boundedSessionCall(() => session.abort({ path: { id: sessionId } }), timeoutMs, "ephemeral session abort timed out", "ephemeral session abort failed", sessionId);
 }
 async function boundedDeleteEphemeralSession(session, sessionId, timeoutMs = DEFAULT_EPHEMERAL_TEARDOWN_DELETE_TIMEOUT_MS) {
-  await _internals21.boundedSessionCall(() => session.delete({ path: { id: sessionId } }), timeoutMs, "ephemeral session delete timed out", "ephemeral session delete failed", sessionId);
+  await _internals22.boundedSessionCall(() => session.delete({ path: { id: sessionId } }), timeoutMs, "ephemeral session delete timed out", "ephemeral session delete failed", sessionId);
 }
 async function teardownEphemeralSession(session, sessionId, options = {}) {
   const abortTimeoutMs = options.abortTimeoutMs ?? DEFAULT_EPHEMERAL_ABORT_TIMEOUT_MS;
   const deleteTimeoutMs = options.deleteTimeoutMs ?? DEFAULT_EPHEMERAL_TEARDOWN_DELETE_TIMEOUT_MS;
   const skipAbort = options.skipAbort ?? false;
   if (!skipAbort) {
-    await _internals21.boundedAbort(session, sessionId, abortTimeoutMs);
+    await _internals22.boundedAbort(session, sessionId, abortTimeoutMs);
   }
-  await _internals21.boundedDelete(session, sessionId, deleteTimeoutMs);
+  await _internals22.boundedDelete(session, sessionId, deleteTimeoutMs);
 }
-var _internals21 = {
+var _internals22 = {
   boundedSessionCall,
   boundedAbort: boundedAbortEphemeralSession,
   boundedDelete: boundedDeleteEphemeralSession,
@@ -16900,7 +18055,7 @@ var _internals21 = {
 };
 
 // src/failures/invocation-failure.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 
 // src/utils/provider-error-classification.ts
 var TRANSIENT_STATUS_CODES = new Set([
@@ -16937,7 +18092,7 @@ function isQuotaError(signal) {
 
 // src/failures/action-identity.ts
 init_schema();
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 var MAX_STRING_INPUT = 512;
 var MAX_PUBLIC_FIELD_LENGTH = 128;
 var MAX_COLLECTION_ITEMS = 64;
@@ -16987,11 +18142,11 @@ var SCOPE_KEYS = [
   "path",
   "paths"
 ];
-function normalizeToolName(tool2) {
+function normalizeToolName2(tool2) {
   return tool2.trim().toLowerCase() || "unknown-tool";
 }
 function hashString(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash10("sha256").update(value).digest("hex");
 }
 function readRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -17182,7 +18337,7 @@ function createActionIdentity(input) {
   ]);
   const additionalDigest = hashString(JSON.stringify(canonicalizeAdditional(omitKnownKeys(args, knownKeys))));
   const normalized = {
-    tool: normalizeToolName(input.tool),
+    tool: normalizeToolName2(input.tool),
     role,
     swarm,
     task,
@@ -17259,7 +18414,7 @@ function boundedUtf8(value, maxBytes = MAX_DISPLAY_BYTES) {
   return buffer.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD+$/g, "");
 }
 function hashValue(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function redactUrl(match) {
   try {
@@ -17671,7 +18826,7 @@ class ModelDispatchTimeoutError extends Error {
     this.name = "TimeoutError";
   }
 }
-var _internals22 = {
+var _internals23 = {
   setTimeout,
   clearTimeout
 };
@@ -17681,13 +18836,13 @@ function deadlineError(phase) {
 async function raceWithTimeout(promise, ms, timeoutError) {
   let timer;
   const timeoutPromise = new Promise((_, reject) => {
-    timer = _internals22.setTimeout(() => reject(timeoutError), Math.max(0, ms));
+    timer = _internals23.setTimeout(() => reject(timeoutError), Math.max(0, ms));
   });
   try {
     return await Promise.race([promise, timeoutPromise]);
   } finally {
     if (timer !== undefined)
-      _internals22.clearTimeout(timer);
+      _internals23.clearTimeout(timer);
   }
 }
 function resolveLegacyFallbackModel(resolveFallback, fallbackIndex) {
@@ -18571,7 +19726,7 @@ async function readLedgerForTransaction(filePath) {
   }
 }
 async function readLedgerStrict(directory) {
-  const filePath = _internals23.resolveRecommendationLedgerPath(directory);
+  const filePath = _internals24.resolveRecommendationLedgerPath(directory);
   try {
     return parseLedgerJsonl(await readFile6(filePath, "utf-8"));
   } catch (err) {
@@ -18649,7 +19804,7 @@ async function checkRecommendations(directory, candidates) {
   let ledgerKeys = new Set;
   let degraded = false;
   try {
-    const entries = await _internals23.readLedgerStrict(directory);
+    const entries = await _internals24.readLedgerStrict(directory);
     ledgerKeys = new Set(entries.map((entry) => entry.crossKey));
   } catch (err) {
     warn(`[recommendation-ledger] check failed (fail-open, emitting everything): ${err instanceof Error ? err.message : String(err)}`);
@@ -18711,13 +19866,13 @@ async function recordEmittedRecommendations(directory, candidates, options = {})
   if (!candidates.some(hasIdentity)) {
     return { recorded: 0, suppressed: 0, evicted: 0, degraded: false };
   }
-  const emittedAt = options.producedAt ?? _internals23.now().toISOString();
+  const emittedAt = options.producedAt ?? _internals24.now().toISOString();
   let recorded = 0;
   let suppressed = 0;
   let evicted = 0;
   try {
-    const filePath = _internals23.resolveRecommendationLedgerPath(directory);
-    const wrote = await _internals23.transactFile(filePath, readLedgerForTransaction, async (target, data) => {
+    const filePath = _internals24.resolveRecommendationLedgerPath(directory);
+    const wrote = await _internals24.transactFile(filePath, readLedgerForTransaction, async (target, data) => {
       await atomicWriteFile(target, serializeLedger(data));
     }, (existing) => {
       const seen = new Set(existing.map((entry) => entry.crossKey));
@@ -18754,7 +19909,7 @@ async function recordEmittedRecommendations(directory, candidates, options = {})
     return { recorded: 0, suppressed: 0, evicted: 0, degraded: true };
   }
 }
-var _internals23 = {
+var _internals24 = {
   now: () => new Date,
   transactFile,
   readLedgerStrict,
@@ -18985,7 +20140,7 @@ async function reviseSkill(params) {
   }
   if (!params.delegate) {
     try {
-      const revised = _internals24.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
+      const revised = _internals25.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
       const validation = await validateRevisionCandidate(params, revised, "skill_reviser:deterministic");
       if (!validation.passed) {
         return {
@@ -19112,7 +20267,7 @@ async function reviseSkill(params) {
     };
   }
 }
-var _internals24 = {
+var _internals25 = {
   reviseSkill,
   getSkillVersion,
   buildDeterministicRevision,
@@ -19491,7 +20646,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-00hyhg47.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8n602qc2.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -19607,7 +20762,7 @@ var MAX_CURATOR_PHASE_DIGESTS = 50;
 var MAX_CURATOR_COMPLIANCE_OBSERVATIONS = 200;
 var MAX_CURATOR_RECOMMENDATIONS = 200;
 var MAX_LESSON_CHARS = 280;
-var _internals25 = {
+var _internals26 = {
   parseKnowledgeRecommendations,
   parseKnowledgeRecommendationsWithDiagnostics,
   readCuratorSummary,
@@ -19742,9 +20897,9 @@ function recordCuratorSkips(directory, skipped) {
 async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs) {
   const observations = [];
   try {
-    const skillListResult = await _internals25.listSkills(directory);
-    const { entries: usageEntries, coverage } = _internals25.readSkillUsageEntriesWithCoverage(directory);
-    const allArchivedIds = await _internals25.getArchivedKnowledgeIds(directory);
+    const skillListResult = await _internals26.listSkills(directory);
+    const { entries: usageEntries, coverage } = _internals26.readSkillUsageEntriesWithCoverage(directory);
+    const allArchivedIds = await _internals26.getArchivedKnowledgeIds(directory);
     let skippedForCoverage = 0;
     for (const active of skillListResult.active) {
       if (excludeSlugs?.has(active.slug))
@@ -19771,7 +20926,7 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
           warn(`[curator] skill '${active.slug}' auto-retire skipped: retained usage window (${skillUsage.length} entries) cannot support the decision`);
         } else {
           const reason = `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold`;
-          await _internals25.retireSkill(directory, active.slug, reason);
+          await _internals26.retireSkill(directory, active.slug, reason);
           observations.push(`Skill '${active.slug}' auto-retired: ${reason}`);
           warn(`[curator] ${observations[observations.length - 1]}`);
           continue;
@@ -19780,15 +20935,15 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
       let archivedSourceMatched = false;
       if (allArchivedIds.size > 0) {
         try {
-          const content = await _internals25.readFileAsync(active.path, "utf-8");
-          const sourceIds = _internals25.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
+          const content = await _internals26.readFileAsync(active.path, "utf-8");
+          const sourceIds = _internals26.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
           archivedSourceMatched = sourceIds.some((id) => allArchivedIds.has(id));
         } catch {
           archivedSourceMatched = false;
         }
       }
       if (archivedSourceMatched) {
-        const result = await _internals25.retireOrMarkStale(directory, path24.dirname(active.path), allArchivedIds);
+        const result = await _internals26.retireOrMarkStale(directory, path24.dirname(active.path), allArchivedIds);
         if (result.action === "retire") {
           observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
           warn(`[curator] ${observations[observations.length - 1]}`);
@@ -19798,7 +20953,7 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
         }
       }
     }
-    _internals25.recordCuratorSkips(directory, skippedForCoverage);
+    _internals26.recordCuratorSkips(directory, skippedForCoverage);
   } catch (autoRetireErr) {
     warn(`[curator] auto-retire health check failed: ${autoRetireErr instanceof Error ? autoRetireErr.message : String(autoRetireErr)}`);
   }
@@ -20062,7 +21217,7 @@ async function transactCuratorSummary(directory, mutate) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
   let invoked = false;
   let mutationResult;
-  await _internals25.transactFile(resolvedPath, _internals25.readCuratorSummaryState, _internals25.writeCuratorSummaryState, (state) => {
+  await _internals26.transactFile(resolvedPath, _internals26.readCuratorSummaryState, _internals26.writeCuratorSummaryState, (state) => {
     invoked = true;
     const mutation = mutate(state.summary);
     mutationResult = mutation.result;
@@ -20211,8 +21366,8 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
   const observations = [];
   const timestamp = new Date().toISOString();
   for (const agent of requiredAgents) {
-    const normalizedAgent = _internals25.normalizeAgentName(agent);
-    const isDispatched = agentsDispatched.some((a) => _internals25.normalizeAgentName(a) === normalizedAgent);
+    const normalizedAgent = _internals26.normalizeAgentName(agent);
+    const isDispatched = agentsDispatched.some((a) => _internals26.normalizeAgentName(a) === normalizedAgent);
     if (!isDispatched) {
       observations.push({
         phase,
@@ -20231,7 +21386,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation") {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals25.normalizeAgentName(agent);
+          const normalized = _internals26.normalizeAgentName(agent);
           if (normalized === "coder") {
             coderDelegations.push({ event: e, index: i });
           } else if (normalized === "reviewer") {
@@ -20288,7 +21443,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation" && e.agent) {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals25.normalizeAgentName(agent);
+          const normalized = _internals26.normalizeAgentName(agent);
           if (normalized === "sme") {
             smeDelegations.push({ event: e, index: i });
           }
@@ -20312,7 +21467,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
 }
 async function runCuratorInit(directory, config, llmDelegate) {
   try {
-    const priorSummary = await _internals25.readCuratorSummary(directory);
+    const priorSummary = await _internals26.readCuratorSummary(directory);
     const knowledgePath = resolveSwarmKnowledgePath(directory);
     const allEntries = await readKnowledge(knowledgePath);
     const highConfidenceEntries = allEntries.filter((e) => typeof e.confidence === "number" && e.confidence >= config.min_knowledge_confidence);
@@ -20353,7 +21508,7 @@ async function runCuratorInit(directory, config, llmDelegate) {
       const maxContextChars = config.max_summary_tokens * 2;
       briefingParts.push(contextMd.slice(0, maxContextChars));
     }
-    const latestPostMortemDigest = _internals25.readLatestPostMortemDigest(directory);
+    const latestPostMortemDigest = _internals26.readLatestPostMortemDigest(directory);
     if (latestPostMortemDigest) {
       briefingParts.push(`
 ## Latest Post-Mortem`);
@@ -20440,7 +21595,7 @@ Could not load prior session context.`,
 }
 async function runCuratorPhase(directory, phase, agentsDispatched, config, knowledgeConfig, llmDelegate) {
   try {
-    const priorSummary = await _internals25.readCuratorSummary(directory);
+    const priorSummary = await _internals26.readCuratorSummary(directory);
     if (priorSummary?.phase_digests.some((d) => d.phase === phase)) {
       const existingDigest = priorSummary.phase_digests.find((d) => d.phase === phase);
       return {
@@ -20453,7 +21608,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       };
     }
     const eventsWindow = readCoreEvents(directory);
-    const phaseEvents = eventsWindow.text.length > 0 ? _internals25.filterPhaseEvents(eventsWindow.text, phase) : [];
+    const phaseEvents = eventsWindow.text.length > 0 ? _internals26.filterPhaseEvents(eventsWindow.text, phase) : [];
     if (eventsWindow.coverage === "truncated") {
       try {
         appendCoreEventSync(directory, {
@@ -20467,7 +21622,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const contextMd = await readSwarmFileAsync(directory, "context.md");
     const requiredAgents = ["reviewer", "test_engineer"];
-    const complianceObservations = _internals25.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
+    const complianceObservations = _internals26.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
     const plan = await loadPlanJsonOnly(directory);
     const phaseData = plan?.phases.find((p) => p.id === phase);
     const tasksCompleted = phaseData ? phaseData.tasks.filter((t) => t.status === "completed").length : 0;
@@ -20491,7 +21646,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       timestamp: new Date().toISOString(),
       summary: `Phase ${phase} completed. ${tasksCompleted}/${tasksTotal} tasks completed. ${complianceObservations.length} compliance observations.`,
       agents_used: [
-        ...new Set(agentsDispatched.map((a) => _internals25.normalizeAgentName(a)))
+        ...new Set(agentsDispatched.map((a) => _internals26.normalizeAgentName(a)))
       ],
       tasks_completed: tasksCompleted,
       tasks_total: tasksTotal,
@@ -20543,7 +21698,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
           clearTimeout(timer);
         }
         if (llmOutput?.trim()) {
-          const parsed = _internals25.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
+          const parsed = _internals26.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
           for (const diagnostic of parsed.diagnostics) {
             warn("[curator] skipped malformed recommendation line", {
               phase,
@@ -20588,7 +21743,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const sessionId = `session-${Date.now()}`;
     const now2 = new Date().toISOString();
-    const summaryUpdated = await _internals25.mergeCuratorPhaseSummary(directory, {
+    const summaryUpdated = await _internals26.mergeCuratorPhaseSummary(directory, {
       phase,
       phaseDigest,
       complianceObservations,
@@ -20621,7 +21776,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-9k1ztt7c.js");
+        const skillModule = await import("./skill-generator-kh1z90tm.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -20639,8 +21794,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const revisedSlugs = new Set;
     try {
-      const skillListResult = await _internals25.listSkills(directory);
-      const { entries: usageEntries, coverage } = _internals25.readSkillUsageEntriesWithCoverage(directory);
+      const skillListResult = await _internals26.listSkills(directory);
+      const { entries: usageEntries, coverage } = _internals26.readSkillUsageEntriesWithCoverage(directory);
       let revisionCallsThisPhase = 0;
       let skippedForCoverage = 0;
       for (const active of skillListResult.active) {
@@ -20665,8 +21820,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
         const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
         const violationRate = violations / skillUsage.length;
         if (violationRate > REVISION_VIOLATION_THRESHOLD && violationRate <= 0.3) {
-          const content = await _internals25.readFileAsync(active.path, "utf-8");
-          const fm = _internals25.parseDraftFrontmatter(content);
+          const content = await _internals26.readFileAsync(active.path, "utf-8");
+          const fm = _internals26.parseDraftFrontmatter(content);
           if (fm && fm.skillOrigin === "promoted_external")
             continue;
           if (!isUsageWindowUsable(coverage, skillUsage.length)) {
@@ -20682,7 +21837,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
             reviewerNotes: e.reviewerNotes,
             timestamp: e.timestamp
           }));
-          const result2 = await _internals25.reviseSkill({
+          const result2 = await _internals26.reviseSkill({
             directory,
             slug: active.slug,
             skillPath: active.path,
@@ -20698,18 +21853,18 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
             revisionCallsThisPhase++;
         }
       }
-      _internals25.recordCuratorSkips(directory, skippedForCoverage);
+      _internals26.recordCuratorSkips(directory, skippedForCoverage);
     } catch (revisionErr) {
       warn(`[curator] skill revision check failed: ${revisionErr instanceof Error ? revisionErr.message : String(revisionErr)}`);
     }
     try {
-      const peSkillList = await _internals25.listSkills(directory);
-      const { entries: peUsageEntries, coverage: peCoverage } = _internals25.readSkillUsageEntriesWithCoverage(directory);
+      const peSkillList = await _internals26.listSkills(directory);
+      const { entries: peUsageEntries, coverage: peCoverage } = _internals26.readSkillUsageEntriesWithCoverage(directory);
       const peRetirementMinAgeDays = 60;
       let skippedForCoverage = 0;
       for (const active of peSkillList.active) {
-        const content = await _internals25.readFileAsync(active.path, "utf-8");
-        const fm = _internals25.parseDraftFrontmatter(content);
+        const content = await _internals26.readFileAsync(active.path, "utf-8");
+        const fm = _internals26.parseDraftFrontmatter(content);
         if (!fm || fm.skillOrigin !== "promoted_external")
           continue;
         const skillUsage = peUsageEntries.filter((e) => {
@@ -20762,11 +21917,11 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
           phaseDigest.summary += ` [promoted-external skill '${active.slug}' source drift detected]`;
         }
       }
-      _internals25.recordCuratorSkips(directory, skippedForCoverage);
+      _internals26.recordCuratorSkips(directory, skippedForCoverage);
     } catch (peErr) {
       warn(`[curator] promoted-external staleness check failed: ${peErr instanceof Error ? peErr.message : String(peErr)}`);
     }
-    const autoRetireObservations = await _internals25.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
+    const autoRetireObservations = await _internals26.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
     if (autoRetireObservations.length > 0) {
       const retireNote = ` [${autoRetireObservations.length} skill(s) auto-retired]`;
       phaseDigest.summary += retireNote;
@@ -20903,7 +22058,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
   const authorizedRevisions = new Map;
   let preSnapshot = [];
   if (validRecommendations.length > 0) {
-    preSnapshot = await _internals25.readKnowledge(knowledgePath);
+    preSnapshot = await _internals26.readKnowledge(knowledgePath);
     const authorizedRecs = [];
     for (const rec of validRecommendations) {
       if (rec.action !== "archive" && rec.action !== "rewrite") {
@@ -20932,7 +22087,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     }
     validRecommendations = authorizedRecs;
   }
-  const dedupCheck = await _internals25.checkRecommendations(directory, validRecommendations.map((rec) => buildCuratorRecommendationCandidate(canonicalizeRecommendationEntryId(rec, preSnapshot))));
+  const dedupCheck = await _internals26.checkRecommendations(directory, validRecommendations.map((rec) => buildCuratorRecommendationCandidate(canonicalizeRecommendationEntryId(rec, preSnapshot))));
   if (!dedupCheck.degraded) {
     const keptRecommendations = [];
     for (const decision of dedupCheck.decisions) {
@@ -21093,7 +22248,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-cq4e6v2j.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-d65mctqy.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -21206,7 +22361,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     currentLessons.push(lesson);
     emittedCandidates.push(buildCuratorRecommendationCandidate(rec));
   }
-  await _internals25.recordEmittedRecommendations(directory, emittedCandidates);
+  await _internals26.recordEmittedRecommendations(directory, emittedCandidates);
   return { applied, skipped };
 }
 
@@ -21477,18 +22632,18 @@ async function executePostMortemActions(directory, parsed, options, generation)
     proposals_rejected: 0,
     proposals_skipped: 0
   };
-  const knowledgeConfig = options.knowledgeConfig ?? await _internals26.loadDefaultKnowledgeConfig(directory);
+  const knowledgeConfig = options.knowledgeConfig ?? await _internals27.loadDefaultKnowledgeConfig(directory);
   if (parsed.recommendations.length > 0) {
     try {
-      const knowledgeResult = await _internals26.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig, generation);
+      const knowledgeResult = await _internals27.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig, generation);
       result.knowledge_applied = knowledgeResult.applied;
       result.knowledge_skipped = knowledgeResult.skipped;
     } catch (err) {
       warnings.push(`Post-mortem knowledge actions failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      const entries = await _internals26.readSwarmKnowledge(directory);
-      const hiveResult = await _internals26.checkHivePromotions(entries, knowledgeConfig, directory);
+      const entries = await _internals27.readSwarmKnowledge(directory);
+      const hiveResult = await _internals27.checkHivePromotions(entries, knowledgeConfig, directory);
       result.hive_promotions = hiveResult.new_promotions;
       result.hive_encounters_incremented = hiveResult.encounters_incremented;
       result.hive_advancements = hiveResult.advancements;
@@ -21498,7 +22653,7 @@ async function executePostMortemActions(directory, parsed, options, generation)
   }
   if (parsed.queueTriage.length > 0) {
     try {
-      const proposalResult = await _internals26.applyProposalTriage(directory, parsed.queueTriage);
+      const proposalResult = await _internals27.applyProposalTriage(directory, parsed.queueTriage);
       result.proposals_approved = proposalResult.approved.length;
       result.proposals_rejected = proposalResult.rejected.length;
       result.proposals_skipped = proposalResult.skipped.length;
@@ -21511,7 +22666,7 @@ async function executePostMortemActions(directory, parsed, options, generation)
 async function verifyPostMortemKnowledgeActions(directory, recommendations) {
   if (recommendations.length === 0)
     return [];
-  const entries = await _internals26.readSwarmKnowledge(directory);
+  const entries = await _internals27.readSwarmKnowledge(directory);
   const activeEntries = entries.filter((entry) => isActiveStatus(entry.status));
   const exactIds = new Set(activeEntries.map((entry) => entry.id));
   const prefixMatches = new Map;
@@ -21612,7 +22767,7 @@ async function repairPostMortemActions(llmOutput, diagnostics, options) {
     ].join(`
 `);
     const repaired = await options.llmDelegate("", repairPrompt, ac.signal);
-    const parsed = _internals26.parsePostMortemActions(repaired);
+    const parsed = _internals27.parsePostMortemActions(repaired);
     if (parsed.diagnostics.length === 0) {
       return parsed;
     }
@@ -21665,7 +22820,7 @@ function collectRetrospectives(directory) {
 }
 async function collectDriftReports(directory) {
   try {
-    const reports = await _internals26.readPriorDriftReports(directory);
+    const reports = await _internals27.readPriorDriftReports(directory);
     return reports.slice(-MAX_DRIFT_REPORTS).map((report) => JSON.stringify(report, null, 2));
   } catch {
     return [];
@@ -21890,7 +23045,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings
     };
   }
-  const lock = await _internals26.acquirePostMortemLock(directory, effectivePlanId);
+  const lock = await _internals27.acquirePostMortemLock(directory, effectivePlanId);
   if (!lock.acquired) {
     return {
       success: false,
@@ -21912,7 +23067,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-6awybk8b.js");
+      const { getScanStatus } = await import("./scan-cursor-q3530gc8.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.`);
@@ -21971,20 +23126,20 @@ async function runCuratorPostMortem(directory, options = {}) {
         } finally {
           clearTimeout(timer);
         }
-        let parsedActions = _internals26.parsePostMortemActions(llmOutput);
+        let parsedActions = _internals27.parsePostMortemActions(llmOutput);
         if (parsedActions.diagnostics.length > 0) {
           warnings.push(`Post-mortem structured action parse diagnostics: ${parsedActions.diagnostics.join("; ")}`);
-          const repaired = await _internals26.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
+          const repaired = await _internals27.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
           if (repaired) {
             parsedActions = repaired;
             warnings.push("Post-mortem structured actions repaired by LLM.");
           }
         }
         llmSummary = parsedActions.summary;
-        const executed = await _internals26.executePostMortemActions(directory, parsedActions, options, scanCursor.generation);
+        const executed = await _internals27.executePostMortemActions(directory, parsedActions, options, scanCursor.generation);
         actionResult = executed.result;
         warnings.push(...executed.warnings);
-        const knowledgeVerification = await _internals26.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
+        const knowledgeVerification = await _internals27.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
         for (const item of knowledgeVerification) {
           if (item.status === "not_found" || item.status === "ambiguous_prefix" || item.status === "missing_entry_id") {
             warnings.push(`Post-mortem knowledge action ${item.action} for '${item.input_entry_id ?? "new"}' ${item.status}: ${item.reason}`);
@@ -22023,10 +23178,10 @@ ${actionSummary}`;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`LLM delegate failed, falling back to data-only report: ${msg}`);
-        reportContent = _internals26.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+        reportContent = _internals27.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
       }
     } else {
-      reportContent = _internals26.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+      reportContent = _internals27.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
     }
     try {
       const { mkdirSync: mkdirSync8 } = await import("fs");
@@ -22067,7 +23222,7 @@ ${actionSummary}`;
     }
   }
 }
-var _internals26 = {
+var _internals27 = {
   acquirePostMortemLock,
   collectKnowledgeSummary,
   collectRetrospectives,
@@ -22084,9 +23239,9 @@ var _internals26 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-bf3smw7k.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-5zc62306.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-00hyhg47.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8n602qc2.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -22094,11 +23249,11 @@ var _internals26 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-dnjf9ser.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-pjjw3ja4.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-mpez5tqh.js");
+    const { checkHivePromotions } = await import("./hive-promoter-7vxm11sm.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -22107,7 +23262,7 @@ var _internals26 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-9k1ztt7c.js");
+    } = await import("./skill-generator-kh1z90tm.js");
     const result = {
       approved: [],
       rejected: [],
@@ -22197,7 +23352,7 @@ function extractCurrentPhaseFromPlan(plan) {
 
 // src/hooks/hive-promoter.ts
 init_schema();
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import path27 from "path";
 
 // src/hooks/hive-policy.ts
@@ -22308,10 +23463,10 @@ class HiveStagedAppendError extends Error {
   }
 }
 async function transactHiveStore(mutate) {
-  const dataDir = _internals27.resolveHiveDataDir();
-  const hivePath = _internals27.resolveHiveKnowledgePath();
-  const rejectedPath = _internals27.resolveHiveRejectedPath();
-  const eventsPath = _internals27.resolveHiveEventsPath();
+  const dataDir = _internals28.resolveHiveDataDir();
+  const hivePath = _internals28.resolveHiveKnowledgePath();
+  const rejectedPath = _internals28.resolveHiveRejectedPath();
+  const eventsPath = _internals28.resolveHiveEventsPath();
   const diagnostics = [];
   try {
     await mkdir7(dataDir, { recursive: true });
@@ -22322,7 +23477,7 @@ async function transactHiveStore(mutate) {
   let release = null;
   try {
     try {
-      release = await _internals27.lockfile.lock(dataDir, {
+      release = await _internals28.lockfile.lock(dataDir, {
         ...HIVE_LOCK_RETRIES,
         stale: HIVE_LOCK_STALE_MS
       });
@@ -22330,7 +23485,7 @@ async function transactHiveStore(mutate) {
       diagnostics.push(`hive lock acquire failed: ${err instanceof Error ? err.message : String(err)}`);
       return { committed: false, return: undefined, diagnostics };
     }
-    const entries = await _internals27.readKnowledge(hivePath);
+    const entries = await _internals28.readKnowledge(hivePath);
     const outcome = await mutate({ entries });
     if (outcome.kind === "noop") {
       return { committed: false, return: outcome.return, diagnostics };
@@ -22351,7 +23506,7 @@ async function transactHiveStore(mutate) {
       return { committed: false, return: undefined, diagnostics };
     }
     if (typeof outcome.maxEntries === "number" && committedEntries.length > outcome.maxEntries) {
-      committedEntries = _internals27.selectKnowledgeCapSurvivors(committedEntries, outcome.maxEntries);
+      committedEntries = _internals28.selectKnowledgeCapSurvivors(committedEntries, outcome.maxEntries);
     }
     if (outcome.extraStagedAppends && outcome.extraStagedAppends.length > 0) {
       for (const staged of outcome.extraStagedAppends) {
@@ -22362,7 +23517,7 @@ async function transactHiveStore(mutate) {
     const content = committedEntries.map((e) => overrides?.get(e.id) ?? JSON.stringify(e)).join(`
 `) + (committedEntries.length > 0 ? `
 ` : "");
-    await _internals27.atomicWriteFile(hivePath, content);
+    await _internals28.atomicWriteFile(hivePath, content);
     if (outcome.rejects && outcome.rejects.length > 0) {
       const rejectBlock = `${outcome.rejects.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -22383,7 +23538,7 @@ async function transactHiveStore(mutate) {
     if (outcome.extraStagedAppends && outcome.extraStagedAppends.length > 0) {
       for (const staged of outcome.extraStagedAppends) {
         try {
-          await _internals27.appendFile(staged.path, staged.block, "utf-8");
+          await _internals28.appendFile(staged.path, staged.block, "utf-8");
         } catch (err) {
           throw new HiveStagedAppendError(staged.path, err);
         }
@@ -22447,7 +23602,7 @@ async function trimHiveEventsUnderLock(eventsPath) {
 `)}
 `);
 }
-var _internals27 = {
+var _internals28 = {
   lockfile: import_proper_lockfile4.default,
   readKnowledge,
   atomicWriteFile,
@@ -22482,7 +23637,7 @@ function terminalHistory(membership) {
 }
 async function loadPromotionEvidenceByEntry(directory, canonicalCohortId) {
   try {
-    const history = await _internals28.queryHistoricalOutcomes(directory);
+    const history = await _internals29.queryHistoricalOutcomes(directory);
     if (!history.ok)
       return {};
     const out = {};
@@ -22517,7 +23672,7 @@ async function loadPromotionEvidenceByEntry(directory, canonicalCohortId) {
     return {};
   }
 }
-var _internals28 = { queryHistoricalOutcomes };
+var _internals29 = { queryHistoricalOutcomes };
 
 // src/hooks/hive-promoter.ts
 function carryActionableFields(source) {
@@ -22613,7 +23768,7 @@ function buildLineage(args) {
   return lineage;
 }
 function lessonRevision(lesson) {
-  return createHash11("sha256").update(lesson).digest("hex").slice(0, 12);
+  return createHash12("sha256").update(lesson).digest("hex").slice(0, 12);
 }
 async function checkHivePromotions(swarmEntries, config, directory) {
   const empty = {
@@ -22626,8 +23781,8 @@ async function checkHivePromotions(swarmEntries, config, directory) {
   if (config.hive_enabled === false) {
     return empty;
   }
-  const sourceCohort = await _internals29.resolveCohortId(directory);
-  const evidence2 = await _internals29.loadPromotionEvidence(directory, sourceCohort.cohortId);
+  const sourceCohort = await _internals30.resolveCohortId(directory);
+  const evidence2 = await _internals30.loadPromotionEvidence(directory, sourceCohort.cohortId);
   const diagnostics = [];
   const activeSwarm = swarmEntries.filter((e) => isActiveStatus(e.status));
   const activeSwarmBigrams = activeSwarm.map((e) => typeof e.lesson === "string" ? wordBigrams(e.lesson) : new Set);
@@ -22647,7 +23802,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
       diagnostics.push(`skip promote '${swarmEntry.lesson.slice(0, 40)}\u2026': ${decision.reason}`);
       continue;
     }
-    const validationResult = _internals29.validateLesson(swarmEntry.lesson, [], {
+    const validationResult = _internals30.validateLesson(swarmEntry.lesson, [], {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -22669,7 +23824,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
     });
   }
   const hiveDir = resolveHiveDataDir();
-  const result = await _internals29.transactHiveStore(async (ctx) => {
+  const result = await _internals30.transactHiveStore(async (ctx) => {
     let newPromotions = 0;
     let encounters = 0;
     let advancements = 0;
@@ -22895,7 +24050,7 @@ async function authorizeAndRecordHiveMerge(args) {
   let authorized = true;
   let basis = "config-skipped-unlinked";
   try {
-    const decision = await _internals29.authorizeCuration({
+    const decision = await _internals30.authorizeCuration({
       directory: hiveDir,
       action: "merge",
       entryId: survivingEntry.id,
@@ -22925,7 +24080,7 @@ async function authorizeAndRecordHiveMerge(args) {
     authorizationBasis: basis
   });
 }
-var _internals29 = {
+var _internals30 = {
   readSwarmEntries: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory)),
   checkHivePromotions,
   readCuratorSummary,
@@ -22939,15 +24094,15 @@ var _internals29 = {
 };
 function createHivePromoterHook(directory, config) {
   const hook = async (_input, _output) => {
-    const swarmEntries = await _internals29.readSwarmEntries(directory);
-    const promotionSummary = await _internals29.checkHivePromotions(swarmEntries, config, directory);
-    const curatorSummary = await _internals29.readCuratorSummary(directory);
+    const swarmEntries = await _internals30.readSwarmEntries(directory);
+    const promotionSummary = await _internals30.checkHivePromotions(swarmEntries, config, directory);
+    const curatorSummary = await _internals30.readCuratorSummary(directory);
     if (!curatorSummary)
       return;
     const hasActivity = promotionSummary.new_promotions > 0 || promotionSummary.encounters_incremented > 0 || promotionSummary.advancements > 0;
     if (!hasActivity)
       return;
-    await _internals29.appendCuratorRecommendation(directory, {
+    await _internals30.appendCuratorRecommendation(directory, {
       action: "promote",
       lesson: `Hive promotion: ${promotionSummary.new_promotions} new, ${promotionSummary.encounters_incremented} encounters, ${promotionSummary.advancements} advancements, ${promotionSummary.total_hive_entries} total entries`,
       reason: JSON.stringify({
@@ -22985,16 +24140,16 @@ function normalizeManualActionability(fields) {
 async function promoteToHive(directory, lesson, category, options, config, actionable) {
   const trimmedLesson = lesson.trim();
   const actionableFields = normalizeManualActionability(actionable);
-  const sourceCohort = await _internals29.resolveCohortId(directory);
-  const policyConfig = config ?? _internals29.loadDefaultKnowledgeConfig();
-  const result = await _internals29.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals30.resolveCohortId(directory);
+  const policyConfig = config ?? _internals30.loadDefaultKnowledgeConfig();
+  const result = await _internals30.transactHiveStore(async (ctx) => {
     if (findNearDuplicate(trimmedLesson, ctx.entries, policyConfig.dedup_threshold)) {
       return {
         kind: "noop",
         return: `Lesson already exists in hive (near-duplicate).`
       };
     }
-    const validationResult = _internals29.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals30.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
       category: category || "process",
       scope: "global",
       confidence: 1
@@ -23105,16 +24260,16 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
   if (!swarmEntry) {
     throw new Error(`Lesson ${lessonId} not found in .swarm/knowledge.jsonl`);
   }
-  const sourceCohort = await _internals29.resolveCohortId(directory);
-  const policyConfig = config ?? _internals29.loadDefaultKnowledgeConfig();
-  const result = await _internals29.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals30.resolveCohortId(directory);
+  const policyConfig = config ?? _internals30.loadDefaultKnowledgeConfig();
+  const result = await _internals30.transactHiveStore(async (ctx) => {
     if (findNearDuplicate(swarmEntry.lesson, ctx.entries, policyConfig.dedup_threshold)) {
       return {
         kind: "noop",
         return: `Lesson already exists in hive (near-duplicate).`
       };
     }
-    const validationResult = _internals29.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals30.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -23202,7 +24357,7 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
 }
 
 // src/hooks/knowledge-curator.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile9, realpath as realpath3, writeFile as writeFile6 } from "fs/promises";
 import * as path29 from "path";
@@ -23434,12 +24589,12 @@ function recordSeenRetroSection(key, value, timestamp) {
   capSeenRetroSections();
 }
 function hashContent(content) {
-  return createHash12("sha1").update(content).digest("hex");
+  return createHash13("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-bf3smw7k.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-5zc62306.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-00hyhg47.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8n602qc2.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -23449,7 +24604,7 @@ async function loadConfigForPolicyCurator(directory) {
 async function canonicalExistingPath(candidate) {
   let resolved = path29.resolve(candidate);
   try {
-    resolved = await _internals30.realpath(resolved);
+    resolved = await _internals31.realpath(resolved);
   } catch {}
   return resolved;
 }
@@ -24281,9 +25436,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals30.runAutoPromotion(directory, config);
+    await _internals31.runAutoPromotion(directory, config);
     if (phaseInfo.phase_number > 0) {
-      await _internals30.runAutoDemotion(directory, config, phaseInfo.phase_number);
+      await _internals31.runAutoDemotion(directory, config, phaseInfo.phase_number);
     }
   }
   return { stored, reinforced, skipped, rejected, quarantined };
@@ -24398,7 +25553,7 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
         }
         inFlightEvidenceEntries.add(evidenceKey);
         try {
-          await _internals30.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
+          await _internals31.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
             llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
             enrichmentQuota: options.enrichmentQuota
           });
@@ -24430,14 +25585,14 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals30.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
+    await _internals31.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
       llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var _internals30 = {
+var _internals31 = {
   isWriteToEvidenceFile,
   curateAndStoreSwarm,
   runAutoPromotion,
@@ -24711,7 +25866,7 @@ function isValidTelemetryEntry(value) {
   const nonNegFinite = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
   return typeof obj.timestamp === "string" && typeof obj.task_id === "string" && typeof obj.agent_role === "string" && typeof obj.delegation_reason === "string" && nonNegFinite(obj.token_estimate) && nonNegFinite(obj.cache_hits) && nonNegFinite(obj.cache_misses) && nonNegFinite(obj.stale_entries) && nonNegFinite(obj.recommended_reads) && nonNegFinite(obj.skipped_reads) && typeof obj.success === "boolean";
 }
-var _internals31 = {
+var _internals32 = {
   appendFileSync: fs14.appendFileSync,
   readFileSync: fs14.readFileSync,
   existsSync: fs14.existsSync,
@@ -24802,25 +25957,25 @@ function parseManifestLine(line) {
 }
 function readBoundedChunk(filePath, maxBytes) {
   try {
-    if (!_internals31.existsSync(filePath)) {
+    if (!_internals32.existsSync(filePath)) {
       return { text: "", truncated: false };
     }
-    const fd = _internals31.openSync(filePath, "r");
+    const fd = _internals32.openSync(filePath, "r");
     try {
-      const size = _internals31.statSync(filePath).size;
+      const size = _internals32.statSync(filePath).size;
       const truncated = size > maxBytes;
       const len = Math.min(size, maxBytes);
       const buf = Buffer.alloc(len);
       let read = 0;
       while (read < len) {
-        const n = _internals31.readSync(fd, buf, read, len - read, read);
+        const n = _internals32.readSync(fd, buf, read, len - read, read);
         if (n <= 0)
           break;
         read += n;
       }
       return { text: buf.toString("utf-8", 0, read), truncated };
     } finally {
-      _internals31.closeSync(fd);
+      _internals32.closeSync(fd);
     }
   } catch {
     warnThrottled("bounded read failed (transient I/O)");
@@ -24829,9 +25984,9 @@ function readBoundedChunk(filePath, maxBytes) {
 }
 function fileSizeOrZero(filePath) {
   try {
-    if (!_internals31.existsSync(filePath))
+    if (!_internals32.existsSync(filePath))
       return 0;
-    return _internals31.statSync(filePath).size;
+    return _internals32.statSync(filePath).size;
   } catch {
     return 0;
   }
@@ -24873,17 +26028,17 @@ function atomicReplace(directory, content) {
   const finalPath = telemetryFilePath(directory);
   const tmpPath = tmpFilePath(directory);
   try {
-    if (_internals31.existsSync(tmpPath)) {
+    if (_internals32.existsSync(tmpPath)) {
       try {
-        _internals31.unlinkSync(tmpPath);
+        _internals32.unlinkSync(tmpPath);
       } catch {}
     }
-    _internals31.writeFileSync(tmpPath, content, "utf-8");
-    _internals31.renameSync(tmpPath, finalPath);
+    _internals32.writeFileSync(tmpPath, content, "utf-8");
+    _internals32.renameSync(tmpPath, finalPath);
   } catch {
     try {
-      if (_internals31.existsSync(tmpPath)) {
-        _internals31.unlinkSync(tmpPath);
+      if (_internals32.existsSync(tmpPath)) {
+        _internals32.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error("context-telemetry atomic replace failed");
@@ -24893,20 +26048,20 @@ function withStoreLock(directory, fn) {
   const lockPath = lockFilePath(directory);
   let acquired = false;
   try {
-    _internals31.mkdirSync(path30.dirname(lockPath), { recursive: true });
-    const fd = _internals31.openSync(lockPath, "wx");
-    _internals31.closeSync(fd);
+    _internals32.mkdirSync(path30.dirname(lockPath), { recursive: true });
+    const fd = _internals32.openSync(lockPath, "wx");
+    _internals32.closeSync(fd);
     acquired = true;
   } catch {
     try {
-      const age = Date.now() - _internals31.statSync(lockPath).mtimeMs;
+      const age = Date.now() - _internals32.statSync(lockPath).mtimeMs;
       if (age > 5 * 60000) {
         try {
-          _internals31.unlinkSync(lockPath);
+          _internals32.unlinkSync(lockPath);
         } catch {}
         try {
-          const fd = _internals31.openSync(lockPath, "wx");
-          _internals31.closeSync(fd);
+          const fd = _internals32.openSync(lockPath, "wx");
+          _internals32.closeSync(fd);
           acquired = true;
         } catch {
           acquired = false;
@@ -24922,32 +26077,32 @@ function withStoreLock(directory, fn) {
     return fn();
   } finally {
     try {
-      _internals31.unlinkSync(lockPath);
+      _internals32.unlinkSync(lockPath);
     } catch {}
   }
 }
 var _lastWarnAt = 0;
 function warnThrottled(message) {
   const now2 = Date.now();
-  if (now2 - _lastWarnAt < _internals31.limits.warnCooldownMs)
+  if (now2 - _lastWarnAt < _internals32.limits.warnCooldownMs)
     return;
   _lastWarnAt = now2;
   warn(`context-telemetry: ${message}`);
 }
 function readStore(directory, bounded) {
   const filePath = telemetryFilePath(directory);
-  if (!_internals31.existsSync(filePath)) {
+  if (!_internals32.existsSync(filePath)) {
     return { manifest: null, records: [], corruptLines: 0, truncated: false };
   }
   let text;
   let truncated = false;
   if (bounded) {
-    const chunk = readBoundedChunk(filePath, _internals31.limits.readMaxBytes);
+    const chunk = readBoundedChunk(filePath, _internals32.limits.readMaxBytes);
     text = chunk.text;
     truncated = chunk.truncated;
   } else {
     try {
-      text = _internals31.readFileSync(filePath, "utf-8");
+      text = _internals32.readFileSync(filePath, "utf-8");
     } catch {
       return { manifest: null, records: [], corruptLines: 0, truncated: false };
     }
@@ -25065,7 +26220,7 @@ function periodMs(oldest, newest) {
 }
 function compactStore(directory, trigger = "compaction", alreadyLocked = false) {
   const filePath = telemetryFilePath(directory);
-  if (!_internals31.existsSync(filePath))
+  if (!_internals32.existsSync(filePath))
     return;
   const run = () => {
     const view = readStore(directory, false);
@@ -25077,7 +26232,7 @@ function compactStore(directory, trigger = "compaction", alreadyLocked = false)
     const kept = [];
     for (const rec of view.records) {
       const ts = Date.parse(rec.timestamp);
-      if (!Number.isNaN(ts) && now2 - ts > _internals31.limits.ageMaxMs) {
+      if (!Number.isNaN(ts) && now2 - ts > _internals32.limits.ageMaxMs) {
         agePruned.push(rec);
       } else {
         kept.push(rec);
@@ -25088,7 +26243,7 @@ function compactStore(directory, trigger = "compaction", alreadyLocked = false)
     for (let i = kept.length - 1;i >= 0; i -= 1) {
       const rec = kept[i];
       const lineBytes = Buffer.byteLength(JSON.stringify(rec)) + 1;
-      if (retained.length >= _internals31.limits.activeMaxEntries || bytes + lineBytes > _internals31.limits.activeMaxBytes) {
+      if (retained.length >= _internals32.limits.activeMaxEntries || bytes + lineBytes > _internals32.limits.activeMaxBytes) {
         break;
       }
       retained.push(rec);
@@ -25131,7 +26286,7 @@ function compactStore(directory, trigger = "compaction", alreadyLocked = false)
       oldest: folded.oldestTimestamp,
       newest: folded.newestTimestamp,
       bytes: fileSizeOrZero(filePath),
-      limitBytes: _internals31.limits.activeMaxBytes
+      limitBytes: _internals32.limits.activeMaxBytes
     });
   };
   if (alreadyLocked) {
@@ -25142,10 +26297,10 @@ function compactStore(directory, trigger = "compaction", alreadyLocked = false)
 }
 function migrateCutover(directory, trigger = "compaction", alreadyLocked = false) {
   const filePath = telemetryFilePath(directory);
-  if (!_internals31.existsSync(filePath))
+  if (!_internals32.existsSync(filePath))
     return;
   const run = () => {
-    if (!_internals31.existsSync(filePath))
+    if (!_internals32.existsSync(filePath))
       return;
     const view = readStore(directory, false);
     if (view.manifest === null && view.records.length === 0)
@@ -25156,7 +26311,7 @@ function migrateCutover(directory, trigger = "compaction", alreadyLocked = false
     const kept = [];
     for (const rec of view.records) {
       const ts = Date.parse(rec.timestamp);
-      if (!Number.isNaN(ts) && now2 - ts > _internals31.limits.ageMaxMs) {
+      if (!Number.isNaN(ts) && now2 - ts > _internals32.limits.ageMaxMs) {
         agePruned.push(rec);
       } else {
         kept.push(rec);
@@ -25167,7 +26322,7 @@ function migrateCutover(directory, trigger = "compaction", alreadyLocked = false
     for (let i = kept.length - 1;i >= 0; i -= 1) {
       const rec = kept[i];
       const lb = Buffer.byteLength(JSON.stringify(rec)) + 1;
-      if (retained.length >= _internals31.limits.activeMaxEntries || bytes + lb > _internals31.limits.activeMaxBytes) {
+      if (retained.length >= _internals32.limits.activeMaxEntries || bytes + lb > _internals32.limits.activeMaxBytes) {
         break;
       }
       retained.push(rec);
@@ -25186,7 +26341,7 @@ function migrateCutover(directory, trigger = "compaction", alreadyLocked = false
     let foldedBytes = 0;
     for (const cand of candidates) {
       const cb = Buffer.byteLength(JSON.stringify(cand)) + 1;
-      if (foldedBytes + cb > _internals31.limits.compactMaxBytes && toFold.size > 0) {
+      if (foldedBytes + cb > _internals32.limits.compactMaxBytes && toFold.size > 0) {
         break;
       }
       toFold.add(cand);
@@ -25229,7 +26384,7 @@ function migrateCutover(directory, trigger = "compaction", alreadyLocked = false
       oldest: folded.oldestTimestamp,
       newest: folded.newestTimestamp,
       bytes: fileSizeOrZero(filePath),
-      limitBytes: _internals31.limits.activeMaxBytes
+      limitBytes: _internals32.limits.activeMaxBytes
     });
   };
   if (alreadyLocked) {
@@ -25241,7 +26396,7 @@ function migrateCutover(directory, trigger = "compaction", alreadyLocked = false
 function finalizeContextTelemetry(directory) {
   try {
     const filePath = telemetryFilePath(directory);
-    if (!_internals31.existsSync(filePath))
+    if (!_internals32.existsSync(filePath))
       return;
     withStoreLock(directory, () => {
       let prev = Number.POSITIVE_INFINITY;
@@ -25279,7 +26434,7 @@ function emitContextTelemetryHealth(_directory, payload) {
   } catch {}
 }
 function emitHealth(directory, payload) {
-  _internals31.emitHealth(directory, payload);
+  _internals32.emitHealth(directory, payload);
 }
 
 // src/memory/finalize-reward-sweep.ts
@@ -25532,100 +26687,6 @@ function summarizePiiFindings(findings) {
 }
 var NER_MODEL_CACHE_DIR = path31.join(os3.homedir(), ".cache", "opencode-swarm", "models");
 
-// src/memory/redaction.ts
-import { createHash as createHash13 } from "crypto";
-var SECRET_PATTERNS = [
-  { type: "openai_api_key", pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
-  {
-    type: "github_token",
-    pattern: /\b(?:ghp|gho|ghu|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}\b/g
-  },
-  { type: "aws_access_key_id", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
-  {
-    type: "private_key_block",
-    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g
-  },
-  {
-    type: "authorization_bearer",
-    pattern: /\bAuthorization\s*:\s*Bearer\s+[A-Za-z0-9._~+/=-]{12,}/gi
-  },
-  {
-    type: "env_secret",
-    pattern: /\b(?:[A-Z][A-Z0-9]+_)+(?:KEY|TOKEN|SECRET|PASSWORD)\b\s*=\s*["']?[^\s"'`]{8,}["']?/gi
-  },
-  { type: "gitlab_token", pattern: /\bgl(?:pat|ptt)-[A-Za-z0-9_-]{15,}\b/g },
-  { type: "slack_token", pattern: /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g },
-  {
-    type: "jwt_token",
-    pattern: /\beyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g
-  },
-  {
-    type: "aws_secret_access_key",
-    pattern: /\b(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY|secret_access_key|SecretAccessKey)"?\s*[=:]\s*["']?[A-Za-z0-9/+=]{40}\b/g
-  },
-  {
-    type: "aws_secret_access_key_context",
-    pattern: /\bAKIA[0-9A-Z]{16}\b[^\n]{0,200}?\b[A-Za-z0-9/+=]{40}\b/g
-  },
-  {
-    type: "stripe_secret_key",
-    pattern: /\b(?:sk|rk)_(?:live|test)_[A-Za-z0-9]{24,}\b/g
-  },
-  { type: "google_api_key", pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g },
-  {
-    type: "openssh_private_key_block",
-    pattern: /-----BEGIN[ ]OPENSSH[ ]PRIVATE[ ]KEY-----[\s\S]*?-----END[ ]OPENSSH[ ]PRIVATE[ ]KEY-----/g
-  }
-];
-var REDACTION_POLICY_SALT = 2;
-function computeRedactionPolicyVersion(policy) {
-  return REDACTION_POLICY_SALT * 1e6 + SECRET_PATTERNS.length * 2 + (policy.rejectDurableSecrets ? 1 : 0) + (policy.detectPii ? 4 : 0) + (policy.rejectDurablePii ? 8 : 0) + (policy.piiDetector === "ner" ? 16 : 0);
-}
-var FINGERPRINT_ALGORITHM_VERSION = 2;
-var LEGACY_FINGERPRINT_ALGORITHM_VERSION = 1;
-var _internals32 = {
-  currentAlgorithmVersion: FINGERPRINT_ALGORITHM_VERSION
-};
-function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVersion = _internals32.currentAlgorithmVersion) {
-  const storedVersion = rawStoredVersion === undefined ? LEGACY_FINGERPRINT_ALGORITHM_VERSION : rawStoredVersion;
-  if (typeof storedVersion !== "number" || !Number.isFinite(storedVersion)) {
-    return { status: "unknown" };
-  }
-  return storedVersion === currentVersion ? { status: "comparable" } : { status: "mismatch", storedVersion, currentVersion };
-}
-function computeMemoryCohortFingerprint(input) {
-  const canonical = stableCanonicalStringify(input);
-  return createHash13("sha256").update(canonical).digest("hex").slice(0, 12);
-}
-function buildMemoryCohortFingerprintInput(config) {
-  return {
-    provider: config.provider,
-    redaction_policy_version: computeRedactionPolicyVersion({
-      rejectDurableSecrets: config.redaction.rejectDurableSecrets,
-      detectPii: config.redaction.detectPii,
-      rejectDurablePii: config.redaction.rejectDurablePii,
-      piiDetector: config.redaction.piiDetector
-    }),
-    embedding_model: config.embeddings.model,
-    embedding_dimension: config.embeddings.dimension,
-    embedding_version: config.embeddings.version ?? "default"
-  };
-}
-function findSecrets(text) {
-  const findings = [];
-  for (const { type, pattern } of SECRET_PATTERNS) {
-    pattern.lastIndex = 0;
-    for (const match of text.matchAll(pattern)) {
-      if (match[0])
-        findings.push({ type, match: match[0] });
-    }
-  }
-  return findings;
-}
-function containsSecret(text) {
-  return findSecrets(text).length > 0;
-}
-
 // src/memory/sentinel.ts
 var MEMORY_RECALL_SENTINEL = "## Retrieved Swarm Memory";
 
@@ -35720,7 +36781,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-bf3smw7k.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-5zc62306.js");
     const { config: pmLoadedConfig } = _internals41.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -37939,9 +39000,9 @@ var _internals45 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-bf3smw7k.js"),
-      import("./curator-dnjf9ser.js"),
-      import("./curator-llm-factory-cnatbky1.js")
+      import("./schema-5zc62306.js"),
+      import("./curator-pjjw3ja4.js"),
+      import("./curator-llm-factory-7mfvey3x.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -38950,7 +40011,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-6awybk8b.js");
+    const { getScanStatus } = await import("./scan-cursor-q3530gc8.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -38958,19 +40019,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-4frk38w8.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-z9cchqdj.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-bf3smw7k.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-5zc62306.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-00hyhg47.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8n602qc2.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-jabphe51.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-72qx868r.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -40283,7 +41344,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-q9v8yscr.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-4jxf9w9e.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -40321,7 +41382,7 @@ async function handleDoctorCommand(directory, args) {
 `;
   }
   try {
-    const { runModelPreflight } = await import("./model-preflight-b95w8wxy.js");
+    const { runModelPreflight } = await import("./model-preflight-cv9kvw8h.js");
     const preflight = await runModelPreflight(config, swarmState.opencodeClient);
     if (preflight.catalogAvailable) {
       const unresolved = preflight.resolutions.filter((resolution) => resolution.status === "unresolved");
@@ -41223,7 +42284,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-5drv65qh.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-5ffkbs50.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -76285,7 +77346,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-gheaxd5r.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-eagt6gf8.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await withProtectedSetIntegrity([evalInputRoot, ...protectedRoots(input.directory)], () => _internals97.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -78330,7 +79391,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-17h6ewqp.js");
+    const { buildHelpText } = await import("./index-3qpr16k2.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -78339,7 +79400,7 @@ async function handleHelpCommand(ctx) {
     return _internals100.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals100.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-17h6ewqp.js");
+  const { buildHelpText: fullHelp } = await import("./index-3qpr16k2.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -78670,7 +79731,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-z8f6qhz2.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-b9vr4ta3.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -78680,7 +79741,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-ga6e11r9.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-pggm9hx4.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -78689,7 +79750,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-z8f6qhz2.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-b9vr4ta3.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -78699,7 +79760,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-ga6e11r9.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-pggm9hx4.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -78709,7 +79770,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-zwec6ann.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-hrt36jz5.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -79155,7 +80216,7 @@ Subcommands:
     handler: (ctx) => handleAbortPrWorkflowCommand(ctx.directory, ctx.args, ctx.sessionID),
     description: "Clear a stuck PR_REVIEW/PR_FEEDBACK mechanical gate and stop the auto-resume loop [mode] [reason]",
     args: "[PR_REVIEW|PR_FEEDBACK] [reason...]",
-    details: "Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow \u2014 for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch \u2014 running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. This human-only force path has exactly one exception to that second refusal (issue #2251): when the ONLY lanes still blocking are ones past the 30-minute staleness horizon that the liveness probe reports as still running \u2014 a lane nothing will ever settle on a schedule \u2014 it clears the gate anyway, names exactly which lanes it overrode, and finalizes their delegation records so the session can start a new PR workflow. Those sessions are NOT stopped and their output is NOT collected. A lane with a fresh updatedAt still blocks even under force, and any delegation record that still keeps the session blocked is named in the warning. When checkout preparation preserved a stash, the result instructs the caller to run prepare_pr_workflow_checkout operation=restore after the clear. An audit event is appended to .swarm/events.jsonl.",
+    details: 'Human-only escape hatch for an unrecoverable PR_REVIEW or PR_FEEDBACK mechanical gate. When the architect cannot reach complete_pr_workflow \u2014 for example a compound `git fetch && git checkout` was rejected as read-only shell syntax, the PR head cannot be fetched, or the working tree is on the wrong branch \u2014 running this clears the durable gate state for the current session and stops the auto-resume loop without depending on the trapped model. The agent itself cannot run this command; it must call the abort_pr_workflow tool (or ask you to run this command). Both paths funnel into the same fail-closed abortPrWorkflow hook, which refuses while the workflow is armed for publication or while PR workflow lanes are still in flight. Issue #2108 adds the two audited exits from an armed publication window: the invalidate_pr_feedback_publication tool (change approved content \u2014 every approval of the generation is superseded and the full ladder re-runs) and the abort_pr_workflow tool kind "cancel-publication" with cancel_publication: true and a reason (terminal no-publish cancellation; never grants push authority). A plain recovery or force abort never clears an armed window. This human-only force path has exactly one exception to the lane refusal (issue #2251): when the ONLY lanes still blocking are ones past the 30-minute staleness horizon that the liveness probe reports as still running \u2014 a lane nothing will ever settle on a schedule \u2014 it clears the gate anyway, names exactly which lanes it overrode, and finalizes their delegation records so the session can start a new PR workflow. Those sessions are NOT stopped and their output is NOT collected. A lane with a fresh updatedAt still blocks even under force, and any delegation record that still keeps the session blocked is named in the warning. When checkout preparation preserved a stash, the result instructs the caller to run prepare_pr_workflow_checkout operation=restore after the clear. An audit event is appended to .swarm/events.jsonl.',
     category: "utility",
     toolPolicy: "restricted"
   },
@@ -84696,7 +85757,7 @@ function getDisplayFinalPromptPressure() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-00evnffe.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-76vg2xya.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -85142,7 +86203,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-ej10dhwe.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-2qxjtxt6.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function runRecoveryGit(directory, args, timeoutMs = 15000) {
@@ -85551,7 +86612,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, handle.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-ev3bn503.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-xf2f087t.js");
       await writeLaneProfileToDiskReal(handle.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -86476,7 +87537,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-ev3bn503.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-xf2f087t.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);
@@ -86679,4 +87740,4 @@ var _internals102 = {
   resolveGitExecutable
 };
 
-export { resetActionCircuitExternally, getBlockingActionCircuit, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, getSharedClassifierGuardrailBlock, classifyCommand, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals102 as _internals, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleApproveWriteCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals25 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals29 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, safeRealpathSync, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleBlueprintValidateCommand, handleBlueprintCurrentCommand, handleBlueprintHistoryCommand, handleBlueprintDiffCommand, handleBlueprintExportCommand, handleHarnessCandidateValidateCommand, handleHarnessCandidateShowCommand, handleHarnessCandidateDiffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals100 as _internals3, resolveCommand };
+export { resetActionCircuitExternally, getBlockingActionCircuit, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcExtractRecursiveRmTargets, dcEvaluateRecursiveDeleteTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, getSharedClassifierGuardrailBlock, classifyCommand, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, getAgentSession, parseLeanLaneIndex, computeLaneRuntimeProfile, MAX_TRACKED_STANDARD_WORKTREE_CALLS, awaitingMergeByCallID, standardWorktreeByCallID, standardWorktreeSerializationSessions, getStandardWorktreeDegradationReason, resetStandardWorktreeIsolationState, checkStandardWorktreeSerializationRelease, sanitizeWorktreeTaskId, preProvisionCollisionCheck, isLaneOwnedByCurrentSession, precreateStandardWorktreeSession, preserveBackgroundWorktreeOwnershipForCallId, preserveDirtyWorktreeForCallId, preserveDirtyWorktreeAtPath, cleanupStandardWorktreeForCallId, abortStandardWorktreeDispatch, finishStandardWorktreeDispatch, readLaneEnvFileFromDisk, _internals102 as _internals, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleApproveWriteCommand, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals26 as _internals1, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals30 as _internals2, createHivePromoterHook, promoteToHive, promoteFromSwarm, safeRealpathSync, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, VERSION_PINNED_LEAF, discoverVersionPinnedCachePaths, readCachePackageVersion, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleBlueprintValidateCommand, handleBlueprintCurrentCommand, handleBlueprintHistoryCommand, handleBlueprintDiffCommand, handleBlueprintExportCommand, handleHarnessCandidateValidateCommand, handleHarnessCandidateShowCommand, handleHarnessCandidateDiffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleRecoverCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals100 as _internals3, resolveCommand };