opencode-swarm 7.146.2 → 7.146.3

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

@@ -6,16 +6,16 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-w5r84rd1.js";
+} from "./index-qjgg9qzs.js";
 import {
   stableCanonicalStringify
-} from "./index-c9jr4j2q.js";
+} from "./index-3377n9qp.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-yxhcy5cm.js";
+} from "./index-gayh8tmh.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -61,7 +61,7 @@ import {
   updateTaskStatus,
   validateProjectRoot,
   validateSymlinkBoundary
-} from "./index-z5ppkn8y.js";
+} from "./index-0a4s2803.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -78,7 +78,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-zkaz3fhw.js";
+} from "./index-pc4423w8.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -104,12 +104,12 @@ import {
 } from "./index-y8552snf.js";
 import {
   readRecentEscalations
-} from "./index-vmfaafte.js";
+} from "./index-pgsvn005.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-jv9xs6mb.js";
+} from "./index-eybamsqg.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -158,7 +158,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-5e5a1y2r.js";
+} from "./index-3p4wgm0d.js";
 import {
   BUNDLED_PROJECT_SKILL_ROOT,
   DEFAULT_SKILL_MIN_CONFIDENCE,
@@ -179,7 +179,7 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-vj9bba5k.js";
+} from "./index-v2eevdbj.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -190,11 +190,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-n4k0pt5f.js";
+} from "./index-cgcs823z.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-e1hjd15c.js";
+} from "./index-463msy1e.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -213,7 +213,7 @@ import {
   findByBatchId,
   readDelegations,
   sweepStaleDelegations
-} from "./index-97psh79d.js";
+} from "./index-bxs4wkjf.js";
 import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
@@ -246,18 +246,18 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-tj861zhd.js";
+} from "./index-262kyrk3.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-cx67qa9g.js";
+} from "./index-bxk21f2w.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   canonicalWorkspaceIdentity,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-46cypnz3.js";
+} from "./index-yr1aabxa.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -267,11 +267,12 @@ import {
   getOrAdoptPlanEpochUnderLock,
   initLedger,
   ledgerExists,
+  normalizeExecutionProfileForHash,
   readLedgerEvents,
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-p0m03xa6.js";
+} from "./index-3gagma8p.js";
 import {
   isPathWithinDeclaredScope,
   sanitizeDiagnosticText
@@ -322,7 +323,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-42nq97rb.js";
+} from "./index-923phxsp.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -336,10 +337,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-cr90rcg3.js";
+} from "./index-a7cnyp5e.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-y3hmyvt6.js";
+} from "./index-bydybrke.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -349,7 +350,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-01ybcsa5.js";
+} from "./index-fypq68yn.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -363,7 +364,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-z9ed68jt.js";
+} from "./index-7ph5pz77.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -414,10 +415,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-w0cj7zyd.js";
+} from "./index-j2ckvbx7.js";
 import {
   atomicWriteFile
-} from "./index-qbpxrw95.js";
+} from "./index-1kq3x5q6.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -429,7 +430,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-ycgm9pzg.js";
+} from "./index-xz9w7sa9.js";
 import {
   assertProjectRoot,
   hasExplicitProjectBoundary,
@@ -437,12 +438,12 @@ import {
   listActiveLocks,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-bghwrr59.js";
+} from "./index-6q35swn2.js";
 import {
   emit,
   getLastHeartbeat,
   telemetry
-} from "./index-qyvjp0bq.js";
+} from "./index-q81s0m8k.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -469,20 +470,107 @@ import {
 
 // src/hooks/delegation-gate/worktree-isolation.ts
 init_constants();
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import * as fs53 from "fs/promises";
 import * as path114 from "path";
 init_executor();
 
 // src/state.ts
 init_constants();
+init_loader();
 import { randomUUID as randomUUID14 } from "crypto";
 import * as fs52 from "fs/promises";
 import * as path113 from "path";
 init_schema();
 
-// src/db/qa-gate-profile.ts
+// src/council/council-review-identity.ts
+init_schema();
 import { createHash } from "crypto";
+var COUNCIL_REVIEW_IDENTITY_VERSION = 2;
+function computeCouncilReviewHash(plan) {
+  const normalized = {
+    schema_version: plan.schema_version,
+    title: plan.title,
+    swarm: plan.swarm,
+    migration_status: plan.migration_status,
+    execution_profile: normalizeExecutionProfileForHash(plan.execution_profile),
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      name: phase.name,
+      type: phase.type,
+      required_agents: phase.required_agents ? [...phase.required_agents].sort() : undefined,
+      tasks: phase.tasks.map((task) => ({
+        id: task.id,
+        phase: task.phase,
+        size: task.size,
+        description: task.description,
+        depends: [...task.depends].sort(),
+        acceptance: task.acceptance,
+        files_touched: [...task.files_touched].sort(),
+        evidence_path: task.evidence_path,
+        fr_refs: task.fr_refs ? [...task.fr_refs].sort() : undefined
+      }))
+    }))
+  };
+  return createHash("sha256").update(JSON.stringify(normalized), "utf8").digest("hex");
+}
+function computeCouncilPolicyDigest(level, config) {
+  const base = {
+    maxRounds: config?.maxRounds ?? 3,
+    vetoPriority: config?.vetoPriority ?? true,
+    freshnessMaxAgeHours: config?.freshnessMaxAgeHours ?? 24
+  };
+  let normalized;
+  if (level === "final") {
+    normalized = {
+      ...base,
+      finalCompletionPolicy: resolveFinalCompletionPolicy(config)
+    };
+  } else if (level === "phase") {
+    normalized = {
+      ...base,
+      requireAllMembers: config?.requireAllMembers ?? false,
+      minimumMembers: config?.minimumMembers ?? 3,
+      phaseConcernsAllowComplete: config?.phaseConcernsAllowComplete ?? true
+    };
+  } else {
+    normalized = {
+      ...base,
+      requireAllMembers: config?.requireAllMembers ?? false,
+      minimumMembers: config?.minimumMembers ?? 3
+    };
+  }
+  return createHash("sha256").update(JSON.stringify(normalized), "utf8").digest("hex");
+}
+function resolveFinalCompletionPolicy(config) {
+  const policy = config?.finalCompletionPolicy;
+  if (!policy || policy.mode !== "quorum") {
+    return { mode: "all_required" };
+  }
+  const minimum = policy.minimumMembers;
+  if (typeof minimum === "number" && Number.isInteger(minimum) && minimum >= 3 && minimum <= 5) {
+    return { mode: "quorum", minimumMembers: minimum };
+  }
+  return { mode: "all_required" };
+}
+function computeCouncilReviewIdentity(input) {
+  const identity = {
+    version: COUNCIL_REVIEW_IDENTITY_VERSION,
+    level: input.level,
+    scope: input.scope,
+    planId: input.plan ? derivePlanId(input.plan) : null,
+    planIdentityHash: input.plan ? derivePlanIdentityHash(input.plan) : null,
+    reviewHash: input.plan ? computeCouncilReviewHash(input.plan) : null,
+    policyDigest: computeCouncilPolicyDigest(input.level, input.config)
+  };
+  return {
+    ...identity,
+    identityDigest: createHash("sha256").update(JSON.stringify(identity), "utf8").digest("hex")
+  };
+}
+
+// src/db/qa-gate-profile.ts
+import { createHash as createHash2 } from "crypto";
 
 // src/qa-gate/recovery.ts
 function formatLegacyQaBindingOnlyCall(identity) {
@@ -928,7 +1016,7 @@ function computeProfileHash(profile) {
     identity_hash: profile.identity_hash,
     gates: profile.gates
   });
-  return createHash("sha256").update(payload).digest("hex");
+  return createHash2("sha256").update(payload).digest("hex");
 }
 function getEffectiveGates(profile, sessionOverrides) {
   const merged = { ...profile.gates };
@@ -4197,7 +4285,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-87j70zg1.js");
+  } = await import("./worktree-isolation-443q0pah.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -4299,7 +4387,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-87j70zg1.js");
+        } = await import("./worktree-isolation-443q0pah.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -4962,7 +5050,7 @@ async function commitTaskTerminalUnderPlanLock(options) {
 
 // src/hooks/pr-workflow-gate.ts
 init_zod();
-import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 import { readFileSync as readFileSync4 } from "fs";
 import * as fsp2 from "fs/promises";
 import * as path11 from "path";
@@ -6142,7 +6230,7 @@ ${trimmed}`;
 
 // src/background/lane-output-store.ts
 init_zod();
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import {
   existsSync as existsSync6,
   mkdirSync as mkdirSync3,
@@ -6217,7 +6305,7 @@ function hasValidArtifactIntegrity(artifact, expectedRef) {
   return artifact.ref === expectedRef && artifact.ref === expectedArtifactRef;
 }
 function digestText(text) {
-  return createHash3("sha256").update(text).digest("hex");
+  return createHash4("sha256").update(text).digest("hex");
 }
 
 // src/background/pr-review-trigger-contract.ts
@@ -7778,7 +7866,7 @@ async function readPrReviewFeedbackHandoffArtifact(directory, relativePath) {
   }
   return {
     artifact: parsed.data,
-    digest: createHash4("sha256").update(raw, "utf8").digest("hex")
+    digest: createHash5("sha256").update(raw, "utf8").digest("hex")
   };
 }
 var PrReviewFindingProjectionSchema = exports_external.object({
@@ -7834,7 +7922,7 @@ function canonicalGitHubPrUrl(value) {
   }
 }
 function workflowIdentity(state) {
-  return state.workflowInstanceId ?? `legacy-${createHash4("sha256").update(`${state.sessionID}\x00${state.mode}\x00${state.activatedAt}`).digest("hex").slice(0, 32)}`;
+  return state.workflowInstanceId ?? `legacy-${createHash5("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();
@@ -9325,7 +9413,7 @@ function parseReviewerVerdictFields(text, itemId) {
   return fields;
 }
 function reviewerVerdictRowDigest(fields) {
-  return createHash4("sha256").update(fields.join("\x00")).digest("hex");
+  return createHash5("sha256").update(fields.join("\x00")).digest("hex");
 }
 function parseLaneItemVerdicts(text, itemIds, phase, reviewerClaims) {
   const parsed = new Map;
@@ -9931,7 +10019,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 digest = createHash4("sha256").update(normalized).digest("hex").slice(0, 12);
+  const digest = createHash5("sha256").update(normalized).digest("hex").slice(0, 12);
   return `${slug}-${digest}`;
 }
 function normalizeSessionID(sessionID) {
@@ -10153,7 +10241,7 @@ ${USAGE}`;
 }
 
 // src/services/spec-drift-recovery.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { appendFile as appendFile5, mkdir as mkdir5, readFile as readFile6, unlink as unlink2 } from "fs/promises";
 import { dirname as dirname9 } from "path";
 var SPEC_DRIFT_RECOVERY_AGENT = "spec-drift-recovery";
@@ -10182,7 +10270,7 @@ function now() {
   return new Date().toISOString();
 }
 function sha2562(text) {
-  return createHash5("sha256").update(text, "utf-8").digest("hex");
+  return createHash6("sha256").update(text, "utf-8").digest("hex");
 }
 function parseMarker(raw) {
   try {
@@ -13490,8 +13578,8 @@ async function handleClarifyCommand(_directory, args) {
 
 // src/commands/close.ts
 import * as fsSync2 from "fs";
-import { promises as fs15 } from "fs";
-import path44 from "path";
+import { promises as fs16 } from "fs";
+import path45 from "path";
 init_schema();
 
 // src/full-auto/state.ts
@@ -15598,7 +15686,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4zevsvaa.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -16682,7 +16770,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-fwvmcv8m.js");
+        const skillModule = await import("./skill-generator-k5pxb3w2.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -17142,7 +17230,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-mn4sx4qd.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-7zpg79dx.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -17961,7 +18049,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-p7t5mb4x.js");
+      const { getScanStatus } = await import("./scan-cursor-4jv70zwb.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.`);
@@ -18133,9 +18221,9 @@ var _internals24 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-jhz9hme9.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4zevsvaa.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -18143,11 +18231,11 @@ var _internals24 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-cvy1s7wd.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-acp80hpc.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-3tex870c.js");
+    const { checkHivePromotions } = await import("./hive-promoter-qhrngsvb.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -18156,7 +18244,7 @@ var _internals24 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-fwvmcv8m.js");
+    } = await import("./skill-generator-k5pxb3w2.js");
     const result = {
       approved: [],
       rejected: [],
@@ -18246,7 +18334,7 @@ function extractCurrentPhaseFromPlan(plan) {
 
 // src/hooks/hive-promoter.ts
 init_schema();
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import path25 from "path";
 
 // src/hooks/hive-policy.ts
@@ -18662,7 +18750,7 @@ function buildLineage(args) {
   return lineage;
 }
 function lessonRevision(lesson) {
-  return createHash6("sha256").update(lesson).digest("hex").slice(0, 12);
+  return createHash7("sha256").update(lesson).digest("hex").slice(0, 12);
 }
 async function checkHivePromotions(swarmEntries, config, directory) {
   const empty = {
@@ -19251,7 +19339,7 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
 }
 
 // src/hooks/knowledge-curator.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { existsSync as existsSync14 } from "fs";
 import {
   appendFile as appendFile7,
@@ -19489,12 +19577,12 @@ function recordSeenRetroSection(key, value, timestamp) {
   capSeenRetroSections();
 }
 function hashContent(content) {
-  return createHash7("sha1").update(content).digest("hex");
+  return createHash8("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-jhz9hme9.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4zevsvaa.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -20512,6 +20600,599 @@ var _internals28 = {
   realpath: realpath3
 };
 
+// src/context-map/telemetry.ts
+import * as fs13 from "fs";
+import * as path28 from "path";
+init_logger();
+var CONTEXT_TELEMETRY_LIMITS = {
+  activeMaxBytes: 256 * 1024,
+  activeMaxEntries: 1e4,
+  ageMaxMs: 30 * 24 * 60 * 60 * 1000,
+  compactMaxBytes: 64 * 1024,
+  readMaxBytes: 280 * 1024,
+  checkInterval: 50,
+  warnCooldownMs: 60000,
+  headerMaxBytes: 8 * 1024
+};
+function isValidTelemetryEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = 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 _internals29 = {
+  appendFileSync: fs13.appendFileSync,
+  readFileSync: fs13.readFileSync,
+  existsSync: fs13.existsSync,
+  mkdirSync: fs13.mkdirSync,
+  statSync: fs13.statSync,
+  renameSync: fs13.renameSync,
+  writeFileSync: fs13.writeFileSync,
+  unlinkSync: fs13.unlinkSync,
+  openSync: fs13.openSync,
+  closeSync: fs13.closeSync,
+  readSync: fs13.readSync,
+  limits: CONTEXT_TELEMETRY_LIMITS,
+  emitHealth: emitContextTelemetryHealth,
+  withStoreLock
+};
+function telemetryFilePath(directory) {
+  return path28.join(directory, ".swarm", "context-telemetry.jsonl");
+}
+function lockFilePath(directory) {
+  return path28.join(directory, ".swarm", "context-telemetry.lock");
+}
+function tmpFilePath(directory) {
+  return path28.join(directory, ".swarm", `.context-telemetry.jsonl.${process.pid}.tmp`);
+}
+var MANIFEST_TYPE = "ctx-telemetry-manifest";
+var MANIFEST_SCHEMA = 2;
+function emptyFolded() {
+  return {
+    delegations: 0,
+    successCount: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    staleEntries: 0,
+    tokenSum: 0,
+    recommendedReads: 0,
+    skippedReads: 0,
+    corrupt: 0,
+    dropped: 0,
+    oldestTimestamp: null,
+    newestTimestamp: null
+  };
+}
+function emptyManifest() {
+  return {
+    v: 2,
+    type: MANIFEST_TYPE,
+    schemaVersion: MANIFEST_SCHEMA,
+    folded: emptyFolded(),
+    updatedAt: new Date().toISOString()
+  };
+}
+function parseManifestLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const obj = JSON.parse(trimmed);
+    if (typeof obj !== "object" || obj === null)
+      return null;
+    const rec = obj;
+    if (rec.type !== MANIFEST_TYPE || rec.v !== 2 || rec.schemaVersion !== MANIFEST_SCHEMA || typeof rec.folded !== "object" || rec.folded === null) {
+      return null;
+    }
+    const f = rec.folded;
+    const manifest = emptyManifest();
+    const num = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0;
+    manifest.folded.delegations = num(f.delegations);
+    manifest.folded.successCount = num(f.successCount);
+    manifest.folded.cacheHits = num(f.cacheHits);
+    manifest.folded.cacheMisses = num(f.cacheMisses);
+    manifest.folded.staleEntries = num(f.staleEntries);
+    manifest.folded.tokenSum = num(f.tokenSum);
+    manifest.folded.recommendedReads = num(f.recommendedReads);
+    manifest.folded.skippedReads = num(f.skippedReads);
+    manifest.folded.corrupt = num(f.corrupt);
+    manifest.folded.dropped = num(f.dropped);
+    if (typeof f.oldestTimestamp === "string") {
+      manifest.folded.oldestTimestamp = f.oldestTimestamp;
+    }
+    if (typeof f.newestTimestamp === "string") {
+      manifest.folded.newestTimestamp = f.newestTimestamp;
+    }
+    manifest.updatedAt = typeof rec.updatedAt === "string" ? rec.updatedAt : new Date().toISOString();
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+function readBoundedChunk(filePath, maxBytes) {
+  try {
+    if (!_internals29.existsSync(filePath)) {
+      return { text: "", truncated: false };
+    }
+    const fd = _internals29.openSync(filePath, "r");
+    try {
+      const size = _internals29.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 = _internals29.readSync(fd, buf, read, len - read, read);
+        if (n <= 0)
+          break;
+        read += n;
+      }
+      return { text: buf.toString("utf-8", 0, read), truncated };
+    } finally {
+      _internals29.closeSync(fd);
+    }
+  } catch {
+    warnThrottled("bounded read failed (transient I/O)");
+    return { text: "", truncated: false };
+  }
+}
+function fileSizeOrZero(filePath) {
+  try {
+    if (!_internals29.existsSync(filePath))
+      return 0;
+    return _internals29.statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+function foldEntryInto(agg, entry) {
+  agg.delegations += 1;
+  if (entry.success)
+    agg.successCount += 1;
+  agg.cacheHits += entry.cache_hits;
+  agg.cacheMisses += entry.cache_misses;
+  agg.staleEntries += entry.stale_entries;
+  agg.tokenSum += entry.token_estimate;
+  agg.recommendedReads += entry.recommended_reads;
+  agg.skippedReads += entry.skipped_reads;
+  if (agg.oldestTimestamp === null || entry.timestamp < agg.oldestTimestamp) {
+    agg.oldestTimestamp = entry.timestamp;
+  }
+  if (agg.newestTimestamp === null || entry.timestamp > agg.newestTimestamp) {
+    agg.newestTimestamp = entry.timestamp;
+  }
+}
+function cloneFolded(agg) {
+  return {
+    delegations: agg.delegations,
+    successCount: agg.successCount,
+    cacheHits: agg.cacheHits,
+    cacheMisses: agg.cacheMisses,
+    staleEntries: agg.staleEntries,
+    tokenSum: agg.tokenSum,
+    recommendedReads: agg.recommendedReads,
+    skippedReads: agg.skippedReads,
+    corrupt: agg.corrupt,
+    dropped: agg.dropped,
+    oldestTimestamp: agg.oldestTimestamp,
+    newestTimestamp: agg.newestTimestamp
+  };
+}
+function atomicReplace(directory, content) {
+  const finalPath = telemetryFilePath(directory);
+  const tmpPath = tmpFilePath(directory);
+  try {
+    if (_internals29.existsSync(tmpPath)) {
+      try {
+        _internals29.unlinkSync(tmpPath);
+      } catch {}
+    }
+    _internals29.writeFileSync(tmpPath, content, "utf-8");
+    _internals29.renameSync(tmpPath, finalPath);
+  } catch {
+    try {
+      if (_internals29.existsSync(tmpPath)) {
+        _internals29.unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw new Error("context-telemetry atomic replace failed");
+  }
+}
+function withStoreLock(directory, fn) {
+  const lockPath = lockFilePath(directory);
+  let acquired = false;
+  try {
+    _internals29.mkdirSync(path28.dirname(lockPath), { recursive: true });
+    const fd = _internals29.openSync(lockPath, "wx");
+    _internals29.closeSync(fd);
+    acquired = true;
+  } catch {
+    try {
+      const age = Date.now() - _internals29.statSync(lockPath).mtimeMs;
+      if (age > 5 * 60000) {
+        try {
+          _internals29.unlinkSync(lockPath);
+        } catch {}
+        try {
+          const fd = _internals29.openSync(lockPath, "wx");
+          _internals29.closeSync(fd);
+          acquired = true;
+        } catch {
+          acquired = false;
+        }
+      }
+    } catch {
+      acquired = false;
+    }
+  }
+  if (!acquired)
+    return null;
+  try {
+    return fn();
+  } finally {
+    try {
+      _internals29.unlinkSync(lockPath);
+    } catch {}
+  }
+}
+var _lastWarnAt = 0;
+function warnThrottled(message) {
+  const now2 = Date.now();
+  if (now2 - _lastWarnAt < _internals29.limits.warnCooldownMs)
+    return;
+  _lastWarnAt = now2;
+  warn(`context-telemetry: ${message}`);
+}
+function readStore(directory, bounded) {
+  const filePath = telemetryFilePath(directory);
+  if (!_internals29.existsSync(filePath)) {
+    return { manifest: null, records: [], corruptLines: 0, truncated: false };
+  }
+  let text;
+  let truncated = false;
+  if (bounded) {
+    const chunk = readBoundedChunk(filePath, _internals29.limits.readMaxBytes);
+    text = chunk.text;
+    truncated = chunk.truncated;
+  } else {
+    try {
+      text = _internals29.readFileSync(filePath, "utf-8");
+    } catch {
+      return { manifest: null, records: [], corruptLines: 0, truncated: false };
+    }
+  }
+  const lines = text.split(`
+`);
+  const records = [];
+  let corruptLines = 0;
+  let manifest = null;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.trim() === "")
+      continue;
+    if (i === 0) {
+      manifest = parseManifestLine(line);
+      if (manifest)
+        continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      if (isValidTelemetryEntry(parsed)) {
+        records.push(parsed);
+      } else {
+        corruptLines += 1;
+      }
+    } catch {
+      corruptLines += 1;
+    }
+  }
+  return { manifest, records, corruptLines, truncated };
+}
+function getTelemetrySummary(directory) {
+  const filePath = telemetryFilePath(directory);
+  const zero = () => ({
+    total_delegations: 0,
+    total_cache_hits: 0,
+    total_cache_misses: 0,
+    total_stale_entries: 0,
+    avg_token_estimate: 0,
+    total_recommended_reads: 0,
+    total_skipped_reads: 0,
+    success_rate: 0,
+    coverage: "empty",
+    tracked_period_ms: null,
+    retained_entries: 0,
+    folded_entries: 0,
+    corrupt_entries: 0,
+    dropped_entries: 0,
+    on_disk_bytes: 0
+  });
+  const view = readStore(directory, true);
+  const onDiskBytes = fileSizeOrZero(filePath);
+  const corrupt = view.corruptLines;
+  if (view.manifest === null) {
+    const folded = emptyFolded();
+    for (const rec of view.records)
+      foldEntryInto(folded, rec);
+    const total2 = folded.delegations;
+    if (total2 === 0 && corrupt === 0 && view.records.length === 0) {
+      return zero();
+    }
+    const coverage2 = view.truncated ? "partial-unmigrated" : "complete";
+    return {
+      total_delegations: total2,
+      total_cache_hits: folded.cacheHits,
+      total_cache_misses: folded.cacheMisses,
+      total_stale_entries: folded.staleEntries,
+      avg_token_estimate: total2 > 0 ? Math.round(folded.tokenSum / total2) : 0,
+      total_recommended_reads: folded.recommendedReads,
+      total_skipped_reads: folded.skippedReads,
+      success_rate: total2 > 0 ? Math.round(folded.successCount / total2 * 100) : 0,
+      coverage: coverage2,
+      tracked_period_ms: periodMs(folded.oldestTimestamp, folded.newestTimestamp),
+      retained_entries: view.records.length,
+      folded_entries: 0,
+      corrupt_entries: corrupt,
+      dropped_entries: 0,
+      on_disk_bytes: onDiskBytes
+    };
+  }
+  const agg = cloneFolded(view.manifest.folded);
+  for (const rec of view.records)
+    foldEntryInto(agg, rec);
+  const total = agg.delegations;
+  if (total === 0 && view.records.length === 0 && corrupt === 0) {
+    return zero();
+  }
+  const coverage = view.truncated ? "partial-unmigrated" : "complete";
+  return {
+    total_delegations: total,
+    total_cache_hits: agg.cacheHits,
+    total_cache_misses: agg.cacheMisses,
+    total_stale_entries: agg.staleEntries,
+    avg_token_estimate: total > 0 ? Math.round(agg.tokenSum / total) : 0,
+    total_recommended_reads: agg.recommendedReads,
+    total_skipped_reads: agg.skippedReads,
+    success_rate: total > 0 ? Math.round(agg.successCount / total * 100) : 0,
+    coverage,
+    tracked_period_ms: periodMs(agg.oldestTimestamp, agg.newestTimestamp),
+    retained_entries: view.records.length,
+    folded_entries: view.manifest.folded.delegations,
+    corrupt_entries: corrupt + view.manifest.folded.corrupt,
+    dropped_entries: view.manifest.folded.dropped,
+    on_disk_bytes: onDiskBytes
+  };
+}
+function periodMs(oldest, newest) {
+  if (oldest === null || newest === null)
+    return null;
+  const o = Date.parse(oldest);
+  const n = Date.parse(newest);
+  if (Number.isNaN(o) || Number.isNaN(n))
+    return null;
+  return Math.max(0, n - o);
+}
+function compactStore(directory, trigger = "compaction", alreadyLocked = false) {
+  const filePath = telemetryFilePath(directory);
+  if (!_internals29.existsSync(filePath))
+    return;
+  const run = () => {
+    const view = readStore(directory, false);
+    if (view.manifest === null)
+      return;
+    const folded = cloneFolded(view.manifest.folded);
+    const now2 = Date.now();
+    const agePruned = [];
+    const kept = [];
+    for (const rec of view.records) {
+      const ts = Date.parse(rec.timestamp);
+      if (!Number.isNaN(ts) && now2 - ts > _internals29.limits.ageMaxMs) {
+        agePruned.push(rec);
+      } else {
+        kept.push(rec);
+      }
+    }
+    const retained = [];
+    let bytes = 0;
+    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 >= _internals29.limits.activeMaxEntries || bytes + lineBytes > _internals29.limits.activeMaxBytes) {
+        break;
+      }
+      retained.push(rec);
+      bytes += lineBytes;
+    }
+    retained.reverse();
+    for (const rec of agePruned)
+      foldEntryInto(folded, rec);
+    folded.dropped += agePruned.length;
+    const retainedSet = new Set(retained);
+    const compacted = [];
+    const keptSet = new Set(kept);
+    for (const rec of view.records) {
+      if (keptSet.has(rec) && !retainedSet.has(rec)) {
+        compacted.push(rec);
+      }
+    }
+    for (const rec of compacted)
+      foldEntryInto(folded, rec);
+    folded.corrupt += view.corruptLines;
+    const manifest = {
+      ...emptyManifest(),
+      folded,
+      updatedAt: new Date().toISOString()
+    };
+    const lines = [`${JSON.stringify(manifest)}`];
+    for (const rec of retained)
+      lines.push(JSON.stringify(rec));
+    atomicReplace(directory, lines.length > 1 ? `${lines.join(`
+`)}
+` : `${lines[0]}
+`);
+    emitHealth(directory, {
+      trigger,
+      accepted: folded.delegations + retained.length,
+      compacted: compacted.length,
+      retained: retained.length,
+      dropped: agePruned.length,
+      corrupt: folded.corrupt,
+      oldest: folded.oldestTimestamp,
+      newest: folded.newestTimestamp,
+      bytes: fileSizeOrZero(filePath),
+      limitBytes: _internals29.limits.activeMaxBytes
+    });
+  };
+  if (alreadyLocked) {
+    run();
+    return;
+  }
+  withStoreLock(directory, run);
+}
+function migrateCutover(directory, trigger = "compaction", alreadyLocked = false) {
+  const filePath = telemetryFilePath(directory);
+  if (!_internals29.existsSync(filePath))
+    return;
+  const run = () => {
+    if (!_internals29.existsSync(filePath))
+      return;
+    const view = readStore(directory, false);
+    if (view.manifest === null && view.records.length === 0)
+      return;
+    const folded = view.manifest ? cloneFolded(view.manifest.folded) : emptyFolded();
+    const now2 = Date.now();
+    const agePruned = [];
+    const kept = [];
+    for (const rec of view.records) {
+      const ts = Date.parse(rec.timestamp);
+      if (!Number.isNaN(ts) && now2 - ts > _internals29.limits.ageMaxMs) {
+        agePruned.push(rec);
+      } else {
+        kept.push(rec);
+      }
+    }
+    const retained = [];
+    let bytes = 0;
+    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 >= _internals29.limits.activeMaxEntries || bytes + lb > _internals29.limits.activeMaxBytes) {
+        break;
+      }
+      retained.push(rec);
+      bytes += lb;
+    }
+    retained.reverse();
+    const retainedSet = new Set(retained);
+    const keptSet = new Set(kept);
+    const budgetPruned = [];
+    for (const rec of view.records) {
+      if (keptSet.has(rec) && !retainedSet.has(rec))
+        budgetPruned.push(rec);
+    }
+    const candidates = [...agePruned, ...budgetPruned];
+    const toFold = new Set;
+    let foldedBytes = 0;
+    for (const cand of candidates) {
+      const cb = Buffer.byteLength(JSON.stringify(cand)) + 1;
+      if (foldedBytes + cb > _internals29.limits.compactMaxBytes && toFold.size > 0) {
+        break;
+      }
+      toFold.add(cand);
+      foldedBytes += cb;
+    }
+    const finalRetained = [];
+    const agePrunedSet = new Set(agePruned);
+    let dropped = 0;
+    for (const rec of view.records) {
+      if (toFold.has(rec)) {
+        foldEntryInto(folded, rec);
+        if (agePrunedSet.has(rec))
+          dropped += 1;
+      } else {
+        finalRetained.push(rec);
+      }
+    }
+    if (dropped > 0)
+      folded.dropped += dropped;
+    folded.corrupt += view.corruptLines;
+    const manifest = {
+      ...emptyManifest(),
+      folded,
+      updatedAt: new Date().toISOString()
+    };
+    const lines = [`${JSON.stringify(manifest)}`];
+    for (const rec of finalRetained)
+      lines.push(JSON.stringify(rec));
+    atomicReplace(directory, lines.length > 1 ? `${lines.join(`
+`)}
+` : `${lines[0]}
+`);
+    emitHealth(directory, {
+      trigger,
+      accepted: folded.delegations + finalRetained.length,
+      compacted: toFold.size - dropped,
+      retained: finalRetained.length,
+      dropped,
+      corrupt: folded.corrupt,
+      oldest: folded.oldestTimestamp,
+      newest: folded.newestTimestamp,
+      bytes: fileSizeOrZero(filePath),
+      limitBytes: _internals29.limits.activeMaxBytes
+    });
+  };
+  if (alreadyLocked) {
+    run();
+    return;
+  }
+  withStoreLock(directory, run);
+}
+function finalizeContextTelemetry(directory) {
+  try {
+    const filePath = telemetryFilePath(directory);
+    if (!_internals29.existsSync(filePath))
+      return;
+    withStoreLock(directory, () => {
+      let prev = Number.POSITIVE_INFINITY;
+      for (let pass = 0;pass < 1e4; pass += 1) {
+        const view = readStore(directory, false);
+        if (view.manifest !== null)
+          break;
+        if (view.records.length === 0)
+          break;
+        if (view.records.length >= prev)
+          break;
+        prev = view.records.length;
+        migrateCutover(directory, "close", true);
+      }
+      compactStore(directory, "close", true);
+    });
+  } catch {
+    warnThrottled("finalize failed");
+  }
+}
+function emitContextTelemetryHealth(_directory, payload) {
+  try {
+    telemetry.contextTelemetryHealth({
+      trigger: payload.trigger,
+      accepted_count: payload.accepted,
+      compacted_count: payload.compacted,
+      retained_count: payload.retained,
+      dropped_count: payload.dropped,
+      corrupt_count: payload.corrupt,
+      oldest_timestamp: payload.oldest,
+      newest_timestamp: payload.newest,
+      bytes: payload.bytes,
+      limit_bytes: payload.limitBytes
+    });
+  } catch {}
+}
+function emitHealth(directory, payload) {
+  _internals29.emitHealth(directory, payload);
+}
+
 // src/memory/finalize-reward-sweep.ts
 init_logger();
 
@@ -20745,11 +21426,11 @@ class MemoryValidationError extends Error {
 
 // src/memory/schema.ts
 init_zod();
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 
 // src/memory/pii.ts
 import * as os3 from "os";
-import * as path28 from "path";
+import * as path29 from "path";
 function computePiiScore(findings) {
   return findings.reduce((max, f) => Math.max(max, f.confidence), 0);
 }
@@ -20760,10 +21441,10 @@ function summarizePiiFindings(findings) {
   }
   return { score: computePiiScore(findings), countsByType };
 }
-var NER_MODEL_CACHE_DIR = path28.join(os3.homedir(), ".cache", "opencode-swarm", "models");
+var NER_MODEL_CACHE_DIR = path29.join(os3.homedir(), ".cache", "opencode-swarm", "models");
 
 // src/memory/redaction.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 var SECRET_PATTERNS = [
   { type: "openai_api_key", pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
   {
@@ -20813,10 +21494,10 @@ function computeRedactionPolicyVersion(policy) {
 }
 var FINGERPRINT_ALGORITHM_VERSION = 2;
 var LEGACY_FINGERPRINT_ALGORITHM_VERSION = 1;
-var _internals29 = {
+var _internals30 = {
   currentAlgorithmVersion: FINGERPRINT_ALGORITHM_VERSION
 };
-function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVersion = _internals29.currentAlgorithmVersion) {
+function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVersion = _internals30.currentAlgorithmVersion) {
   const storedVersion = rawStoredVersion === undefined ? LEGACY_FINGERPRINT_ALGORITHM_VERSION : rawStoredVersion;
   if (typeof storedVersion !== "number" || !Number.isFinite(storedVersion)) {
     return { status: "unknown" };
@@ -20825,7 +21506,7 @@ function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVers
 }
 function computeMemoryCohortFingerprint(input) {
   const canonical = stableCanonicalStringify(input);
-  return createHash8("sha256").update(canonical).digest("hex").slice(0, 12);
+  return createHash9("sha256").update(canonical).digest("hex").slice(0, 12);
 }
 function buildMemoryCohortFingerprintInput(config) {
   return {
@@ -21123,7 +21804,7 @@ function stableScopeKey(scope) {
 }
 function computeMemoryContentHash(recordLike) {
   const normalized = normalizeMemoryText(recordLike.text).toLowerCase();
-  return createHash9("sha256").update(`${stableScopeKey(recordLike.scope)}
+  return createHash10("sha256").update(`${stableScopeKey(recordLike.scope)}
 ${recordLike.kind}
 ${normalized}`).digest("hex");
 }
@@ -21278,7 +21959,7 @@ function normalizeTags(tags) {
 // src/memory/local-jsonl-provider.ts
 var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
 import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "fs";
 import {
   appendFile as appendFile8,
   mkdir as mkdir11,
@@ -21287,7 +21968,7 @@ import {
   truncate,
   writeFile as writeFile7
 } from "fs/promises";
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/memory/q-learning.ts
 function clamp01(value) {
@@ -21865,7 +22546,7 @@ function proposalSort(a, b) {
 }
 
 // src/memory/outcome-events.ts
-import { createHash as createHash10, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash11, randomUUID as randomUUID5 } from "crypto";
 function newOutcomeGeneration() {
   return randomUUID5();
 }
@@ -21998,7 +22679,7 @@ function dedupeAnchors(anchors) {
   return [...byKey.values()].sort((a, b) => compareText(a.file, b.file) || compareText(a.symbol ?? "", b.symbol ?? ""));
 }
 function hash(value) {
-  return createHash10("sha256").update(value).digest("hex").slice(0, 32);
+  return createHash11("sha256").update(value).digest("hex").slice(0, 32);
 }
 function compareText(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
@@ -22023,10 +22704,10 @@ class LocalJsonlMemoryProvider {
   pathFor(file) {
     const filename = file === "memories" ? "memories.jsonl" : file === "proposals" ? "proposals.jsonl" : file === "audit" ? "audit.jsonl" : file === "reward-events" ? "reward-events.jsonl" : "outcome-events.jsonl";
     if (this.cohortRoot) {
-      return path29.join(this.cohortRoot, filename);
+      return path30.join(this.cohortRoot, filename);
     }
     const storageDir = this.config.storageDir.replace(/^\.swarm[/\\]?/, "");
-    return validateSwarmPath(this.rootDirectory, path29.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path30.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -22448,7 +23129,7 @@ class LocalJsonlMemoryProvider {
     await appendJsonl(this.pathFor("audit"), event);
   }
   async withOutcomeStoreLock(fn) {
-    const storageDirectory = path29.dirname(this.pathFor("memories"));
+    const storageDirectory = path30.dirname(this.pathFor("memories"));
     await mkdir11(storageDirectory, { recursive: true });
     const release = await lockfile6.lock(storageDirectory, {
       realpath: false,
@@ -22478,9 +23159,9 @@ class LocalJsonlMemoryProvider {
   }
   readOutcomeEventsSync() {
     const filePath = this.pathFor("outcome-events");
-    if (!existsSync15(filePath))
+    if (!existsSync16(filePath))
       return [];
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     const completeContent = content.endsWith(`
 `) ? content : content.slice(0, Math.max(0, content.lastIndexOf(`
 `) + 1));
@@ -22526,18 +23207,18 @@ class LocalJsonlMemoryProvider {
     if (!this.cohortRoot)
       return;
     try {
-      const markerPath = path29.join(this.cohortRoot, "memory.gen");
-      writeFileSync6(markerPath, String(Date.now()), "utf-8");
+      const markerPath = path30.join(this.cohortRoot, "memory.gen");
+      writeFileSync7(markerPath, String(Date.now()), "utf-8");
     } catch {}
   }
   assertCohortConfigFingerprint() {
     if (!this.cohortRoot)
       return;
-    const configPath = path29.join(this.cohortRoot, "memory-cohort-config.json");
-    if (!existsSync15(configPath))
+    const configPath = path30.join(this.cohortRoot, "memory-cohort-config.json");
+    if (!existsSync16(configPath))
       return;
     try {
-      const stored = JSON.parse(readFileSync12(configPath, "utf-8"));
+      const stored = JSON.parse(readFileSync13(configPath, "utf-8"));
       const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
       if (versionCheck.status === "unknown") {
         warn("[memory-cohort] cohort config has a present but non-numeric `algorithm_version`, so its fingerprint cannot be attributed to a known algorithm and the config-coherence check was skipped. Run `/swarm memory link` to rewrite the cohort fingerprint.", {
@@ -22650,7 +23331,7 @@ function validateLoadedProposals(values, config) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return [];
   const content = await readFile12(filePath, "utf-8");
   const records = [];
@@ -22727,12 +23408,12 @@ function parseRewardEvent(value) {
   };
 }
 async function appendJsonl(filePath, value) {
-  await mkdir11(path29.dirname(filePath), { recursive: true });
+  await mkdir11(path30.dirname(filePath), { recursive: true });
   await appendFile8(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir11(path29.dirname(filePath), { recursive: true });
+  await mkdir11(path30.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID6()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -22741,7 +23422,7 @@ async function writeJsonlAtomic(filePath, values) {
   await rename5(tmp, filePath);
 }
 async function repairIncompleteJsonlTail(filePath) {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return;
   const content = await readFile12(filePath, "utf-8");
   if (content.length === 0 || content.endsWith(`
@@ -22754,19 +23435,19 @@ async function repairIncompleteJsonlTail(filePath) {
 
 // src/memory/provider-pool.ts
 import { realpathSync as realpathSync3 } from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 
 // src/memory/sqlite-provider.ts
-import { createHash as createHash11, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash12, randomUUID as randomUUID7 } from "crypto";
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync13,
-  statSync as statSync7,
-  writeFileSync as writeFileSync7
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync14,
+  statSync as statSync8,
+  writeFileSync as writeFileSync8
 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import * as path33 from "path";
+import * as path34 from "path";
 
 // src/memory/embeddings/cache.ts
 var DEFAULT_CACHE_SIZE = 256;
@@ -22882,10 +23563,10 @@ function minMaxNormalise(candidates) {
 }
 
 // src/memory/embeddings/local-provider.ts
-import { mkdirSync as mkdirSync7 } from "fs";
+import { mkdirSync as mkdirSync8 } from "fs";
 import { createRequire } from "module";
 import * as os4 from "os";
-import * as path30 from "path";
+import * as path31 from "path";
 
 // src/memory/embeddings/types.ts
 class EmbeddingUnavailableError extends Error {
@@ -22907,20 +23588,20 @@ class EmbeddingVersionMismatchError extends Error {
 }
 
 // src/memory/embeddings/local-provider.ts
-var _internals30 = {
+var _internals31 = {
   resolveEmbeddingCacheDir() {
     let base;
     if (process.platform === "win32") {
-      base = process.env.LOCALAPPDATA || path30.join(os4.homedir(), "AppData", "Local");
+      base = process.env.LOCALAPPDATA || path31.join(os4.homedir(), "AppData", "Local");
     } else if (process.platform === "darwin") {
-      base = path30.join(os4.homedir(), "Library", "Caches");
+      base = path31.join(os4.homedir(), "Library", "Caches");
     } else {
-      base = process.env.XDG_CACHE_HOME || path30.join(os4.homedir(), ".cache");
+      base = process.env.XDG_CACHE_HOME || path31.join(os4.homedir(), ".cache");
     }
-    const resolved = path30.join(base, "opencode", "embeddings");
-    const segments = resolved.split(path30.sep);
+    const resolved = path31.join(base, "opencode", "embeddings");
+    const segments = resolved.split(path31.sep);
     if (segments.includes(".swarm")) {
-      const safeDefault = process.platform === "win32" ? path30.join(os4.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path30.join(os4.homedir(), "Library", "Caches", "opencode", "embeddings") : path30.join(os4.homedir(), ".cache", "opencode", "embeddings");
+      const safeDefault = process.platform === "win32" ? path31.join(os4.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path31.join(os4.homedir(), "Library", "Caches", "opencode", "embeddings") : path31.join(os4.homedir(), ".cache", "opencode", "embeddings");
       warn("Embedding cache dir resolved under .swarm/ \u2014 falling back to safe default");
       return safeDefault;
     }
@@ -22928,7 +23609,7 @@ var _internals30 = {
   }
 };
 function resolveEmbeddingCacheDir() {
-  return _internals30.resolveEmbeddingCacheDir();
+  return _internals31.resolveEmbeddingCacheDir();
 }
 
 class LocalEmbeddingProvider {
@@ -22961,7 +23642,7 @@ class LocalEmbeddingProvider {
         console.log(`[opencode-swarm] Downloading embedding model "${this.modelName}" (~25 MB) \u2014 this happens once per process.`);
       }
       const cacheDir = resolveEmbeddingCacheDir();
-      mkdirSync7(cacheDir, { recursive: true });
+      mkdirSync8(cacheDir, { recursive: true });
       this.pipeline = await transformers.pipeline("feature-extraction", this.modelName, { cache_dir: cacheDir });
       this._available = true;
       return this.pipeline;
@@ -23035,10 +23716,10 @@ class LocalEmbeddingProvider {
 }
 
 // src/memory/embeddings/reranker.ts
-import { mkdirSync as mkdirSync8 } from "fs";
+import { mkdirSync as mkdirSync9 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as os5 from "os";
-import * as path31 from "path";
+import * as path32 from "path";
 function shouldRerank(previousRecallElapsedMs, latencyBudgetMs) {
   return previousRecallElapsedMs <= latencyBudgetMs;
 }
@@ -23064,7 +23745,7 @@ class CrossEncoderReranker {
       const transformers = req("@xenova/transformers");
       const modelName = this.options.model ?? "Xenova/ms-marco-MiniLM-L-6-v2";
       const cacheDir = resolveRerankerCacheDir();
-      mkdirSync8(cacheDir, { recursive: true });
+      mkdirSync9(cacheDir, { recursive: true });
       this.pipeline = await transformers.pipeline("text-classification", modelName, { cache_dir: cacheDir });
       this._available = true;
       return this.pipeline;
@@ -23106,16 +23787,16 @@ class CrossEncoderReranker {
 function resolveRerankerCacheDir() {
   let base;
   if (process.platform === "win32") {
-    base = process.env.LOCALAPPDATA || path31.join(os5.homedir(), "AppData", "Local");
+    base = process.env.LOCALAPPDATA || path32.join(os5.homedir(), "AppData", "Local");
   } else if (process.platform === "darwin") {
-    base = path31.join(os5.homedir(), "Library", "Caches");
+    base = path32.join(os5.homedir(), "Library", "Caches");
   } else {
-    base = process.env.XDG_CACHE_HOME || path31.join(os5.homedir(), ".cache");
+    base = process.env.XDG_CACHE_HOME || path32.join(os5.homedir(), ".cache");
   }
-  const resolved = path31.join(base, "opencode", "embeddings");
-  const segments = resolved.split(path31.sep);
+  const resolved = path32.join(base, "opencode", "embeddings");
+  const segments = resolved.split(path32.sep);
   if (segments.includes(".swarm")) {
-    const safeDefault = process.platform === "win32" ? path31.join(os5.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path31.join(os5.homedir(), "Library", "Caches", "opencode", "embeddings") : path31.join(os5.homedir(), ".cache", "opencode", "embeddings");
+    const safeDefault = process.platform === "win32" ? path32.join(os5.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path32.join(os5.homedir(), "Library", "Caches", "opencode", "embeddings") : path32.join(os5.homedir(), ".cache", "opencode", "embeddings");
     warn("Reranker cache dir resolved under .swarm/ \u2014 falling back to safe default");
     return safeDefault;
   }
@@ -23123,9 +23804,9 @@ function resolveRerankerCacheDir() {
 }
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync16, renameSync as renameSync5, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync17, renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
 import { copyFile, mkdir as mkdir12, readFile as readFile13, stat as stat4, writeFile as writeFile8 } from "fs/promises";
-import * as path32 from "path";
+import * as path33 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 var LEGACY_JSONL_OUTCOME_META_KEY = "legacy_jsonl_outcomes_import_complete";
@@ -23142,9 +23823,9 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path32.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path32.join(storageDir, "proposals.jsonl"), resolved);
-  const outcomeLoad = await readOutcomeJsonl(path32.join(storageDir, "outcome-events.jsonl"));
+  const memoryLoad = await readMemoryJsonl(path33.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path33.join(storageDir, "proposals.jsonl"), resolved);
+  const outcomeLoad = await readOutcomeJsonl(path33.join(storageDir, "outcome-events.jsonl"));
   return {
     memories: memoryLoad.records,
     memoryRows: memoryLoad.rows,
@@ -23161,7 +23842,7 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path32.join(storageDir, "backups");
+  const backupDir = path33.join(storageDir, "backups");
   await mkdir12(backupDir, { recursive: true });
   const results = [];
   for (const filename of [
@@ -23169,11 +23850,11 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
     "proposals.jsonl",
     "outcome-events.jsonl"
   ]) {
-    const source = path32.join(storageDir, filename);
-    if (!existsSync16(source))
+    const source = path33.join(storageDir, filename);
+    if (!existsSync17(source))
       continue;
-    const backup = path32.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync16(backup)) {
+    const backup = path33.join(backupDir, `${filename}.pre-sqlite-migration`);
+    if (existsSync17(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
@@ -23183,62 +23864,62 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals, outcomeEvents = []) {
-  const exportDir = path32.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path33.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir12(exportDir, { recursive: true });
-  const memoriesPath = path32.join(exportDir, "memories.jsonl");
-  const proposalsPath = path32.join(exportDir, "proposals.jsonl");
-  const outcomesPath = path32.join(exportDir, "outcome-events.jsonl");
-  const memoriesTempPath = path32.join(path32.dirname(memoriesPath), `${path32.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const memoriesPath = path33.join(exportDir, "memories.jsonl");
+  const proposalsPath = path33.join(exportDir, "proposals.jsonl");
+  const outcomesPath = path33.join(exportDir, "outcome-events.jsonl");
+  const memoriesTempPath = path33.join(path33.dirname(memoriesPath), `${path33.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile8(memoriesTempPath, toJsonl(memories), "utf-8");
-    renameSync5(memoriesTempPath, memoriesPath);
+    renameSync6(memoriesTempPath, memoriesPath);
   } catch (err) {
     try {
-      unlinkSync3(memoriesTempPath);
+      unlinkSync4(memoriesTempPath);
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path32.join(path32.dirname(proposalsPath), `${path32.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path33.join(path33.dirname(proposalsPath), `${path33.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile8(proposalsTempPath, toJsonl(proposals), "utf-8");
-    renameSync5(proposalsTempPath, proposalsPath);
+    renameSync6(proposalsTempPath, proposalsPath);
   } catch (err) {
     try {
-      unlinkSync3(proposalsTempPath);
+      unlinkSync4(proposalsTempPath);
     } catch {}
     throw err;
   }
-  const outcomesTempPath = path32.join(path32.dirname(outcomesPath), `${path32.basename(outcomesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const outcomesTempPath = path33.join(path33.dirname(outcomesPath), `${path33.basename(outcomesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile8(outcomesTempPath, toJsonl(outcomeEvents), "utf-8");
-    renameSync5(outcomesTempPath, outcomesPath);
+    renameSync6(outcomesTempPath, outcomesPath);
   } catch (err) {
     try {
-      unlinkSync3(outcomesTempPath);
+      unlinkSync4(outcomesTempPath);
     } catch {}
     throw err;
   }
   return { directory: exportDir, memoriesPath, proposalsPath, outcomesPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  const reportPath = path32.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  await mkdir12(path32.dirname(reportPath), { recursive: true });
-  const reportTempPath = path32.join(path32.dirname(reportPath), `${path32.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const reportPath = path33.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir12(path33.dirname(reportPath), { recursive: true });
+  const reportTempPath = path33.join(path33.dirname(reportPath), `${path33.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile8(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
-    renameSync5(reportTempPath, reportPath);
+    renameSync6(reportTempPath, reportPath);
   } catch (err) {
     try {
-      unlinkSync3(reportTempPath);
+      unlinkSync4(reportTempPath);
     } catch {}
     throw err;
   }
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path32.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  if (!existsSync16(reportPath))
+  const reportPath = path33.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  if (!existsSync17(reportPath))
     return null;
   try {
     return JSON.parse(await readFile13(reportPath, "utf-8"));
@@ -23254,23 +23935,23 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
     "proposals.jsonl",
     "outcome-events.jsonl"
   ]) {
-    const filePath = path32.join(storageDir, file);
+    const filePath = path33.join(storageDir, file);
     let sizeBytes = 0;
-    if (existsSync16(filePath)) {
+    if (existsSync17(filePath)) {
       sizeBytes = (await stat4(filePath)).size;
     }
     statuses.push({
       file,
       path: filePath,
-      exists: existsSync16(filePath),
+      exists: existsSync17(filePath),
       sizeBytes
     });
   }
   return statuses;
 }
 async function getLegacyOutcomeJsonlSignature(rootDirectory, config = {}) {
-  const filePath = path32.join(resolveMemoryStorageDir(rootDirectory, config), "outcome-events.jsonl");
-  if (!existsSync16(filePath))
+  const filePath = path33.join(resolveMemoryStorageDir(rootDirectory, config), "outcome-events.jsonl");
+  if (!existsSync17(filePath))
     return "missing";
   const details = await stat4(filePath);
   return `${details.size}:${details.mtimeMs}`;
@@ -23392,7 +24073,7 @@ async function readOutcomeJsonl(filePath) {
   return { records, rows: validRows, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile13(filePath, "utf-8");
@@ -23426,7 +24107,7 @@ function toJsonl(values) {
 var EVENT_CHAIN_GENESIS = "GENESIS";
 var MEMORY_EVENTS_CHAIN_HEAD_KEY = "memory_events_chain_head";
 function memoryEventRowHash(row) {
-  return createHash11("sha256").update(stableCanonicalStringify({
+  return createHash12("sha256").update(stableCanonicalStringify({
     id: row.id,
     operation: row.operation,
     target_id: row.target_id,
@@ -23771,7 +24452,7 @@ class SQLiteMemoryProvider {
   }
   databasePath() {
     if (this.cohortRoot) {
-      return path33.join(this.cohortRoot, "memory.db");
+      return path34.join(this.cohortRoot, "memory.db");
     }
     const relativePath2 = this.config.sqlite.path.replace(/^\.swarm[/\\]?/, "");
     return validateSwarmPath(this.rootDirectory, relativePath2);
@@ -23792,7 +24473,7 @@ class SQLiteMemoryProvider {
     if (this.cohortRoot) {
       this.assertCohortConfigFingerprint();
     }
-    mkdirSync9(path33.dirname(dbPath), { recursive: true });
+    mkdirSync10(path34.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor();
     this.db = new Db(dbPath);
     try {
@@ -24446,13 +25127,13 @@ class SQLiteMemoryProvider {
       }
       try {
         const wal = `${dbPath}-wal`;
-        const st = statSync7(wal);
+        const st = statSync8(wal);
         if (st.size > 0)
           walPath2 = wal;
       } catch {}
       try {
         const shm = `${dbPath}-shm`;
-        const st = statSync7(shm);
+        const st = statSync8(shm);
         if (st.size > 0)
           shmPath = shm;
       } catch {}
@@ -24864,9 +25545,9 @@ class SQLiteMemoryProvider {
     try {
       const dimension = Math.max(1, Math.trunc(this.config.embeddings.dimension ?? 384));
       const req = createRequire3(import.meta.url);
-      const pkgDir = path33.dirname(req.resolve("@sqlite/sqlite-vec/package.json"));
+      const pkgDir = path34.dirname(req.resolve("@sqlite/sqlite-vec/package.json"));
       const ext = process.platform === "win32" ? ".dll" : process.platform === "darwin" ? ".dylib" : ".so";
-      const vec0Path = path33.join(pkgDir, `vec0${ext}`);
+      const vec0Path = path34.join(pkgDir, `vec0${ext}`);
       db.loadExtension(vec0Path);
       db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS memory_items_vec USING vec0(
 				id TEXT PRIMARY KEY, embedding FLOAT[${dimension}]
@@ -25075,20 +25756,20 @@ class SQLiteMemoryProvider {
     if (!this.cohortRoot)
       return;
     try {
-      const markerPath = path33.join(this.cohortRoot, "memory.gen");
-      writeFileSync7(markerPath, String(Date.now()), "utf-8");
+      const markerPath = path34.join(this.cohortRoot, "memory.gen");
+      writeFileSync8(markerPath, String(Date.now()), "utf-8");
     } catch {}
   }
   assertCohortConfigFingerprint() {
     if (!this.cohortRoot)
       return;
-    const configPath = path33.join(this.cohortRoot, "memory-cohort-config.json");
-    if (!existsSync17(configPath)) {
+    const configPath = path34.join(this.cohortRoot, "memory-cohort-config.json");
+    if (!existsSync18(configPath)) {
       warn("[memory-cohort] cohort config fingerprint file is absent; config-coherence check skipped. Run `/swarm memory link` to re-establish the fingerprint.", { cohortRoot: this.cohortRoot });
       return;
     }
     try {
-      const stored = JSON.parse(readFileSync13(configPath, "utf-8"));
+      const stored = JSON.parse(readFileSync14(configPath, "utf-8"));
       const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
       if (versionCheck.status === "unknown") {
         warn("[memory-cohort] cohort config has a present but non-numeric `algorithm_version`, so its fingerprint cannot be attributed to a known algorithm and the config-coherence check was skipped. Run `/swarm memory link` to rewrite the cohort fingerprint.", {
@@ -25808,7 +26489,7 @@ function resolvePoolKeyForRoot(root) {
     try {
       return `cohort:${realpathSync3(root.cohortRoot)}`;
     } catch {
-      return `cohort:${path34.resolve(root.cohortRoot)}`;
+      return `cohort:${path35.resolve(root.cohortRoot)}`;
     }
   }
   return resolvePoolKey(root.directory);
@@ -25887,7 +26568,7 @@ function unlinkEntry(entry) {
     tail = entry.prev;
 }
 function resolvePoolKey(directory) {
-  const rawKey = path34.resolve(directory);
+  const rawKey = path35.resolve(directory);
   try {
     const canonical = realpathSync3(directory);
     resolvedKeyCache.delete(rawKey);
@@ -25920,24 +26601,24 @@ function evictAndClose(directory) {
 
 // src/memory/storage-root.ts
 init_logger();
-import * as path36 from "path";
+import * as path37 from "path";
 
 // src/memory/memory-link.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync14, rmSync as rmSync2, statSync as statSync8 } from "fs";
-import * as path35 from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync15, rmSync as rmSync2, statSync as statSync9 } from "fs";
+import * as path36 from "path";
 init_logger();
 var MEMORY_LINK_POINTER_FILENAME = "memory-link.json";
 var CACHE_TTL_MS = 2000;
 var MAX_CACHE_ENTRIES = 500;
 function resolveMemoryLinkPointerPath(directory) {
-  return path35.join(directory, ".swarm", MEMORY_LINK_POINTER_FILENAME);
+  return path36.join(directory, ".swarm", MEMORY_LINK_POINTER_FILENAME);
 }
 function readMemoryLinkPointer(directory) {
   const pointerPath = resolveMemoryLinkPointerPath(directory);
-  if (!existsSync18(pointerPath))
+  if (!existsSync19(pointerPath))
     return null;
   try {
-    const raw = JSON.parse(readFileSync14(pointerPath, "utf-8"));
+    const raw = JSON.parse(readFileSync15(pointerPath, "utf-8"));
     if (!raw || typeof raw !== "object")
       return null;
     const obj = raw;
@@ -25965,8 +26646,8 @@ function readMemoryLinkPointer(directory) {
   }
 }
 async function writeMemoryLinkPointer(directory, pointer) {
-  const swarmDir = path35.join(directory, ".swarm");
-  mkdirSync10(swarmDir, { recursive: true });
+  const swarmDir = path36.join(directory, ".swarm");
+  mkdirSync11(swarmDir, { recursive: true });
   const pointerPath = resolveMemoryLinkPointerPath(directory);
   await atomicWriteFile(pointerPath, JSON.stringify(pointer, null, 2));
   invalidateMemoryStoreDirCache(directory);
@@ -25983,14 +26664,14 @@ var _resolutionCache = new Map;
 function pointerStatFingerprint(directory) {
   const pointerPath = resolveMemoryLinkPointerPath(directory);
   try {
-    const st = statSync8(pointerPath);
+    const st = statSync9(pointerPath);
     return `${st.mtimeMs}:${st.ctimeMs}:${st.size}`;
   } catch {
     return null;
   }
 }
 function resolveMemoryStoreDir(directory) {
-  const localSwarm = path35.join(directory, ".swarm");
+  const localSwarm = path36.join(directory, ".swarm");
   const now2 = Date.now();
   const cached = _resolutionCache.get(directory);
   const currentStat = pointerStatFingerprint(directory);
@@ -26001,7 +26682,7 @@ function resolveMemoryStoreDir(directory) {
   try {
     const pointer = readMemoryLinkPointer(directory);
     if (pointer) {
-      linkDir = path35.resolve(resolveLinkDir(pointer.linkId));
+      linkDir = path36.resolve(resolveLinkDir(pointer.linkId));
     }
   } catch {
     linkDir = null;
@@ -26041,13 +26722,13 @@ function resolveVettedMemoryRoot(directory, config) {
     return wrapLocalRoot(directory);
   }
   const sharedDir = resolveMemoryStoreDir(directory);
-  const localSwarm = path36.join(directory, ".swarm");
+  const localSwarm = path37.join(directory, ".swarm");
   if (sharedDir === localSwarm) {
     return wrapLocalRoot(directory);
   }
   return {
     kind: "cohort",
-    cohortRoot: path36.join(sharedDir, "memory"),
+    cohortRoot: path37.join(sharedDir, "memory"),
     cohortId: pointer.cohortId ?? pointer.linkId,
     generation: pointer.generation ?? 0,
     linkId: pointer.linkId,
@@ -26058,7 +26739,7 @@ function wrapLocalRoot(directory) {
   log("[memory] wrapping raw directory as local vetted root \u2014 cohort sharing inactive for this caller", { directory });
   return {
     kind: "local",
-    root: path36.join(directory, ".swarm"),
+    root: path37.join(directory, ".swarm"),
     directory
   };
 }
@@ -26066,7 +26747,7 @@ function isCohortRoot(root) {
   return root.kind === "cohort";
 }
 function rootStoragePath(root) {
-  return root.kind === "cohort" ? root.cohortRoot : path36.join(root.root, "memory");
+  return root.kind === "cohort" ? root.cohortRoot : path37.join(root.root, "memory");
 }
 
 // src/memory/gateway.ts
@@ -26338,7 +27019,7 @@ async function runFinalizeRewardSweep(args) {
     }
     const timestamp = args.timestamp ?? new Date().toISOString();
     const vettedRoot = resolveVettedMemoryRoot(directory, memoryConfig);
-    const provider = _internals31.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
+    const provider = _internals32.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
     try {
       result.swept = true;
       for (const taskId of taskIds) {
@@ -26358,7 +27039,7 @@ async function runFinalizeRewardSweep(args) {
         }
         let taskRewarded = 0;
         for (const runId of runIds) {
-          const { memoriesRewarded } = await _internals31.applyCouncilReward(provider, {
+          const { memoriesRewarded } = await _internals32.applyCouncilReward(provider, {
             runId,
             unitId: taskId,
             reward: FINALIZE_NEGATIVE_TERMINAL_REWARD,
@@ -26384,15 +27065,15 @@ async function runFinalizeRewardSweep(args) {
   }
   return result;
 }
-var _internals31 = {
+var _internals32 = {
   createConfiguredMemoryProvider,
   createConfiguredMemoryProviderForRoot,
   applyCouncilReward
 };
 
 // src/services/session-reflection.ts
-import { promises as fs13 } from "fs";
-import * as path37 from "path";
+import { promises as fs14 } from "fs";
+import * as path38 from "path";
 
 // src/hooks/skill-improver-llm-factory.ts
 init_schema();
@@ -26569,13 +27250,13 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
   const lessons = [];
   const taxonomy = {};
   try {
-    const evidenceDir = path37.join(directory, ".swarm", "evidence");
-    const entries = await fs13.readdir(evidenceDir);
+    const evidenceDir = path38.join(directory, ".swarm", "evidence");
+    const entries = await fs14.readdir(evidenceDir);
     const retroDirs = entries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path37.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path38.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs13.readFile(evidencePath, "utf-8");
+        const content = await fs14.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const bundleEntries = parsed.entries ?? [parsed];
         for (const entry of bundleEntries) {
@@ -26602,14 +27283,14 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
 async function gatherGateFailures(directory) {
   const failures = new Map;
   try {
-    const evidenceDir = path37.join(directory, ".swarm", "evidence");
-    const entries = await fs13.readdir(evidenceDir);
+    const evidenceDir = path38.join(directory, ".swarm", "evidence");
+    const entries = await fs14.readdir(evidenceDir);
     for (const entry of entries) {
       if (entry.startsWith("retro-"))
         continue;
-      const evidencePath = path37.join(evidenceDir, entry, "evidence.json");
+      const evidencePath = path38.join(evidenceDir, entry, "evidence.json");
       try {
-        const content = await fs13.readFile(evidencePath, "utf-8");
+        const content = await fs14.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const bundleEntries = parsed.entries ?? [parsed];
         for (const e of bundleEntries) {
@@ -26642,7 +27323,7 @@ async function gatherLedgerRejections(directory, sessionId) {
   const counts = {};
   const readLedger = async (filePath) => {
     try {
-      const handle = await fs13.open(filePath, "r");
+      const handle = await fs14.open(filePath, "r");
       try {
         const stat5 = await handle.stat();
         if (!stat5.isFile())
@@ -26659,23 +27340,23 @@ async function gatherLedgerRejections(directory, sessionId) {
     }
   };
   const readContained = async (root, ...segments) => {
-    const target = path37.join(root, ...segments);
+    const target = path38.join(root, ...segments);
     try {
-      const realRoot = await fs13.realpath(path37.join(root));
-      const realTarget = await fs13.realpath(target);
-      const rel = path37.relative(realRoot, realTarget);
-      if (rel.startsWith("..") || path37.isAbsolute(rel))
+      const realRoot = await fs14.realpath(path38.join(root));
+      const realTarget = await fs14.realpath(target);
+      const rel = path38.relative(realRoot, realTarget);
+      if (rel.startsWith("..") || path38.isAbsolute(rel))
         return null;
     } catch {
       return null;
     }
     return readLedger(target);
   };
-  let content = await readLedger(path37.join(directory, ".swarm", "events.jsonl"));
+  let content = await readLedger(path38.join(directory, ".swarm", "events.jsonl"));
   if (content === null) {
     try {
-      const archiveRoot = path37.join(directory, ".swarm", "archive");
-      const archiveEntries = await fs13.readdir(archiveRoot);
+      const archiveRoot = path38.join(directory, ".swarm", "archive");
+      const archiveEntries = await fs14.readdir(archiveRoot);
       const archives = archiveEntries.filter((entry) => entry.startsWith("swarm-")).sort();
       for (let index = archives.length - 1;index >= 0 && content === null; index--) {
         content = await readContained(archiveRoot, archives[index], "events.jsonl");
@@ -26718,7 +27399,7 @@ function gatherSkillViolations(directory, sessionId) {
   if (!sessionId)
     return [];
   try {
-    const entries = _internals32.readSkillUsageEntriesTail(directory, {
+    const entries = _internals33.readSkillUsageEntriesTail(directory, {
       sessionID: sessionId
     });
     const bySkill = new Map;
@@ -26751,7 +27432,7 @@ async function gatherContradictionCandidates(directory, sessionStart, dedupThres
   if (!Number.isFinite(sessionStartMs))
     return [];
   try {
-    const all = await _internals32.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const all = await _internals33.readKnowledge(resolveSwarmKnowledgePath(directory));
     const sessionCreated = all.filter((e) => {
       if (typeof e.created_at !== "string")
         return false;
@@ -26799,7 +27480,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
   if (!Number.isFinite(sessionStartMs))
     return;
   try {
-    const entries = await _internals32.readKnowledge(resolveSwarmKnowledgePath(directory));
+    const entries = await _internals33.readKnowledge(resolveSwarmKnowledgePath(directory));
     let admitted = 0;
     let reinforced = 0;
     for (const e of entries) {
@@ -26818,7 +27499,7 @@ async function gatherRealtimeAdmissionCounts(directory, sessionStart) {
     }
     let rejected = 0;
     try {
-      const rejectedLessons = await _internals32.readRejectedLessons(directory);
+      const rejectedLessons = await _internals33.readRejectedLessons(directory);
       rejected = rejectedLessons.filter((r) => {
         const ms = Date.parse(r.rejected_at ?? "");
         return Number.isFinite(ms) && ms >= sessionStartMs;
@@ -27132,10 +27813,10 @@ async function runSessionReflection(input) {
   const agentDispatches = gatherAgentDispatches(input.agentSessions);
   const { lessons, taxonomy } = await gatherRetroLessonsAndTaxonomy(input.directory);
   const gateFailures = await gatherGateFailures(input.directory);
-  const ledgerRejections = await _internals32.gatherLedgerRejections(input.directory, input.sessionId);
-  const skillViolations = _internals32.gatherSkillViolations(input.directory, input.sessionId);
-  const contradictionCandidates = await _internals32.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
-  const realtimeCounts = await _internals32.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
+  const ledgerRejections = await _internals33.gatherLedgerRejections(input.directory, input.sessionId);
+  const skillViolations = _internals33.gatherSkillViolations(input.directory, input.sessionId);
+  const contradictionCandidates = await _internals33.gatherContradictionCandidates(input.directory, input.sessionStart, input.dedupThreshold ?? DEFAULT_DEDUP_THRESHOLD2);
+  const realtimeCounts = await _internals33.gatherRealtimeAdmissionCounts(input.directory, input.sessionStart);
   const knowledgeDelta = input.knowledgeDelta ? {
     ...input.knowledgeDelta,
     admitted: realtimeCounts?.admitted ?? input.knowledgeDelta.admitted,
@@ -27193,10 +27874,10 @@ async function writeSessionReflection(directory, result) {
   lines.push(result.architectReport);
   const content = lines.join(`
 `);
-  await fs13.writeFile(reflectionPath, content, "utf-8");
+  await fs14.writeFile(reflectionPath, content, "utf-8");
   return reflectionPath;
 }
-var _internals32 = {
+var _internals33 = {
   gatherToolProblems,
   gatherAgentDispatches,
   gatherRetroLessonsAndTaxonomy,
@@ -27216,14 +27897,14 @@ var _internals32 = {
 };
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { mkdir as mkdir14, readFile as readFile14 } from "fs/promises";
-import * as path39 from "path";
+import * as path40 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir13, writeFile as writeFile9 } from "fs/promises";
-import * as path38 from "path";
+import * as path39 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
 var MOTIF_MIN_TASKS = 2;
@@ -27383,14 +28064,14 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals33.now().toISOString();
+    const producedAt = _internals34.now().toISOString();
     const candidates = selected.map((motif) => buildMotifCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals33.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals34.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
       return result;
-    const proposalsDir = validateSwarmPath(directory, path38.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path39.join("skills", "proposals"));
     await mkdir13(proposalsDir, { recursive: true });
     const written = [];
     for (const decision of emitted) {
@@ -27399,7 +28080,7 @@ async function writeMotifProposals(directory, opts = {}) {
       if (motif === undefined || candidate === undefined)
         continue;
       const slug = `motif-${slugify(motif.signature)}`;
-      const filePath = path38.join(proposalsDir, `${slug}.md`);
+      const filePath = path39.join(proposalsDir, `${slug}.md`);
       await writeFile9(filePath, buildMotifProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
@@ -27407,7 +28088,7 @@ async function writeMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals33.recordEmittedRecommendations(directory, written, {
+    await _internals34.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -27573,14 +28254,14 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals33.now().toISOString();
+    const producedAt = _internals34.now().toISOString();
     const candidates = selected.map((motif) => buildWorkflowCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals33.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals34.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
       return result;
-    const proposalsDir = validateSwarmPath(directory, path38.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path39.join("skills", "proposals"));
     await mkdir13(proposalsDir, { recursive: true });
     const written = [];
     for (const decision of emitted) {
@@ -27589,7 +28270,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       if (motif === undefined || candidate === undefined)
         continue;
       const slug = workflowSlug(motif.signature);
-      const filePath = path38.join(proposalsDir, `${slug}.md`);
+      const filePath = path39.join(proposalsDir, `${slug}.md`);
       await writeFile9(filePath, buildWorkflowProposal(motif, {
         fingerprint: decision.fingerprint,
         producedAt
@@ -27597,7 +28278,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals33.recordEmittedRecommendations(directory, written, {
+    await _internals34.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -27606,21 +28287,21 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     return result;
   }
 }
-var _internals33 = {
+var _internals34 = {
   now: () => new Date,
   checkRecommendations,
   recordEmittedRecommendations
 };
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 init_logger();
 var HARDENING_BATCH_LIMIT = 5;
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync19(queuePath))
+    if (!existsSync20(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -27724,13 +28405,13 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir14(path39.dirname(p), { recursive: true });
+  await mkdir14(path40.dirname(p), { recursive: true });
   await atomicWriteSwarmFile(p, content);
 }
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath2();
-  const hive = existsSync20(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync21(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -27933,7 +28614,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals34.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals35.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -28125,8 +28806,8 @@ async function runSkillImprover(req) {
     }
     throw err;
   }
-  const proposalDir = path39.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path39.join(proposalDir, `${timestampSlug(now2)}.md`);
+  const proposalDir = path40.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path40.join(proposalDir, `${timestampSlug(now2)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body,
     targets,
@@ -28189,7 +28870,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals34 = {
+var _internals35 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -28201,9 +28882,9 @@ var _internals34 = {
 };
 
 // src/services/swarm-residue.ts
-import { createHash as createHash12 } from "crypto";
-import * as fs14 from "fs";
-import * as path40 from "path";
+import { createHash as createHash13 } from "crypto";
+import * as fs15 from "fs";
+import * as path41 from "path";
 var RESIDUE_STALE_AGE_MS = 30 * 60000;
 var MAX_RESIDUE_SCAN_ENTRIES = 20000;
 var RESIDUE_SCAN_DEPTH = 8;
@@ -28213,10 +28894,10 @@ var RESIDUE_SKIP_DIRS = Object.freeze([
   "quarantine",
   "locks"
 ]);
-var _internals35 = {
+var _internals36 = {
   now: () => Date.now(),
   renameResidueEntry: (from, to) => {
-    fs14.renameSync(from, to);
+    fs15.renameSync(from, to);
   },
   queryTracked: (projectRoot, swarmRoot) => {
     const result = bunSpawnSync([
@@ -28225,7 +28906,7 @@ var _internals35 = {
       "core.quotepath=false",
       "ls-files",
       "--",
-      swarmRoot.split(path40.sep).join("/")
+      swarmRoot.split(path41.sep).join("/")
     ], {
       cwd: projectRoot,
       stdin: "ignore",
@@ -28243,30 +28924,30 @@ var _internals35 = {
     for (const line of out.split(/\r?\n/)) {
       const t = line.trim();
       if (t)
-        tracked.add(path40.normalize(path40.resolve(projectRoot, t)));
+        tracked.add(path41.normalize(path41.resolve(projectRoot, t)));
     }
     return { tracked };
   },
   activeLockTargets: (directory) => {
     const targets = new Set;
     for (const lock of listActiveLocks(directory)) {
-      targets.add(path40.normalize(path40.resolve(directory, lock.filePath)));
+      targets.add(path41.normalize(path41.resolve(directory, lock.filePath)));
     }
     return targets;
   },
   sha256File: (absPath) => {
-    const hash2 = createHash12("sha256");
-    const fd = fs14.openSync(absPath, "r");
+    const hash2 = createHash13("sha256");
+    const fd = fs15.openSync(absPath, "r");
     try {
       const chunk = Buffer.alloc(1024 * 1024);
       for (;; ) {
-        const read = fs14.readSync(fd, chunk, 0, chunk.byteLength, null);
+        const read = fs15.readSync(fd, chunk, 0, chunk.byteLength, null);
         if (read === 0)
           break;
         hash2.update(chunk.subarray(0, read));
       }
     } finally {
-      fs14.closeSync(fd);
+      fs15.closeSync(fd);
     }
     return hash2.digest("hex");
   }
@@ -28278,10 +28959,10 @@ function collectCandidates(swarmRoot) {
   const walk = (relDir, depth) => {
     if (truncated)
       return;
-    const absDir = relDir === "" ? swarmRoot : path40.join(swarmRoot, ...relDir.split("/"));
+    const absDir = relDir === "" ? swarmRoot : path41.join(swarmRoot, ...relDir.split("/"));
     let dirents;
     try {
-      dirents = fs14.readdirSync(absDir, { withFileTypes: true });
+      dirents = fs15.readdirSync(absDir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -28305,7 +28986,7 @@ function collectCandidates(swarmRoot) {
       let mtimeMs = 0;
       if (!dirent.isSymbolicLink()) {
         try {
-          const st = fs14.lstatSync(path40.join(swarmRoot, ...rel.split("/")));
+          const st = fs15.lstatSync(path41.join(swarmRoot, ...rel.split("/")));
           if (!st.isFile())
             continue;
           bytes = st.size;
@@ -28327,8 +29008,8 @@ function collectCandidates(swarmRoot) {
   return { items, scannedEntries, truncated };
 }
 async function inventorySwarmResidue(directory) {
-  const swarmRoot = path40.normalize(path40.resolve(directory, ".swarm"));
-  if (!fs14.existsSync(swarmRoot)) {
+  const swarmRoot = path41.normalize(path41.resolve(directory, ".swarm"));
+  if (!fs15.existsSync(swarmRoot)) {
     return {
       swarmRoot,
       scannedEntries: 0,
@@ -28344,15 +29025,15 @@ async function inventorySwarmResidue(directory) {
       gitState: "unknown"
     };
   }
-  const rootStat = fs14.lstatSync(swarmRoot);
+  const rootStat = fs15.lstatSync(swarmRoot);
   if (rootStat.isSymbolicLink()) {
     throw new Error(`Refusing to scan a symlinked .swarm root: ${swarmRoot}`);
   }
-  const projectRoot = path40.dirname(swarmRoot);
-  const { tracked } = _internals35.queryTracked(projectRoot, swarmRoot);
-  const lockTargets = _internals35.activeLockTargets(directory);
+  const projectRoot = path41.dirname(swarmRoot);
+  const { tracked } = _internals36.queryTracked(projectRoot, swarmRoot);
+  const lockTargets = _internals36.activeLockTargets(directory);
   const { items, scannedEntries, truncated } = collectCandidates(swarmRoot);
-  const now2 = _internals35.now();
+  const now2 = _internals36.now();
   const entries = [];
   for (const item of items) {
     const ageMs = Math.max(0, now2 - item.mtimeMs);
@@ -28360,7 +29041,7 @@ async function inventorySwarmResidue(directory) {
       if (ageMs < RESIDUE_STALE_AGE_MS)
         continue;
     }
-    const abs = path40.normalize(path40.join(swarmRoot, ...item.relPath.split("/")));
+    const abs = path41.normalize(path41.join(swarmRoot, ...item.relPath.split("/")));
     const reasons = [];
     if (!item.grammar.quarantineEligible)
       reasons.push("constant-name-grammar");
@@ -28378,7 +29059,7 @@ async function inventorySwarmResidue(directory) {
     }
     if (item.isSymlink)
       reasons.push("symlink");
-    const lockHeld = lockTargets.has(abs) || (item.grammar.parsesTarget ? lockTargets.has(path40.normalize(path40.join(path40.dirname(abs), parseTargetBasename(item.relPath.split("/").pop() ?? "") ?? ""))) : false);
+    const lockHeld = lockTargets.has(abs) || (item.grammar.parsesTarget ? lockTargets.has(path41.normalize(path41.join(path41.dirname(abs), parseTargetBasename(item.relPath.split("/").pop() ?? "") ?? ""))) : false);
     if (lockHeld)
       reasons.push("active-lock");
     if (item.bytes > RESIDUE_HASH_MAX_BYTES)
@@ -28386,10 +29067,10 @@ async function inventorySwarmResidue(directory) {
     if (item.grammar.quarantineEligible && item.grammar.parsesTarget) {
       const targetBasename = parseTargetBasename(item.relPath.split("/").pop() ?? "");
       if (targetBasename) {
-        const targetAbs = path40.join(path40.dirname(abs), targetBasename);
+        const targetAbs = path41.join(path41.dirname(abs), targetBasename);
         let targetOk = false;
         try {
-          targetOk = fs14.lstatSync(targetAbs).isFile();
+          targetOk = fs15.lstatSync(targetAbs).isFile();
         } catch {
           targetOk = false;
         }
@@ -28429,14 +29110,14 @@ async function inventorySwarmResidue(directory) {
   };
 }
 function validateRelPath(rel, what) {
-  if (!rel || path40.isAbsolute(rel) || rel.split("/").some((s) => s === ".." || s === "" || /[\0-\x1f]/.test(s))) {
+  if (!rel || path41.isAbsolute(rel) || rel.split("/").some((s) => s === ".." || s === "" || /[\0-\x1f]/.test(s))) {
     throw new Error(`unsafe ${what} in quarantine manifest: ${JSON.stringify(rel)}`);
   }
   return rel;
 }
 function sha256Bounded(absPath) {
   try {
-    return _internals35.sha256File(absPath);
+    return _internals36.sha256File(absPath);
   } catch {
     return;
   }
@@ -28454,8 +29135,8 @@ async function quarantineSwarmResidue(directory, options) {
   }
   const swarmRoot = inventory.swarmRoot;
   const batchId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 10)}`;
-  const batchAbs = path40.join(swarmRoot, "quarantine", batchId);
-  fs14.mkdirSync(batchAbs, { recursive: true });
+  const batchAbs = path41.join(swarmRoot, "quarantine", batchId);
+  fs15.mkdirSync(batchAbs, { recursive: true });
   const manifest = {
     schema_version: 1,
     batch_id: batchId,
@@ -28465,9 +29146,9 @@ async function quarantineSwarmResidue(directory, options) {
   };
   const moved = [];
   for (const entry of eligible) {
-    const abs = path40.join(swarmRoot, ...entry.relPath.split("/"));
+    const abs = path41.join(swarmRoot, ...entry.relPath.split("/"));
     try {
-      const st = fs14.lstatSync(abs);
+      const st = fs15.lstatSync(abs);
       if (!st.isFile() || st.size !== entry.bytes || st.mtimeMs !== entry.mtimeMs) {
         preserved.push({
           relPath: entry.relPath,
@@ -28493,10 +29174,10 @@ async function quarantineSwarmResidue(directory, options) {
       });
       continue;
     }
-    const storedAbs = path40.join(batchAbs, ...entry.relPath.split("/"));
+    const storedAbs = path41.join(batchAbs, ...entry.relPath.split("/"));
     try {
-      fs14.mkdirSync(path40.dirname(storedAbs), { recursive: true });
-      _internals35.renameResidueEntry(abs, storedAbs);
+      fs15.mkdirSync(path41.dirname(storedAbs), { recursive: true });
+      _internals36.renameResidueEntry(abs, storedAbs);
     } catch (moveErr) {
       const code = moveErr?.code ?? "unknown";
       preserved.push({
@@ -28508,7 +29189,7 @@ async function quarantineSwarmResidue(directory, options) {
     }
     manifest.entries.push({
       original_rel_path: entry.relPath,
-      stored_rel_path: path40.posix.join("quarantine", batchId, entry.relPath),
+      stored_rel_path: path41.posix.join("quarantine", batchId, entry.relPath),
       sha256: sha,
       bytes: entry.bytes,
       mtime_ms: entry.mtimeMs,
@@ -28519,12 +29200,12 @@ async function quarantineSwarmResidue(directory, options) {
   }
   let batchRelDir;
   if (manifest.entries.length > 0) {
-    atomicWriteSwarmFileSync(path40.join(batchAbs, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    atomicWriteSwarmFileSync(path41.join(batchAbs, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-    batchRelDir = path40.posix.join("quarantine", batchId);
+    batchRelDir = path41.posix.join("quarantine", batchId);
   } else {
     try {
-      fs14.rmSync(batchAbs, { recursive: true, force: true });
+      fs15.rmSync(batchAbs, { recursive: true, force: true });
     } catch {}
   }
   try {
@@ -28552,15 +29233,15 @@ async function quarantineSwarmResidue(directory, options) {
   };
 }
 function listQuarantineBatches(swarmRoot) {
-  const quarantineRoot = path40.join(swarmRoot, "quarantine");
+  const quarantineRoot = path41.join(swarmRoot, "quarantine");
   try {
-    return fs14.readdirSync(quarantineRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.isSymbolicLink()).map((d) => d.name).sort();
+    return fs15.readdirSync(quarantineRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.isSymbolicLink()).map((d) => d.name).sort();
   } catch {
     return [];
   }
 }
 async function rollbackResidueQuarantine(directory, batchId) {
-  const swarmRoot = path40.normalize(path40.resolve(directory, ".swarm"));
+  const swarmRoot = path41.normalize(path41.resolve(directory, ".swarm"));
   const batches = listQuarantineBatches(swarmRoot);
   if (batches.length === 0) {
     throw new Error("No quarantine batches found under .swarm/quarantine/");
@@ -28568,11 +29249,11 @@ async function rollbackResidueQuarantine(directory, batchId) {
   const selected = batchId ? batches.find((b) => b === batchId || b.endsWith(`-${batchId}`)) ?? (() => {
     throw new Error(`Quarantine batch not found: ${batchId}`);
   })() : batches[batches.length - 1];
-  const batchAbs = path40.join(swarmRoot, "quarantine", selected);
-  const manifestPath = path40.join(batchAbs, "manifest.json");
+  const batchAbs = path41.join(swarmRoot, "quarantine", selected);
+  const manifestPath = path41.join(batchAbs, "manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(fs14.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs15.readFileSync(manifestPath, "utf-8"));
   } catch {
     throw new Error(`Quarantine batch has no readable manifest.json: ${selected}`);
   }
@@ -28584,20 +29265,20 @@ async function rollbackResidueQuarantine(directory, batchId) {
   for (const entry of manifest.entries) {
     const originalRel = validateRelPath(entry.original_rel_path, "original_rel_path");
     const storedRel = validateRelPath(entry.stored_rel_path, "stored_rel_path");
-    const originalAbs = path40.join(swarmRoot, ...originalRel.split("/"));
-    const storedAbs = path40.join(swarmRoot, ...storedRel.split("/"));
-    if (!originalAbs.startsWith(swarmRoot + path40.sep) || !storedAbs.startsWith(batchAbs + path40.sep)) {
+    const originalAbs = path41.join(swarmRoot, ...originalRel.split("/"));
+    const storedAbs = path41.join(swarmRoot, ...storedRel.split("/"));
+    if (!originalAbs.startsWith(swarmRoot + path41.sep) || !storedAbs.startsWith(batchAbs + path41.sep)) {
       throw new Error(`Quarantine manifest path escapes its root: ${selected}`);
     }
-    if (!fs14.existsSync(storedAbs)) {
+    if (!fs15.existsSync(storedAbs)) {
       items.push({ relPath: originalRel, status: "missing-copy" });
       allResolved = false;
       continue;
     }
-    if (fs14.existsSync(originalAbs)) {
+    if (fs15.existsSync(originalAbs)) {
       const currentSha = sha256Bounded(originalAbs);
       if (currentSha === entry.sha256) {
-        fs14.unlinkSync(storedAbs);
+        fs15.unlinkSync(storedAbs);
         items.push({ relPath: originalRel, status: "already-restored" });
       } else {
         items.push({ relPath: originalRel, status: "collision" });
@@ -28605,17 +29286,17 @@ async function rollbackResidueQuarantine(directory, batchId) {
       }
       continue;
     }
-    fs14.mkdirSync(path40.dirname(originalAbs), { recursive: true });
-    fs14.renameSync(storedAbs, originalAbs);
+    fs15.mkdirSync(path41.dirname(originalAbs), { recursive: true });
+    fs15.renameSync(storedAbs, originalAbs);
     items.push({ relPath: originalRel, status: "restored" });
   }
   if (allResolved) {
     try {
-      fs14.rmSync(batchAbs, { recursive: true, force: true });
+      fs15.rmSync(batchAbs, { recursive: true, force: true });
     } catch {}
   }
   return {
-    batchRelDir: path40.posix.join("quarantine", selected),
+    batchRelDir: path41.posix.join("quarantine", selected),
     items,
     drained: allResolved
   };
@@ -28668,26 +29349,26 @@ function formatResidueInventoryLines(inv, options) {
 }
 
 // src/session/session-start-store.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync8 } from "fs";
-import * as path41 from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync9 } from "fs";
+import * as path42 from "path";
 var SESSION_START_FILE = "session-start.jsonl";
 function recordSessionStart(directory, startMs) {
   try {
-    const swarmDir = path41.join(directory, ".swarm");
-    const sessionDir = path41.join(swarmDir, "session");
-    const filePath = path41.join(sessionDir, SESSION_START_FILE);
+    const swarmDir = path42.join(directory, ".swarm");
+    const sessionDir = path42.join(swarmDir, "session");
+    const filePath = path42.join(sessionDir, SESSION_START_FILE);
     const line = JSON.stringify({ startMs, ts: Date.now() });
-    mkdirSync12(sessionDir, { recursive: true });
-    writeFileSync8(filePath, `${line}
+    mkdirSync13(sessionDir, { recursive: true });
+    writeFileSync9(filePath, `${line}
 `, { flag: "a" });
   } catch {}
 }
 function readEarliestSessionStart(directory) {
   try {
-    const filePath = path41.join(directory, ".swarm", "session", SESSION_START_FILE);
-    if (!existsSync22(filePath))
+    const filePath = path42.join(directory, ".swarm", "session", SESSION_START_FILE);
+    if (!existsSync23(filePath))
       return null;
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     const lines = content.split(`
 `);
     const validStartMs = [];
@@ -28711,8 +29392,8 @@ function readEarliestSessionStart(directory) {
 
 // src/tools/write-retro.ts
 init_zod();
-import { existsSync as existsSync23 } from "fs";
-import path42 from "path";
+import { existsSync as existsSync24 } from "fs";
+import path43 from "path";
 async function executeWriteRetro(args, directory) {
   if (/^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(:|$)/i.test(directory)) {
     return JSON.stringify({
@@ -28720,7 +29401,7 @@ async function executeWriteRetro(args, directory) {
       message: "Invalid directory: reserved device name"
     }, null, 2);
   }
-  if (!existsSync23(path42.join(directory, ".swarm"))) {
+  if (!existsSync24(path43.join(directory, ".swarm"))) {
     return JSON.stringify({
       success: false,
       message: `Cannot write evidence in "${directory}" \u2014 no .swarm/ folder was found. Run write_retro from an initialized project root.`
@@ -29071,13 +29752,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals36.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals37.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals36 = {
+var _internals37 = {
   executeWriteRetro,
   write_retro
 };
@@ -29086,9 +29767,9 @@ var _internals36 = {
 init_logger();
 
 // src/workflow/close-terminal.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 function createCloseTransitionId(planEpoch, taskId, target) {
-  const digest = createHash13("sha256").update(JSON.stringify([planEpoch, taskId, target]), "utf8").digest("hex");
+  const digest = createHash14("sha256").update(JSON.stringify([planEpoch, taskId, target]), "utf8").digest("hex");
   return `close-terminal:${digest}`;
 }
 function findTask(plan, taskId) {
@@ -29303,10 +29984,10 @@ async function reconcileCloseTerminalState(directory, targetPlan, options) {
 
 // src/commands/archive-sqlite.ts
 import * as fsSync from "fs";
-import path43 from "path";
+import path44 from "path";
 var DEFAULT_MAX_SOURCE_BYTES = 2 * 1024 * 1024 * 1024;
 var DEFAULT_BUSY_TIMEOUT_MS = 5000;
-var _internals37 = {
+var _internals38 = {
   existsSync: fsSync.existsSync,
   statSync: fsSync.statSync,
   renameSync: fsSync.renameSync,
@@ -29316,11 +29997,11 @@ var _internals37 = {
   DatabaseCtor: null
 };
 function resolveDatabaseCtor() {
-  return _internals37.DatabaseCtor ?? loadDatabaseCtor();
+  return _internals38.DatabaseCtor ?? loadDatabaseCtor();
 }
 function safeRemoveTemp(tempPath) {
   try {
-    _internals37.rmSync(tempPath, {
+    _internals38.rmSync(tempPath, {
       force: true,
       recursive: true,
       maxRetries: 3,
@@ -29376,7 +30057,7 @@ function captureRowCounts(db) {
 async function archiveSqliteSnapshot(opts) {
   const maxSourceBytes = opts.maxSourceBytes ?? DEFAULT_MAX_SOURCE_BYTES;
   const busyTimeoutMs = opts.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS;
-  if (!_internals37.existsSync(opts.sourcePath)) {
+  if (!_internals38.existsSync(opts.sourcePath)) {
     return {
       requiredness: "required",
       attempt: "not_attempted",
@@ -29389,10 +30070,10 @@ async function archiveSqliteSnapshot(opts) {
   let sourceBytes = 0;
   for (const suffix of ["", "-wal", "-shm"]) {
     const sidecar = opts.sourcePath + suffix;
-    if (!_internals37.existsSync(sidecar))
+    if (!_internals38.existsSync(sidecar))
       continue;
     try {
-      sourceBytes += _internals37.statSync(sidecar).size;
+      sourceBytes += _internals38.statSync(sidecar).size;
     } catch (err) {
       if (suffix === "") {
         return {
@@ -29418,8 +30099,8 @@ async function archiveSqliteSnapshot(opts) {
       detail: `source bytes ${sourceBytes} > budget ${maxSourceBytes}`
     };
   }
-  const destFinal = path43.join(opts.destDir, opts.destName);
-  const destTemp = path43.join(opts.destDir, `.${opts.destName}.tmp.${_internals37.now()}.${_internals37.randomSuffix()}`);
+  const destFinal = path44.join(opts.destDir, opts.destName);
+  const destTemp = path44.join(opts.destDir, `.${opts.destName}.tmp.${_internals38.now()}.${_internals38.randomSuffix()}`);
   let Db;
   try {
     Db = resolveDatabaseCtor();
@@ -29518,7 +30199,7 @@ async function archiveSqliteSnapshot(opts) {
     };
   }
   try {
-    _internals37.renameSync(destTemp, destFinal);
+    _internals38.renameSync(destTemp, destFinal);
   } catch (err) {
     safeRemoveTemp(destTemp);
     return {
@@ -29618,20 +30299,20 @@ function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
 async function copyDirRecursiveWithFailures(src, dest) {
   let count = 0;
   const failures = [];
-  const entries = await fs15.readdir(src);
-  await fs15.mkdir(dest, { recursive: true });
+  const entries = await fs16.readdir(src);
+  await fs16.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path44.join(src, entry);
-    const destEntry = path44.join(dest, entry);
+    const srcEntry = path45.join(src, entry);
+    const destEntry = path45.join(dest, entry);
     try {
-      const stat5 = await fs15.stat(srcEntry);
+      const stat5 = await fs16.stat(srcEntry);
       if (stat5.isDirectory()) {
         const subResult = await copyDirRecursiveWithFailures(srcEntry, destEntry);
         count += subResult.copied;
         failures.push(...subResult.failures);
       } else {
         try {
-          await fs15.copyFile(srcEntry, destEntry);
+          await fs16.copyFile(srcEntry, destEntry);
           count++;
         } catch (err) {
           const errno = err?.code;
@@ -29684,7 +30365,8 @@ var ARCHIVE_ARTIFACTS = [
   "background-delegations.jsonl",
   "background-delegations.checkpoint.json",
   "background-delegations.manifest.json",
-  "background-delegations-health.json"
+  "background-delegations-health.json",
+  "context-telemetry.jsonl"
 ];
 var ACTIVE_STATE_TO_CLEAN = [
   "plan.json",
@@ -29861,20 +30543,20 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path44.join(ctx.swarmDir, "close-lessons.md");
+  const lessonsFilePath = path45.join(ctx.swarmDir, "close-lessons.md");
   try {
-    const lessonsText = await fs15.readFile(lessonsFilePath, "utf-8");
+    const lessonsText = await fs16.readFile(lessonsFilePath, "utf-8");
     ctx.explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
   try {
-    const evidenceDir = path44.join(ctx.swarmDir, "evidence");
-    const evidenceEntries = await fs15.readdir(evidenceDir);
+    const evidenceDir = path45.join(ctx.swarmDir, "evidence");
+    const evidenceEntries = await fs16.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path44.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path45.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs15.readFile(evidencePath, "utf-8");
+        const content = await fs16.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const entries = parsed.entries ?? [parsed];
         for (const entry of entries) {
@@ -29908,8 +30590,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals38.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals38.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals39.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals39.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -29922,13 +30604,13 @@ async function runFinalizeStage(ctx) {
     log("[close-command] curateAndStoreSwarm error:", error2);
   }
   if (ctx.curationSucceeded && ctx.allLessons.length > 0) {
-    await fs15.unlink(lessonsFilePath).catch(() => {});
+    await fs16.unlink(lessonsFilePath).catch(() => {});
   }
   if (ctx.curationSucceeded) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals38.checkHivePromotions(entries, ctx.config, ctx.directory);
+        const result = await _internals39.checkHivePromotions(entries, ctx.config, ctx.directory);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -29949,7 +30631,7 @@ async function runFinalizeStage(ctx) {
   ctx.knowledgeSkillHint = ctx.sessionKnowledgeCreated > 0 ? `${ctx.sessionKnowledgeCreated} knowledge entries created this session. Consider running skill_improve or skill_generate to compile mature entries into skills.` : "";
   if (ctx.runSkillReview) {
     try {
-      const { config: loadedConfig } = _internals38.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -30046,7 +30728,7 @@ async function runFinalizeStage(ctx) {
     let terminalPlanPersisted = !ctx.planExists;
     if (ctx.planExists) {
       try {
-        const reconciled = await _internals38.closePlanTerminalState(ctx.directory, ctx.planData, {
+        const reconciled = await _internals39.closePlanTerminalState(ctx.directory, ctx.planData, {
           actor: ctx.options.sessionID ?? "close-command",
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           requestedClosedTaskIds: ctx.guaranteeResult.closedTaskIds,
@@ -30088,12 +30770,12 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-t8bmshhj.js");
-    const { config: pmLoadedConfig } = _internals38.loadPluginConfigWithMeta(ctx.directory);
+    const { CuratorConfigSchema: CCS } = await import("./schema-jhz9hme9.js");
+    const { config: pmLoadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals38.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals38.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals39.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals39.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -30112,15 +30794,21 @@ async function runFinalizeStage(ctx) {
 async function runArchiveStage(ctx) {
   ctx.timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   ctx.archiveSuffix = Math.random().toString(36).slice(2, 8);
-  ctx.archiveDir = path44.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
+  ctx.archiveDir = path45.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
-    await fs15.mkdir(ctx.archiveDir, { recursive: true });
+    await fs16.mkdir(ctx.archiveDir, { recursive: true });
     try {
-      await _internals38.flushAndDrainTelemetry();
+      await _internals39.flushAndDrainTelemetry();
     } catch (flushErr) {
       const msg = flushErr instanceof Error ? flushErr.message : String(flushErr);
       ctx.warnings.push(`Telemetry flush before archive failed: ${msg}`);
     }
+    try {
+      _internals39.finalizeContextTelemetry(ctx.directory);
+    } catch (finalizeErr) {
+      const msg = finalizeErr instanceof Error ? finalizeErr.message : String(finalizeErr);
+      ctx.warnings.push(`Context-map telemetry finalize before archive failed: ${msg}`);
+    }
     const linkedKnowledgeShared = isLinked(ctx.directory);
     if (linkedKnowledgeShared) {
       ctx.warnings.push("Worktree is linked: shared knowledge (knowledge.jsonl, knowledge-rejected.jsonl) lives in the link store and is not archived or cleaned by /swarm close. Manage it via the link.");
@@ -30129,8 +30817,8 @@ async function runArchiveStage(ctx) {
       if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
         continue;
       }
-      const srcPath = path44.join(ctx.swarmDir, artifact);
-      const destPath = path44.join(ctx.archiveDir, artifact);
+      const srcPath = path45.join(ctx.swarmDir, artifact);
+      const destPath = path45.join(ctx.archiveDir, artifact);
       const requiredness = REQUIRED_ARTIFACTS.has(artifact) ? "required" : "optional";
       if (artifact === "swarm.db") {
         const r = await archiveSqliteSnapshot({
@@ -30161,7 +30849,7 @@ async function runArchiveStage(ctx) {
         }
       } else {
         try {
-          await fs15.copyFile(srcPath, destPath);
+          await fs16.copyFile(srcPath, destPath);
           ctx.archivedFileCount++;
           if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
             ctx.archivedActiveStateFiles.add(artifact);
@@ -30205,12 +30893,12 @@ async function runArchiveStage(ctx) {
         }
       }
     }
-    const dynamicArchiveArtifacts = (await fs15.readdir(ctx.swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
+    const dynamicArchiveArtifacts = (await fs16.readdir(ctx.swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
     for (const artifact of dynamicArchiveArtifacts) {
-      const srcPath = path44.join(ctx.swarmDir, artifact);
-      const destPath = path44.join(ctx.archiveDir, artifact);
+      const srcPath = path45.join(ctx.swarmDir, artifact);
+      const destPath = path45.join(ctx.archiveDir, artifact);
       try {
-        await fs15.copyFile(srcPath, destPath);
+        await fs16.copyFile(srcPath, destPath);
         ctx.archivedFileCount++;
         ctx.archivedActiveStateFiles.add(artifact);
         ctx.archiveResults.push({
@@ -30252,8 +30940,8 @@ async function runArchiveStage(ctx) {
       }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path44.join(ctx.swarmDir, dirName);
-      const destDir = path44.join(ctx.archiveDir, dirName);
+      const srcDir = path45.join(ctx.swarmDir, dirName);
+      const destDir = path45.join(ctx.archiveDir, dirName);
       try {
         const result = await copyDirRecursiveWithFailures(srcDir, destDir);
         ctx.archivedFileCount += result.copied;
@@ -30295,7 +30983,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let cacheMaxBytes;
   let cacheMaxRecords;
   try {
-    const { config: evidenceLoadedConfig } = _internals38.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals39.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -30311,7 +30999,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals38.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
+    await _internals39.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
       report: true,
       cacheMaxBytes,
       cacheMaxRecords
@@ -30349,14 +31037,14 @@ async function runCleanStage(ctx) {
         }
         continue;
       }
-      const filePath = path44.join(ctx.swarmDir, artifact);
+      const filePath = path45.join(ctx.swarmDir, artifact);
       if (artifact === "swarm.db") {
         try {
           closeProjectDb(ctx.directory);
         } catch {}
       }
       try {
-        await fs15.unlink(filePath);
+        await fs16.unlink(filePath);
         cleanedFiles.push(artifact);
       } catch (err) {
         const errno = err?.code;
@@ -30374,7 +31062,7 @@ async function runCleanStage(ctx) {
       continue;
     }
     try {
-      await fs15.unlink(path44.join(ctx.swarmDir, artifact));
+      await fs16.unlink(path45.join(ctx.swarmDir, artifact));
       cleanedFiles.push(artifact);
     } catch (err) {
       const errno = err?.code;
@@ -30388,18 +31076,18 @@ async function runCleanStage(ctx) {
     if (!ctx.archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path44.join(ctx.swarmDir, dirName);
+    const dirPath = path45.join(ctx.swarmDir, dirName);
     try {
-      await fs15.rm(dirPath, { recursive: true, force: true });
+      await fs16.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
     } catch {}
   }
   try {
-    const swarmFiles = await fs15.readdir(ctx.swarmDir);
+    const swarmFiles = await fs16.readdir(ctx.swarmDir);
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs15.unlink(path44.join(ctx.swarmDir, backup));
+        await fs16.unlink(path45.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -30412,7 +31100,7 @@ async function runCleanStage(ctx) {
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs15.unlink(path44.join(ctx.swarmDir, sibling));
+        await fs16.unlink(path45.join(ctx.swarmDir, sibling));
       } catch (err) {
         const errno = err?.code;
         if (errno === "ENOENT") {} else {
@@ -30430,16 +31118,16 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path44.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
-    path44.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
-    path44.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
-    path44.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
-    path44.join(ctx.directory, "SWARM_PLAN.json"),
-    path44.join(ctx.directory, "SWARM_PLAN.md")
+    path45.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path45.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
+    path45.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
+    path45.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
+    path45.join(ctx.directory, "SWARM_PLAN.json"),
+    path45.join(ctx.directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
-      await fs15.unlink(candidate);
+      await fs16.unlink(candidate);
       swarmPlanFilesRemoved++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
@@ -30469,7 +31157,7 @@ async function runCleanStage(ctx) {
   }
   for (const terminalFile of TERMINAL_STATE_FILES) {
     try {
-      await fs15.unlink(path44.join(ctx.swarmDir, terminalFile));
+      await fs16.unlink(path45.join(ctx.swarmDir, terminalFile));
       if (!cleanedFiles.includes(terminalFile)) {
         cleanedFiles.push(terminalFile);
       }
@@ -30482,7 +31170,7 @@ async function runCleanStage(ctx) {
     }
   }
   clearAllScopes(ctx.directory);
-  const contextPath = path44.join(ctx.swarmDir, "context.md");
+  const contextPath = path45.join(ctx.swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -30513,9 +31201,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals38.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals39.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals38.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals39.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -30527,7 +31215,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals38.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals39.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -30554,16 +31242,16 @@ async function runAlignStage(ctx) {
   return { gitAlignResult, prunedBranches };
 }
 async function runFinalizeDryRun(directory, swarmDir, planData, planExists) {
-  const existsInSwarm = (name) => fsSync2.existsSync(path44.join(swarmDir, name));
+  const existsInSwarm = (name) => fsSync2.existsSync(path45.join(swarmDir, name));
   const phases = planData.phases ?? [];
   const nonTerminalPhases = phases.filter((p) => p.status !== "complete" && p.status !== "completed" && p.status !== "blocked" && p.status !== "closed");
   const planAlreadyDone = planExists && phases.length > 0 && nonTerminalPhases.length === 0;
   const wouldArchive = ARCHIVE_ARTIFACTS.filter(existsInSwarm);
-  const dynamicArchive = (await fs15.readdir(swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
+  const dynamicArchive = (await fs16.readdir(swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
   const wouldArchiveDirs = ACTIVE_STATE_DIRS_TO_CLEAN.filter(existsInSwarm);
   const wouldRemoveTerminal = TERMINAL_STATE_FILES.filter(existsInSwarm);
   const wouldCleanFiles = ACTIVE_STATE_TO_CLEAN.filter((f) => existsInSwarm(f) && !TERMINAL_STATE_FILES.includes(f));
-  const gitStatus = _internals38.getGitRepositoryStatus(directory);
+  const gitStatus = _internals39.getGitRepositoryStatus(directory);
   const gitNote = gitStatus.isRepo ? "would align the working tree to main/remote (git reset), pruning merged branches only with --prune-branches" : "would skip git alignment (not a git repository / git unavailable)";
   let residueSection = [];
   try {
@@ -30617,7 +31305,7 @@ async function runFinalizeDryRun(directory, swarmDir, planData, planExists) {
 `);
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path44.join(directory, ".swarm");
+  const swarmDir = path45.join(directory, ".swarm");
   try {
     const stat5 = fsSync2.lstatSync(swarmDir);
     if (stat5.isSymbolicLink()) {
@@ -30631,43 +31319,43 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path44.basename(directory) || "Ad-hoc session",
+    title: path45.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
-    const content = await fs15.readFile(planPath, "utf-8");
+    const content = await fs16.readFile(planPath, "utf-8");
     planData = JSON.parse(content);
     planExists = true;
   } catch (error2) {
     if (error2?.code !== "ENOENT") {
       return `\u274C Failed to read plan.json: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
-    const swarmDirExists = await fs15.access(swarmDir).then(() => true).catch(() => false);
+    const swarmDirExists = await fs16.access(swarmDir).then(() => true).catch(() => false);
     if (!swarmDirExists) {
       return `\u274C No .swarm/ directory found in ${directory}. Run /swarm close from the project root, or run /swarm plan first.`;
     }
   }
   if (args.includes("--dry-run")) {
-    return _internals38.runFinalizeDryRun(directory, swarmDir, planData, planExists);
+    return _internals39.runFinalizeDryRun(directory, swarmDir, planData, planExists);
   }
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals38.acquireFinalizeLock(directory);
+  finalizeLock = await _internals39.acquireFinalizeLock(directory);
   if (!finalizeLock.acquired) {
     return `\u274C Another /swarm finalize is already running for this project. If you are certain no other run is active, wait for the lock to expire or remove the stale lock and retry.`;
   }
   try {
     if (!planExists) {
-      const archiveDir = path44.join(swarmDir, "archive");
+      const archiveDir = path45.join(swarmDir, "archive");
       try {
-        const archiveEntries = await fs15.readdir(archiveDir);
+        const archiveEntries = await fs16.readdir(archiveDir);
         const hasArchiveBundle = archiveEntries.some((entry) => entry.startsWith("swarm-"));
         if (hasArchiveBundle) {
           const hasActiveState = [
             ...ACTIVE_STATE_TO_CLEAN,
             ...ACTIVE_STATE_DIRS_TO_CLEAN
-          ].some((entry) => fsSync2.existsSync(path44.join(swarmDir, entry)));
+          ].some((entry) => fsSync2.existsSync(path45.join(swarmDir, entry)));
           if (!hasActiveState) {
             return `\u2705 Already finalized \u2014 nothing to do.
 
@@ -30684,7 +31372,7 @@ This project was already finalized in a previous /swarm close run. The plan has
     if (planExists) {
       planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
     }
-    const { config: loadedConfig } = _internals38.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals39.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -30733,14 +31421,14 @@ This project was already finalized in a previous /swarm close run. The plan has
       archiveSuffix: "",
       args
     };
-    ctx.fullAuto = options.sessionID ? _internals38.detectFullAuto(directory, options.sessionID) : false;
+    ctx.fullAuto = options.sessionID ? _internals39.detectFullAuto(directory, options.sessionID) : false;
     await runFinalizeStage(ctx);
     if (ctx.terminalizationError) {
       return `\u274C Close paused before reward, archive, cleanup, teardown, and Git alignment because terminal plan/evidence reconciliation failed: ${ctx.terminalizationError}
 
 No active state was archived or removed. Fix the reported durable-state problem, then retry /swarm close.`;
     }
-    await _internals38.runFinalizeRewardSweep({
+    await _internals39.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -30818,9 +31506,9 @@ No active state was archived or removed. Fix the reported durable-state problem,
     try {
       const sessionIdsToEnd = [...swarmState.agentSessions.keys()];
       for (const sessionId of sessionIdsToEnd) {
-        _internals38.endAgentSession(sessionId);
+        _internals39.endAgentSession(sessionId);
       }
-      _internals38.resetSwarmStatePreservingSingletons();
+      _internals39.resetSwarmStatePreservingSingletons();
     } catch (teardownError) {
       const msg = teardownError instanceof Error ? teardownError.message : String(teardownError);
       ctx.warnings.push(`Session teardown encountered an error after finalization completed (state may not be fully reset): ${msg}`);
@@ -30917,7 +31605,7 @@ function detectFullAuto(directory, sessionID) {
     return false;
   }
 }
-var _internals38 = {
+var _internals39 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -30946,8 +31634,11 @@ var _internals38 = {
   closePlanTerminalState: reconcileCloseTerminalStateForPlan,
   endAgentSession,
   flushAndDrainTelemetry: async () => {
-    const { flushAndDrainTelemetry } = await import("./telemetry-t109dhv7.js");
+    const { flushAndDrainTelemetry } = await import("./telemetry-xzy0qeap.js");
     return flushAndDrainTelemetry();
+  },
+  finalizeContextTelemetry: (directory) => {
+    finalizeContextTelemetry(directory);
   }
 };
 
@@ -31183,14 +31874,14 @@ function buildStatusMessage(session, plan) {
 // src/commands/config.ts
 init_loader();
 import * as os6 from "os";
-import * as path45 from "path";
+import * as path46 from "path";
 function getUserConfigDir() {
-  return process.env.XDG_CONFIG_HOME || path45.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path46.join(os6.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
-  const userConfigPath = path45.join(getUserConfigDir(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path45.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path46.join(getUserConfigDir(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path46.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -31211,19 +31902,19 @@ async function handleConfigCommand(directory, _args) {
 init_schema();
 
 // src/services/skill-consolidation.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { mkdir as mkdir15, readFile as readFile15 } from "fs/promises";
-import * as path46 from "path";
+import * as path47 from "path";
 var DEFAULT_CONSOLIDATION_INTERVAL_HOURS = 24;
 var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
 var CONSOLIDATION_RUN_TIMEOUT_MS = 5 * 60 * 1000;
 var runningByDirectory = new Map;
 function consolidationStatePath(directory) {
-  return path46.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path47.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync26(filePath))
+  if (!existsSync27(filePath))
     return {};
   try {
     const parsed = JSON.parse(await readFile15(filePath, "utf-8"));
@@ -31235,7 +31926,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir15(path46.dirname(filePath), { recursive: true });
+  await mkdir15(path47.dirname(filePath), { recursive: true });
   await atomicWriteSwarmFile(filePath, content);
 }
 async function writeState2(directory, state) {
@@ -31313,7 +32004,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path46.resolve(req.directory);
+  const key = path47.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -31401,99 +32092,10 @@ async function handleConsolidateCommand(directory, args, options = {}) {
   }
 }
 
-// src/context-map/telemetry.ts
-import * as fs16 from "fs";
-import * as path47 from "path";
-function isValidTelemetryEntry(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const obj = value;
-  return typeof obj.timestamp === "string" && typeof obj.task_id === "string" && typeof obj.agent_role === "string" && typeof obj.delegation_reason === "string" && typeof obj.token_estimate === "number" && typeof obj.cache_hits === "number" && typeof obj.cache_misses === "number" && typeof obj.stale_entries === "number" && typeof obj.recommended_reads === "number" && typeof obj.skipped_reads === "number" && typeof obj.success === "boolean";
-}
-var _internals39 = {
-  appendFileSync: fs16.appendFileSync,
-  readFileSync: fs16.readFileSync,
-  existsSync: fs16.existsSync,
-  mkdirSync: fs16.mkdirSync
-};
-function telemetryFilePath(directory) {
-  return path47.join(directory, ".swarm", "context-telemetry.jsonl");
-}
-function readTelemetry(directory) {
-  const filePath = telemetryFilePath(directory);
-  const entries = [];
-  try {
-    if (!_internals39.existsSync(filePath)) {
-      return entries;
-    }
-    const raw = _internals39.readFileSync(filePath, "utf-8");
-    const lines = raw.split(`
-`);
-    for (const line of lines) {
-      if (line.trim() === "") {
-        continue;
-      }
-      try {
-        const parsed = JSON.parse(line);
-        if (isValidTelemetryEntry(parsed)) {
-          entries.push(parsed);
-        }
-      } catch {}
-    }
-    return entries;
-  } catch {
-    return entries;
-  }
-}
-function getTelemetrySummary(directory) {
-  const entries = readTelemetry(directory);
-  if (entries.length === 0) {
-    return {
-      total_delegations: 0,
-      total_cache_hits: 0,
-      total_cache_misses: 0,
-      total_stale_entries: 0,
-      avg_token_estimate: 0,
-      total_recommended_reads: 0,
-      total_skipped_reads: 0,
-      success_rate: 0
-    };
-  }
-  let totalCacheHits = 0;
-  let totalCacheMisses = 0;
-  let totalStaleEntries = 0;
-  let totalTokenEstimate = 0;
-  let totalRecommendedReads = 0;
-  let totalSkippedReads = 0;
-  let totalSuccess = 0;
-  for (const entry of entries) {
-    totalCacheHits += entry.cache_hits;
-    totalCacheMisses += entry.cache_misses;
-    totalStaleEntries += entry.stale_entries;
-    totalTokenEstimate += entry.token_estimate;
-    totalRecommendedReads += entry.recommended_reads;
-    totalSkippedReads += entry.skipped_reads;
-    if (entry.success) {
-      totalSuccess++;
-    }
-  }
-  return {
-    total_delegations: entries.length,
-    total_cache_hits: totalCacheHits,
-    total_cache_misses: totalCacheMisses,
-    total_stale_entries: totalStaleEntries,
-    avg_token_estimate: Math.round(totalTokenEstimate / entries.length),
-    total_recommended_reads: totalRecommendedReads,
-    total_skipped_reads: totalSkippedReads,
-    success_rate: Math.round(totalSuccess / entries.length * 100)
-  };
-}
-
 // src/commands/context-map-stats.ts
 async function handleContextMapStatsCommand(directory) {
   const summary = getTelemetrySummary(directory);
-  if (summary.total_delegations === 0) {
+  if (summary.total_delegations === 0 && summary.corrupt_entries === 0) {
     return "No capsule telemetry recorded.";
   }
   const pct = (n, d) => d === 0 ? "N/A" : `${(n / d * 100).toFixed(1)}%`;
@@ -31509,6 +32111,15 @@ async function handleContextMapStatsCommand(directory) {
     `**Recommended reads:** ${summary.total_recommended_reads}`,
     `**Skipped reads:** ${summary.total_skipped_reads}`
   ];
+  if (summary.coverage === "partial-unmigrated") {
+    lines.push("", "> Historical context telemetry spans more than the documented read bound and is being migrated in bounded passes; totals above cover only the part already accounted. Run `/swarm context-map stats` again after the store settles for the full lifetime figure.");
+  }
+  if (summary.dropped_entries > 0) {
+    lines.push(`**Dropped (age-pruned raw records, totals unaffected):** ${summary.dropped_entries}`);
+  }
+  if (summary.corrupt_entries > 0) {
+    lines.push(`**Corrupt/partial lines skipped (diagnostics only):** ${summary.corrupt_entries}`);
+  }
   return lines.join(`
 `);
 }
@@ -32352,9 +32963,9 @@ var _internals43 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-t8bmshhj.js"),
-      import("./curator-cvy1s7wd.js"),
-      import("./curator-llm-factory-6bra0bfd.js")
+      import("./schema-jhz9hme9.js"),
+      import("./curator-acp80hpc.js"),
+      import("./curator-llm-factory-ewffa8r1.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -32854,7 +33465,7 @@ ${USAGE8}`;
 // src/services/diagnose-service.ts
 init_package();
 import * as child_process5 from "child_process";
-import { existsSync as existsSync31, readdirSync as readdirSync6, readFileSync as readFileSync21, statSync as statSync10 } from "fs";
+import { existsSync as existsSync31, readdirSync as readdirSync6, readFileSync as readFileSync21, statSync as statSync11 } from "fs";
 import * as path52 from "path";
 import { fileURLToPath } from "url";
 
@@ -32963,7 +33574,7 @@ import { readFile as readFile17 } from "fs/promises";
 import { join as join40 } from "path";
 
 // src/services/version-check.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync15, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync15, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join39 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -33308,7 +33919,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-p7t5mb4x.js");
+    const { getScanStatus } = await import("./scan-cursor-4jv70zwb.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -33316,19 +33927,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-8pr02pza.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-mgg482z6.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-t8bmshhj.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-jhz9hme9.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4vwn66wk.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-4zevsvaa.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-x19e8bqc.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-9vv7v5rf.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -33735,7 +34346,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync31(directory) || !statSync10(directory).isDirectory()) {
+    if (!existsSync31(directory) || !statSync11(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -34604,7 +35215,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-vstrprja.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-yd866pd5.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -35544,7 +36155,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-yhap2xph.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-8gw74j8g.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -35828,7 +36439,7 @@ init_zod();
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "fs";
 import * as path57 from "path";
 init_git_executable();
 
@@ -36098,7 +36709,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir, option
     const safeId = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
     patchFile = path57.join(workingDir, `.mutation_patch_${safeId}.diff`);
     try {
-      writeFileSync11(patchFile, patch.patch);
+      writeFileSync12(patchFile, patch.patch);
     } catch (writeErr) {
       error2 = `Failed to write patch file: ${writeErr}`;
       outcome = "error";
@@ -36200,7 +36811,7 @@ async function executeMutation(patch, testCommand, testFiles, workingDir, option
         revertError = new Error(`Failed to revert mutation ${patch.id}: ${revertErr}. Working tree may be dirty.`);
       }
       try {
-        unlinkSync6(patchFile);
+        unlinkSync7(patchFile);
       } catch (_unlinkErr) {}
     }
   }
@@ -40479,12 +41090,12 @@ var _internals54 = {
 
 // src/session/snapshot-writer.ts
 import {
-  closeSync as closeSync8,
+  closeSync as closeSync9,
   existsSync as existsSync38,
   fsyncSync as fsyncSync2,
   mkdirSync as mkdirSync20,
-  openSync as openSync8,
-  unlinkSync as unlinkSync8
+  openSync as openSync9,
+  unlinkSync as unlinkSync9
 } from "fs";
 import { rename as fsRename } from "fs/promises";
 import * as path64 from "path";
@@ -40648,18 +41259,18 @@ async function writeSnapshot(directory, state) {
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
     try {
-      const fd = openSync8(tempPath, "r+");
+      const fd = openSync9(tempPath, "r+");
       try {
         fsyncSync2(fd);
       } finally {
-        closeSync8(fd);
+        closeSync9(fd);
       }
     } catch {}
     try {
       await renameWithTransientRetry(tempPath, resolvedPath);
     } finally {
       try {
-        unlinkSync8(tempPath);
+        unlinkSync9(tempPath);
       } catch {}
     }
     invalidateCachedArtifact(resolvedPath);
@@ -40861,7 +41472,7 @@ async function handleHistoryCommand(directory, _args) {
 }
 // src/knowledge/hive-quarantine.ts
 init_package();
-import { createHash as createHash16, createHmac, randomBytes, randomUUID as randomUUID9 } from "crypto";
+import { createHash as createHash17, createHmac, randomBytes, randomUUID as randomUUID9 } from "crypto";
 import {
   chmod,
   copyFile as copyFile2,
@@ -40894,7 +41505,7 @@ function serializeCanonical(value) {
   return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${serializeCanonical(v)}`).join(",")}}`;
 }
 function sha256Hex(content) {
-  return createHash16("sha256").update(content, "utf-8").digest("hex");
+  return createHash17("sha256").update(content, "utf-8").digest("hex");
 }
 var QUARANTINE_SECRET_FILE = "hive-quarantine.key";
 async function readQuarantineSecret() {
@@ -43354,7 +43965,7 @@ var MIN_MAX_CYCLES = 1;
 var MAX_MAX_CYCLES = 5;
 async function readLatestLoopState(directory) {
   try {
-    const { readdirSync: readdirSync9, statSync: statSync14, readFileSync: readFileSync33 } = await import("fs");
+    const { readdirSync: readdirSync9, statSync: statSync15, readFileSync: readFileSync33 } = await import("fs");
     const loopDir = `${directory}/.swarm/loop`;
     let latestMtime = 0;
     let latestPath = null;
@@ -43365,7 +43976,7 @@ async function readLatestLoopState(directory) {
           continue;
         const statePath = `${loopDir}/${entry.name}/state.json`;
         try {
-          const mtime = statSync14(statePath).mtimeMs;
+          const mtime = statSync15(statePath).mtimeMs;
           if (mtime > latestMtime) {
             latestMtime = mtime;
             latestPath = statePath;
@@ -43988,13 +44599,13 @@ function parseJsonObject(candidate) {
 init_schema();
 // src/memory/reflection-service.ts
 import {
-  closeSync as closeSync9,
+  closeSync as closeSync10,
   existsSync as existsSync42,
   fstatSync,
-  openSync as openSync9,
-  readSync as readSync6,
+  openSync as openSync10,
+  readSync as readSync7,
   realpathSync as realpathSync8,
-  statSync as statSync15
+  statSync as statSync16
 } from "fs";
 var import_proper_lockfile8 = __toESM(require_proper_lockfile(), 1);
 
@@ -47215,12 +47826,12 @@ var workspaceCache = new Map;
 
 // src/tools/repo-graph/freshness.ts
 init_package();
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import * as fsPromises3 from "fs/promises";
 import * as path74 from "path";
 var REPO_GRAPH_FINGERPRINT_FILENAME = "repo-graph.fingerprint.json";
 var FINGERPRINT_SCHEMA_VERSION = 1;
-var EXTRACTOR_STAMP = createHash17("sha256").update(`${package_default.version}\x00${GRAPH_SCHEMA_VERSION}`).digest("hex");
+var EXTRACTOR_STAMP = createHash18("sha256").update(`${package_default.version}\x00${GRAPH_SCHEMA_VERSION}`).digest("hex");
 var MAX_FINGERPRINT_BYTES = 24 * 1024 * 1024;
 var MAX_FINGERPRINT_ENTRIES = 100256;
 var MAX_RELATIVE_PATH_LENGTH = 4096;
@@ -47244,7 +47855,7 @@ function normalizedExcludes(options) {
   return [...new Set((options?.excludeDirs ?? []).filter(Boolean))].sort((a, b) => a.localeCompare(b));
 }
 function exclusionStamp(options) {
-  return createHash17("sha256").update(JSON.stringify({
+  return createHash18("sha256").update(JSON.stringify({
     excludeDirs: normalizedExcludes(options),
     followSymlinks: options?.followSymlinks ?? false
   })).digest("hex");
@@ -47461,12 +48072,12 @@ function readReflectionDigest(directory) {
     return null;
   let fd;
   try {
-    fd = openSync9(filePath, "r");
+    fd = openSync10(filePath, "r");
     const size = fstatSync(fd).size;
     if (size <= 0 || size > MAX_INJECTION_READ_BYTES)
       return null;
     const bytes = Buffer.alloc(size);
-    const read = readSync6(fd, bytes, 0, size, 0);
+    const read = readSync7(fd, bytes, 0, size, 0);
     if (read !== size)
       return null;
     return JSON.parse(bytes.toString("utf-8"));
@@ -47474,7 +48085,7 @@ function readReflectionDigest(directory) {
     return null;
   } finally {
     if (fd !== undefined)
-      closeSync9(fd);
+      closeSync10(fd);
   }
 }
 function readDeadAnchorMemoryIds(directory) {
@@ -48152,7 +48763,7 @@ init_schema();
 
 // src/memory/memory-family-migration.ts
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
-import { copyFileSync as copyFileSync4, existsSync as existsSync44, readFileSync as readFileSync34, unlinkSync as unlinkSync10 } from "fs";
+import { copyFileSync as copyFileSync4, existsSync as existsSync44, readFileSync as readFileSync34, unlinkSync as unlinkSync11 } from "fs";
 import { mkdir as mkdir22, rename as rename8 } from "fs/promises";
 import * as path77 from "path";
 init_logger();
@@ -48415,10 +49026,10 @@ async function mergeStagedSqlite(destStoragePath, stagedPath) {
       }
       db.close();
       try {
-        unlinkSync10(stagedPath);
+        unlinkSync11(stagedPath);
         for (const suffix of ["-wal", "-shm"]) {
           try {
-            unlinkSync10(`${stagedPath}${suffix}`);
+            unlinkSync11(`${stagedPath}${suffix}`);
           } catch {}
         }
       } catch {}
@@ -53169,7 +53780,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
     const relativeFile = path84.relative(workingDir, absoluteFile);
     const basename20 = path84.basename(absoluteFile);
-    const dirname36 = path84.dirname(absoluteFile);
+    const dirname37 = path84.dirname(absoluteFile);
     const preferRelativeOutput = !path84.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
@@ -53185,7 +53796,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path84.join(dirname36, candidateName));
+    ].map((candidateName) => path84.join(dirname37, candidateName));
     const testDirectoryNames = [
       basename20,
       ...genericTestNames,
@@ -53194,7 +53805,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path84.join(dirname36, dirName, candidateName))),
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path84.join(dirname37, dirName, candidateName))),
       ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path84.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
@@ -55772,7 +56383,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 
 // src/workflow/stage-a-repair.ts
 import { appendFile as appendFile10, mkdir as mkdir24, readdir as readdir7 } from "fs/promises";
-import { dirname as dirname36 } from "path";
+import { dirname as dirname37 } from "path";
 init_logger();
 var MAX_STAGE_A_REPAIR_SCAN = 200;
 var RETRYABLE_EVENT_CODES = new Set(["EBUSY", "EPERM"]);
@@ -55785,7 +56396,7 @@ async function appendStageARepairEvent(directory, payload) {
 `;
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
-    await mkdir24(dirname36(eventsPath), { recursive: true });
+    await mkdir24(dirname37(eventsPath), { recursive: true });
     await appendFile10(eventsPath, line, "utf-8");
   } catch (error2) {
     const code = error2.code;
@@ -57197,7 +57808,7 @@ import * as fs46 from "fs";
 import * as path96 from "path";
 
 // src/review/diff-source.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 import * as fs40 from "fs";
 import * as path90 from "path";
 init_git_executable();
@@ -57609,7 +58220,7 @@ function uniqueSkipCodes(skipReasons) {
   return [...new Set(skipReasons.map((item) => item.code))].sort();
 }
 function hashManifestPayload(payload) {
-  return createHash18("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
+  return createHash19("sha256").update(JSON.stringify(payload), "utf8").digest("hex");
 }
 function parseObjectFormat(stdout) {
   const objectFormat = stdout.trim();
@@ -57697,7 +58308,7 @@ function hashWorkingTreeIdentity(root, rawPath, budget) {
     if (fileBytes > budget.remainingBytes) {
       return deadlineExceeded(`working-tree content identity exceeded the ${WORKTREE_IDENTITY_TOTAL_BYTES}-byte aggregate cap`);
     }
-    const hash2 = createHash18("sha256");
+    const hash2 = createHash19("sha256");
     const buffer = Buffer.alloc(64 * 1024);
     let offset = 0;
     while (offset < fileBytes) {
@@ -58277,8 +58888,8 @@ async function collectReviewDiff(options) {
     canonicalText,
     fileListFallback: fileListFallback ?? null
   });
-  const scopeHash = createHash18("sha256").update(hashPayload, "utf8").digest("hex");
-  const reviewContentHash = createHash18("sha256").update(JSON.stringify({
+  const scopeHash = createHash19("sha256").update(hashPayload, "utf8").digest("hex");
+  const reviewContentHash = createHash19("sha256").update(JSON.stringify({
     selector,
     canonicalText,
     fileListFallback: fileListFallback ?? null
@@ -58791,7 +59402,7 @@ function buildApprovedReceipt(opts) {
 init_schema();
 
 // src/review/finding-validator.ts
-import { createHash as createHash20 } from "crypto";
+import { createHash as createHash21 } from "crypto";
 init_schema();
 var MAX_VALIDATOR_FALLBACK_MODELS = FALLBACK_MODELS_MAX;
 function canonicalFindingPayload(finding) {
@@ -58817,7 +59428,7 @@ function canonicalizeValidationCandidates(findings) {
       line_start: finding.line_start,
       line_end: finding.line_end
     };
-    const findingId = createHash20("sha256").update(canonicalFindingPayload(normalized), "utf8").digest("hex");
+    const findingId = createHash21("sha256").update(canonicalFindingPayload(normalized), "utf8").digest("hex");
     const existing = candidates.get(findingId);
     if (existing) {
       existing.duplicate_count += "duplicate_count" in finding && finding.duplicate_count > 1 ? finding.duplicate_count : 1;
@@ -59098,7 +59709,7 @@ import * as path93 from "path";
 init_git_executable();
 
 // src/hooks/reviewer-scope-file-fingerprint.ts
-import { createHash as createHash21 } from "crypto";
+import { createHash as createHash22 } from "crypto";
 import * as fs42 from "fs";
 import * as path92 from "path";
 var RETRYABLE_CAPTURE_FAILURE_CODES = new Set([
@@ -59384,7 +59995,7 @@ function captureReviewerScopeFileFingerprint(directory, file, options = {}) {
         retryable: true
       };
     }
-    const hash2 = createHash21("sha256");
+    const hash2 = createHash22("sha256");
     const chunk = Buffer.alloc(REVIEWER_SCOPE_CAPTURE_CHUNK_BYTES);
     let totalBytes = 0;
     for (;; ) {
@@ -59904,11 +60515,11 @@ var _internals82 = {
 };
 
 // src/review/evidence.ts
-import { createHash as createHash22 } from "crypto";
+import { createHash as createHash23 } from "crypto";
 import * as fs44 from "fs";
 import * as path94 from "path";
 function computeAutoReviewManifestHash(manifest) {
-  return createHash22("sha256").update(JSON.stringify({
+  return createHash23("sha256").update(JSON.stringify({
     schema_version: manifest.schema_version,
     content_hash: manifest.content_hash,
     plan_requirements_hash: manifest.plan_requirements_hash,
@@ -59995,7 +60606,7 @@ async function computePlanRequirementsHash(directory) {
   return plan ? computeReviewPlanRequirementsHash(plan) : "plan:none";
 }
 function computeAutoReviewPolicyDigest(config) {
-  return createHash22("sha256").update(JSON.stringify({
+  return createHash23("sha256").update(JSON.stringify({
     mode: config.final_review.mode,
     min_confidence: config.min_confidence,
     structured_findings: config.structured_findings,
@@ -60041,7 +60652,7 @@ async function loadReviewRequirementsPlan(directory) {
   return replayed.plan;
 }
 function computeReviewPlanRequirementsHash(plan) {
-  return createHash22("sha256").update(JSON.stringify({
+  return createHash23("sha256").update(JSON.stringify({
     schema_version: plan.schema_version,
     title: plan.title,
     swarm: plan.swarm,
@@ -62042,25 +62653,25 @@ import {
   existsSync as existsSync56,
   mkdirSync as mkdirSync27,
   readFileSync as readFileSync42,
-  renameSync as renameSync14,
-  unlinkSync as unlinkSync18,
-  writeFileSync as writeFileSync16
+  renameSync as renameSync15,
+  unlinkSync as unlinkSync19,
+  writeFileSync as writeFileSync17
 } from "fs";
 import * as path100 from "path";
 
 // src/services/skill-optimizer/store.ts
-import { createHash as createHash23, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash24, randomUUID as randomUUID12 } from "crypto";
 import {
-  closeSync as closeSync16,
+  closeSync as closeSync17,
   existsSync as existsSync55,
   fsyncSync as fsyncSync3,
   mkdirSync as mkdirSync26,
-  openSync as openSync16,
+  openSync as openSync17,
   readFileSync as readFileSync41,
-  renameSync as renameSync13,
-  statSync as statSync19,
-  unlinkSync as unlinkSync17,
-  writeFileSync as writeFileSync15,
+  renameSync as renameSync14,
+  statSync as statSync20,
+  unlinkSync as unlinkSync18,
+  writeFileSync as writeFileSync16,
   writeFileSync as writeFileSyncAsync
 } from "fs";
 import * as path99 from "path";
@@ -62074,10 +62685,10 @@ function canonicalJson3(value) {
   return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson3(v)}`).join(",")}}`;
 }
 function computeStateHash(value) {
-  return createHash23("sha256").update(canonicalJson3(value), "utf8").digest("hex");
+  return createHash24("sha256").update(canonicalJson3(value), "utf8").digest("hex");
 }
 function computeContentHash2(content) {
-  return createHash23("sha256").update(content, "utf8").digest("hex");
+  return createHash24("sha256").update(content, "utf8").digest("hex");
 }
 function computeEventHash(event) {
   return computeStateHash({
@@ -62124,18 +62735,18 @@ function ensureCandidateDir(directory, skillSlug, candidateId2) {
   return dir;
 }
 function writeFileFsyncedThenRename(tempPath, targetPath, data) {
-  const fd = openSync16(tempPath, "w");
+  const fd = openSync17(tempPath, "w");
   try {
-    writeFileSync15(fd, data, "utf8");
+    writeFileSync16(fd, data, "utf8");
     fsyncSync3(fd);
   } finally {
-    closeSync16(fd);
+    closeSync17(fd);
   }
   try {
-    renameSync13(tempPath, targetPath);
+    renameSync14(tempPath, targetPath);
   } catch (err) {
     try {
-      unlinkSync17(tempPath);
+      unlinkSync18(tempPath);
     } catch {}
     throw err;
   }
@@ -62145,10 +62756,10 @@ var _internals86 = {
   writeFileFsyncedThenRename,
   writeFileSync: writeFileSyncAsync,
   readFileSync: readFileSync41,
-  renameSync: renameSync13,
-  unlinkSync: unlinkSync17,
+  renameSync: renameSync14,
+  unlinkSync: unlinkSync18,
   existsSync: existsSync55,
-  statSync: statSync19
+  statSync: statSync20
 };
 async function appendEvent2(directory, eventInput) {
   assertProjectRoot(directory);
@@ -62407,9 +63018,9 @@ function writeSkillFileAtomic(targetPath, content) {
   }
 }
 var _internals87 = {
-  writeFileSync: writeFileSync16,
-  renameSync: renameSync14,
-  unlinkSync: unlinkSync18
+  writeFileSync: writeFileSync17,
+  renameSync: renameSync15,
+  unlinkSync: unlinkSync19
 };
 async function activateCandidate(input) {
   const skillPath = path100.join(input.directory, ".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
@@ -62498,7 +63109,7 @@ async function rollbackCandidate(input) {
 
 // src/services/skill-optimizer/controller.ts
 import { randomUUID as randomUUID13 } from "crypto";
-import { existsSync as existsSync58, mkdirSync as mkdirSync28, readFileSync as readFileSync44, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync58, mkdirSync as mkdirSync28, readFileSync as readFileSync44, writeFileSync as writeFileSync18 } from "fs";
 import * as path103 from "path";
 
 // src/evaluation/pr-review-recovery.ts
@@ -63183,8 +63794,8 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
     mkdirSync28(payloadSubdir, { recursive: true });
   const baselinePayloadRel = path103.join("candidates", candidateId2, "baseline.md");
   const candidatePayloadRel = path103.join("candidates", candidateId2, "candidate.md");
-  writeFileSync17(path103.join(payloadSubdir, "baseline.md"), baselineContent, "utf8");
-  writeFileSync17(path103.join(payloadSubdir, "candidate.md"), candidateContent, "utf8");
+  writeFileSync18(path103.join(payloadSubdir, "baseline.md"), baselineContent, "utf8");
+  writeFileSync18(path103.join(payloadSubdir, "candidate.md"), candidateContent, "utf8");
   const { computeCandidateInputContentHash: computeCandidateInputContentHash2 } = await import("./hashing-mjwn6j4y.js");
   const baseline = {
     v: 1,
@@ -63429,7 +64040,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-e7z9cf5y.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-rcnpm510.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await _internals91.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -63518,7 +64129,7 @@ function writeConvergenceState(directory, nonImprovements) {
   const dir = path103.dirname(path103.join(directory, CONVERGENCE_FILE));
   if (!existsSync58(dir))
     mkdirSync28(dir, { recursive: true });
-  writeFileSync17(path103.join(directory, CONVERGENCE_FILE), JSON.stringify({ nonImprovements }), "utf8");
+  writeFileSync18(path103.join(directory, CONVERGENCE_FILE), JSON.stringify({ nonImprovements }), "utf8");
 }
 async function runOptimizationLoop(input) {
   const rounds = [];
@@ -63573,7 +64184,7 @@ async function runOptimizationLoop(input) {
 }
 
 // src/services/skill-optimizer/skill-eval-tasks.ts
-import { existsSync as existsSync59, mkdirSync as mkdirSync29, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync59, mkdirSync as mkdirSync29, writeFileSync as writeFileSync19 } from "fs";
 import * as path104 from "path";
 var DEFAULT_SKILL_EVAL_TASKS = [
   {
@@ -63618,12 +64229,12 @@ function buildSkillEvalTasks(args) {
     if (!existsSync59(taskDir))
       mkdirSync29(taskDir, { recursive: true });
     const instructionPath = path104.join("skill-eval", spec.id, "instruction.md");
-    writeFileSync18(path104.join(args.inputRoot, instructionPath), `${spec.instruction}
+    writeFileSync19(path104.join(args.inputRoot, instructionPath), `${spec.instruction}
 `, "utf8");
     const envRelPath = path104.join("skill-eval", spec.id, "environment.md");
-    writeFileSync18(path104.join(args.inputRoot, envRelPath), spec.environmentBody, "utf8");
+    writeFileSync19(path104.join(args.inputRoot, envRelPath), spec.environmentBody, "utf8");
     const phraseSpecPath = path104.join("skill-eval", spec.id, "phrase-spec.json");
-    writeFileSync18(path104.join(args.inputRoot, phraseSpecPath), JSON.stringify({
+    writeFileSync19(path104.join(args.inputRoot, phraseSpecPath), JSON.stringify({
       required_phrases: spec.requiredPhrases,
       forbidden_phrases: spec.forbiddenPhrases
     }), "utf8");
@@ -65335,7 +65946,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-r46q6996.js");
+    const { buildHelpText } = await import("./index-qqawmxe7.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -65344,7 +65955,7 @@ async function handleHelpCommand(ctx) {
     return _internals94.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals94.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-r46q6996.js");
+  const { buildHelpText: fullHelp } = await import("./index-qqawmxe7.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -65521,7 +66132,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-h8cnwa02.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-50cp8k3r.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -65531,7 +66142,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-h8cnwa02.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-50cp8k3r.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -65541,7 +66152,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-syb7tz2w.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-jazq10gt.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -67740,6 +68351,15 @@ Reply with a single fenced JSON block. No prose outside the block.
   "areasOfUncertainty": [
     "What I'm not sure about, in plain language."
   ],
+  "claims": [
+    {
+      "subject": "The specific question or decision this claim is about",
+      "statement": "Your position on that subject, in one or two sentences",
+      "stance": "support",
+      "confidence": 0.8,
+      "evidence": ["URL or source reference, if any"]
+    }
+  ],
   "disagreementTopics": []
 }
 \`\`\`
@@ -67747,6 +68367,7 @@ Reply with a single fenced JSON block. No prose outside the block.
 Notes:
 - \`searchQueries\` is optional \u2014 list queries you would have run if you had web access (the architect uses these for audit), or omit / leave empty if none.
 - \`sources\` MUST come from the RESEARCH CONTEXT only. Copy title/url/snippet/query verbatim. Never invent sources.
+- \`claims\` is optional but strongly encouraged (max 8): list your key positions as bounded structured claims. Use one of these \`stance\` values exactly: "support" (the position holds), "oppose" (the position is wrong \u2014 a contrary position), "alternative" (a different option is better \u2014 a contrary position), "concern" (risk flagged without taking a side), "neutral" (no position). Claims make contrary positions detectable even without explicit disagreement phrasing.
 - For Round 1: leave \`disagreementTopics\` as []. For Round 2: list the specific disagreement topics this response addresses.`;
 var HARD_RULES = `================================================================
 HARD RULES
@@ -72390,7 +73011,17 @@ async function buildRehydrationCache(directory) {
     }
   }
   const evidenceMap = await readGateEvidenceFromDisk(directory);
-  _rehydrationCache = { planTaskStates, evidenceMap };
+  let councilConfig;
+  try {
+    councilConfig = loadPluginConfig(directory).council;
+  } catch {
+    councilConfig = undefined;
+  }
+  _rehydrationCache = {
+    planTaskStates,
+    evidenceMap,
+    taskIdentityContext: { plan, councilConfig }
+  };
 }
 function applyRehydrationCache(session) {
   if (!_rehydrationCache) {
@@ -72405,7 +73036,7 @@ function applyRehydrationCache(session) {
   if (!session.taskCouncilApproved) {
     session.taskCouncilApproved = new Map;
   }
-  const { planTaskStates, evidenceMap } = _rehydrationCache;
+  const { planTaskStates, evidenceMap, taskIdentityContext } = _rehydrationCache;
   for (const [taskId, planState] of planTaskStates) {
     const existingState = session.taskWorkflowStates.get(taskId);
     const existingCache = ensureTaskWorkflowCache(session).get(taskId);
@@ -72444,6 +73075,21 @@ function applyRehydrationCache(session) {
       session.taskCouncilApproved.delete(taskId);
       continue;
     }
+    const rawIdentityDigest = council.identity_digest;
+    if (typeof rawIdentityDigest !== "string" || !/^[a-f0-9]{64}$/.test(rawIdentityDigest)) {
+      session.taskCouncilApproved.delete(taskId);
+      continue;
+    }
+    const expectedIdentity = computeCouncilReviewIdentity({
+      level: "task",
+      scope: { kind: "task", taskId },
+      plan: taskIdentityContext.plan,
+      config: taskIdentityContext.councilConfig
+    });
+    if (rawIdentityDigest !== expectedIdentity.identityDigest) {
+      session.taskCouncilApproved.delete(taskId);
+      continue;
+    }
     const councilWorkflow = getTaskWorkflowSnapshot(evidence2);
     if (!councilWorkflow.authoritative || council.workflowGeneration !== councilWorkflow.generation || councilWorkflow.state !== "pre_check_passed") {
       session.taskCouncilApproved.delete(taskId);
@@ -72548,7 +73194,7 @@ function getDisplayBudget() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-2xn238xt.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-js5v2xr6.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -72964,7 +73610,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-2jtg2my1.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-vt0jzmdt.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -73112,7 +73758,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-3wzpwe5z.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-nc9a9g5m.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -73208,7 +73854,7 @@ async function preserveBackgroundWorktreeOwnershipForCallId(callID) {
   }
   const session = Buffer.from(dispatch.handle.sessionId, "utf8").toString("base64url");
   const lane = Buffer.from(dispatch.handle.id, "utf8").toString("base64url");
-  const callDigest = createHash24("sha256").update(callID).digest("hex").slice(0, 12);
+  const callDigest = createHash25("sha256").update(callID).digest("hex").slice(0, 12);
   const tag = `swarm-preserved-owner/${session}/${lane}/${callDigest}`;
   let tagProc;
   try {
@@ -73770,7 +74416,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-3wzpwe5z.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-nc9a9g5m.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);