opencode-swarm 7.161.1 → 7.162.0

package/dist/cli/{index-cs9w1hfs.js → index-2rhs7j4r.js}

@@ -6,7 +6,7 @@ import {
   resolveExecutableFromPath,
   runEvaluation,
   runExternalTool
-} from "./index-s33ee2w3.js";
+} from "./index-acnwj4pc.js";
 import {
   finalizeShellAuditForClose,
   isPolicyProtectedPath,
@@ -15,13 +15,13 @@ import {
   protectedRoots,
   redactDecisionLineForArchive,
   stableCanonicalStringify
-} from "./index-29f9te70.js";
+} from "./index-tjaawnws.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-bn78ywnb.js";
+} from "./index-z4n60b0a.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -68,7 +68,7 @@ import {
   validateProjectRoot,
   validateSymlinkBoundary,
   validateTargetWithinRoot
-} from "./index-7d79mj06.js";
+} from "./index-8vwe2qjh.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -85,7 +85,7 @@ import {
   saveGateAuditResult,
   savePromotionDecision,
   saveTaskSetSnapshot
-} from "./index-dq41vsf9.js";
+} from "./index-jw7z3gem.js";
 import {
   canonicalHash,
   canonicalJson,
@@ -99,7 +99,7 @@ import {
 } from "./index-txdagbh7.js";
 import {
   loadDatabaseCtor
-} from "./index-134d35c1.js";
+} from "./index-n249fbw7.js";
 import {
   LANGUAGE_REGISTRY,
   _internals as _internals3,
@@ -130,15 +130,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-yhadrxka.js";
+} from "./index-sjkxrf06.js";
 import {
   readRecentEscalations
-} from "./index-zhdfqz89.js";
+} from "./index-0h63swrc.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-88wb0z9r.js";
+} from "./index-3gwkmq53.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -162,7 +162,7 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-y14mwbk8.js";
+} from "./index-bdmg6yvj.js";
 import {
   clearWorktreeMergeStatus,
   getAllWorktreeMergeFailures,
@@ -174,7 +174,7 @@ import {
   listCoderSettlementWalStates,
   recoverCoderSettlement,
   recoverStaleCoderSettlements
-} from "./index-qd9mrd7e.js";
+} from "./index-r7rn6e5f.js";
 import {
   parsePorcelainV2Snapshot,
   resolveCommitCountSince,
@@ -207,7 +207,7 @@ import {
   WORKTREE_LIFECYCLE_LOCK_FILE,
   recordWorktreeProvisioningOwner,
   removeWorktreeProvisioningOwner
-} from "./index-awjx0wgk.js";
+} from "./index-9wrmzsnk.js";
 import {
   appendUnactionable,
   quarantineEntry,
@@ -218,11 +218,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-nm0cpfrv.js";
+} from "./index-77syzssw.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-f5axf6vq.js";
+} from "./index-ydbd41sv.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -253,12 +253,12 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-32avgbyq.js";
+} from "./index-vcv9m2q5.js";
 import {
   makeWorktreeBranchName,
   provisionWorktree,
   removeWorktree
-} from "./index-c1geyan9.js";
+} from "./index-6w468bjy.js";
 import {
   DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
   DELEGATION_COMPACTION_HIGH_WATER_BYTES,
@@ -286,7 +286,7 @@ import {
   scanBackgroundCoderReservationsForAdmission,
   scanDelegationsForRecovery,
   sweepStaleDelegations
-} from "./index-za42r41w.js";
+} from "./index-vkaqrrsc.js";
 import {
   compositeSessionKey,
   sessionKeySuffix
@@ -297,7 +297,7 @@ import {
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-4p6x3xxy.js";
+} from "./index-mfewnd7j.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -312,7 +312,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-hq57ytm5.js";
+} from "./index-pde4zn7j.js";
 import {
   CORE_EVENT_LOCKED,
   appendCoreEventSync,
@@ -322,7 +322,7 @@ import {
   hasSpecDriftAuditEvent,
   hasTaskRepairAuditEvent,
   readCoreEvents
-} from "./index-7619tk9a.js";
+} from "./index-kk9yk7an.js";
 import {
   sanitizeDiagnosticText
 } from "./index-556ja8an.js";
@@ -371,7 +371,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-cbcfpgz9.js";
+} from "./index-4wmpv2kn.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals as _internals2,
@@ -387,10 +387,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-hvfsz7e3.js";
+} from "./index-qw893zqp.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-jm21vbyp.js";
+} from "./index-5wq0dd30.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-zg9d392c.js";
@@ -413,7 +413,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-epjvntnm.js";
+} from "./index-tnj464kq.js";
 import {
   DEFAULT_HARNESS_EVOLUTION_CONFIG,
   DEFAULT_PR_REVIEW_RESILIENCE_CONFIG,
@@ -429,7 +429,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-rracnf2y.js";
+} from "./index-2ze7yqm8.js";
 import {
   init_git_executable,
   resolveGitExecutable,
@@ -445,7 +445,7 @@ import {
   observeCuratorCompliance,
   observeStoreHealth,
   readLearningHealth
-} from "./index-k55td019.js";
+} from "./index-80pmq6q2.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -475,10 +475,10 @@ import {
   resolveLinkDir,
   sanitizeLinkId,
   writeLinkPointer
-} from "./index-c6zyqgpq.js";
+} from "./index-7z9gyts0.js";
 import {
   atomicWriteFile
-} from "./index-d8st72j7.js";
+} from "./index-db520vnn.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -498,7 +498,7 @@ import {
   atomicWriteSwarmFileSync,
   matchTempGrammar,
   parseTargetBasename
-} from "./index-dh5q6z7y.js";
+} from "./index-q87ht62k.js";
 import {
   invalidateCachedArtifact,
   resetSwarmArtifactCache
@@ -21326,7 +21326,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9kp3cp5n.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-1wapt173.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -22463,7 +22463,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-k1e7nee3.js");
+        const skillModule = await import("./skill-generator-x6b05jz6.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -22935,7 +22935,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-cqyxfjfh.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-nyeg4ndw.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -23754,7 +23754,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-fbtgyeft.js");
+      const { getScanStatus } = await import("./scan-cursor-wjad4yd7.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.`);
@@ -23926,9 +23926,9 @@ var _internals27 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xb7d31wq.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-9ebqj7mv.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9kp3cp5n.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-1wapt173.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -23936,11 +23936,11 @@ var _internals27 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-q017rjfk.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-p0dwpn2x.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-dmwjya83.js");
+    const { checkHivePromotions } = await import("./hive-promoter-ppbrv8m1.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -23949,7 +23949,7 @@ var _internals27 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-k1e7nee3.js");
+    } = await import("./skill-generator-x6b05jz6.js");
     const result = {
       approved: [],
       rejected: [],
@@ -25279,9 +25279,9 @@ function hashContent(content) {
   return createHash13("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xb7d31wq.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-9ebqj7mv.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9kp3cp5n.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-1wapt173.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -27434,6 +27434,10 @@ class MemoryValidationError extends Error {
   }
 }
 
+// src/memory/relation-constants.ts
+var MAX_MERGE_PARTICIPANTS = 8;
+var MAX_RELATIONS_PER_MEMORY = 32;
+var RELATED_RECALL_FANOUT = 2;
 // src/memory/schema.ts
 init_zod();
 import { createHash as createHash14 } from "crypto";
@@ -27583,6 +27587,10 @@ var MemoryRecordSchema = exports_external.object({
   updatedAt: exports_external.string().datetime(),
   lastAccessedAt: exports_external.string().datetime().optional(),
   expiresAt: exports_external.string().datetime().optional(),
+  relations: exports_external.array(exports_external.object({
+    memoryId: exports_external.string().regex(/^mem_[a-f0-9]{16}$/),
+    type: exports_external.literal("merged_with")
+  }).strict()).max(32).optional(),
   qValue: exports_external.number().min(0).max(1).optional(),
   supersedes: exports_external.array(exports_external.string()).optional(),
   supersededBy: exports_external.string().optional(),
@@ -27614,7 +27622,7 @@ var MemoryProposalSchema = exports_external.object({
   ]),
   proposedRecord: MemoryRecordSchema.optional(),
   targetMemoryId: exports_external.string().optional(),
-  relatedMemoryIds: exports_external.array(exports_external.string()).optional(),
+  relatedMemoryIds: exports_external.array(exports_external.string().regex(/^mem_[a-f0-9]{16}$/)).max(MAX_MERGE_PARTICIPANTS).optional(),
   proposedBy: exports_external.object({
     agentRole: exports_external.string().optional(),
     agentId: exports_external.string().optional(),
@@ -27634,7 +27642,18 @@ var MemoryProposalSchema = exports_external.object({
   rejectionReason: exports_external.string().optional(),
   createdAt: exports_external.string().datetime(),
   metadata: exports_external.record(exports_external.string(), exports_external.unknown())
-}).strict();
+}).strict().superRefine((proposal, context) => {
+  if (proposal.operation !== "merge")
+    return;
+  const ids = proposal.relatedMemoryIds ?? [];
+  if (ids.length < 2 || new Set(ids).size !== ids.length) {
+    context.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      path: ["relatedMemoryIds"],
+      message: `merge proposals require 2-${MAX_MERGE_PARTICIPANTS} distinct relatedMemoryIds`
+    });
+  }
+});
 var NewMemoryRecordSchema = exports_external.object({
   scope: MemoryScopeRefSchema.optional(),
   kind: MemoryKindSchema,
@@ -27686,6 +27705,14 @@ var CuratorMemoryDecisionSchema = exports_external.discriminatedUnion("action",
     replacement: NewMemoryRecordSchema,
     reason: CuratorDecisionReasonSchema
   }).strict(),
+  exports_external.object({
+    action: exports_external.literal("merge"),
+    proposalId: ProposalIdSchema,
+    relatedMemoryIds: exports_external.array(MemoryIdSchema).min(2).max(MAX_MERGE_PARTICIPANTS).refine((ids) => new Set(ids).size === ids.length, {
+      message: "merge decisions require distinct relatedMemoryIds"
+    }),
+    reason: CuratorDecisionReasonSchema
+  }).strict(),
   exports_external.object({
     action: exports_external.literal("reject"),
     proposalId: ProposalIdSchema,
@@ -27790,102 +27817,6 @@ function validateMemoryProposal(proposal) {
   return MemoryProposalSchema.parse(proposal);
 }
 
-// src/memory/curator-decision-helpers.ts
-var CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH = 500;
-function validateDecisionMatchesProposal(decision, proposal) {
-  if (decision.action === "add" && proposal.operation !== "add" || decision.action === "update" && proposal.operation !== "update" || decision.action === "supersede" && proposal.operation !== "supersede") {
-    throw new MemoryValidationError(`curator ${decision.action} decision does not match ${proposal.operation} proposal`);
-  }
-  if (decision.action === "update" && proposal.targetMemoryId && proposal.targetMemoryId !== decision.targetMemoryId) {
-    throw new MemoryValidationError("curator update decision target does not match proposal target");
-  }
-  if (decision.action === "supersede" && proposal.targetMemoryId && proposal.targetMemoryId !== decision.oldMemoryId) {
-    throw new MemoryValidationError("curator supersede decision target does not match proposal target");
-  }
-}
-function validateCuratorPromotableMemory(record) {
-  if (record.stability !== "durable") {
-    throw new MemoryValidationError("curator memory promotions must be durable facts");
-  }
-  if (!DURABLE_MEMORY_KINDS.has(record.kind)) {
-    throw new MemoryValidationError("curator memory promotions must use durable fact kinds; store raw docs, search results, and other bulky source material as evidence records instead");
-  }
-  if (normalizeMemoryText(record.text).length > CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH) {
-    throw new MemoryValidationError(`curator memory promotions must be concise durable facts under ${CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH} characters`);
-  }
-}
-function applyPatchToMemory(existing, patch, updatedAt) {
-  const base = {
-    scope: patch.scope ?? existing.scope,
-    kind: patch.kind ?? existing.kind,
-    text: patch.text === undefined ? existing.text : normalizeMemoryText(patch.text)
-  };
-  const tags = patch.tags === undefined ? existing.tags : normalizeTags(patch.tags);
-  return {
-    ...existing,
-    ...patch,
-    ...base,
-    id: createMemoryId(base),
-    tags,
-    updatedAt,
-    contentHash: computeMemoryContentHash(base),
-    metadata: patch.metadata === undefined ? existing.metadata : { ...existing.metadata, ...patch.metadata }
-  };
-}
-function markProposalReviewed(proposal, decision, status, reviewedAt, ids) {
-  const reason = curatorDecisionReason(decision);
-  return validateMemoryProposal({
-    ...proposal,
-    status,
-    reviewer: "curator_agent",
-    reviewedAt,
-    rejectionReason: decision.action === "reject" ? reason : undefined,
-    metadata: {
-      ...proposal.metadata,
-      curatorDecision: {
-        action: decision.action,
-        reason,
-        ...ids,
-        appliedAt: reviewedAt
-      }
-    }
-  });
-}
-function curatorDecisionReason(decision) {
-  switch (decision.action) {
-    case "add":
-      return;
-    case "update":
-    case "supersede":
-    case "reject":
-    case "noop":
-      return decision.reason;
-  }
-}
-function buildCuratorDecisionEvent(change, proposal) {
-  return {
-    ...change,
-    proposalOperation: proposal.operation
-  };
-}
-function normalizeTags(tags) {
-  return Array.from(new Set(tags.map((tag) => tag.toLowerCase().replace(/[^\w-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")).filter(Boolean))).slice(0, 32);
-}
-
-// src/memory/local-jsonl-provider.ts
-var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
-import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
-import {
-  appendFile as appendFile3,
-  mkdir as mkdir9,
-  readFile as readFile10,
-  rename as rename5,
-  truncate,
-  writeFile as writeFile7
-} from "fs/promises";
-import * as path32 from "path";
-
 // src/memory/q-learning.ts
 function clamp01(value) {
   if (value < 0)
@@ -28115,6 +28046,10 @@ function sameScope(a, b) {
 function scopeAllowed(recordScope, allowedScopes) {
   return allowedScopes.some((scope) => sameScope(recordScope, scope));
 }
+function scoreMemoryRecord(record, request, qLearningConfig = DEFAULT_QLEARNING_CONFIG) {
+  const result = scoreMemoryRecordDetailed(record, request, createScoringContext(request), qLearningConfig);
+  return result.item;
+}
 function scoreMemoryRecordDetailed(record, request, context, qLearningConfig = DEFAULT_QLEARNING_CONFIG) {
   if (!request.includeExpired && isExpired(record)) {
     return { item: null, skipReason: "filtered" };
@@ -28280,6 +28215,218 @@ function unionTokens(...sets) {
   return union;
 }
 
+// src/memory/relations.ts
+function canonicalMemoryIds(ids) {
+  return Array.from(new Set(ids)).sort();
+}
+function buildMemoryRelationIndex(proposals) {
+  const index = new Map;
+  for (const proposal of proposals) {
+    if (proposal.operation !== "merge" || proposal.status !== "applied")
+      continue;
+    const ids = canonicalMemoryIds(proposal.relatedMemoryIds ?? []);
+    for (const sourceId of ids) {
+      let related = index.get(sourceId);
+      if (!related) {
+        related = new Map;
+        index.set(sourceId, related);
+      }
+      for (const targetId of ids) {
+        if (targetId !== sourceId) {
+          related.set(targetId, { memoryId: targetId, type: "merged_with" });
+        }
+      }
+    }
+  }
+  return new Map(Array.from(index, ([id, relations]) => [
+    id,
+    Array.from(relations.values()).sort((a, b) => a.memoryId.localeCompare(b.memoryId))
+  ]));
+}
+function projectMemoryRelations(records, proposals) {
+  const index = buildMemoryRelationIndex(proposals);
+  return records.map(({ relations: _derived, ...record }) => {
+    const relations = index.get(record.id);
+    return relations?.length ? { ...record, relations } : record;
+  });
+}
+function stripDerivedRelations(record) {
+  const { relations: _derived, ...stored } = record;
+  return stored;
+}
+function validateMergeParticipants(ids, records, proposals, now2 = new Date) {
+  const canonical = canonicalMemoryIds(ids);
+  if (canonical.length < 2 || canonical.length > MAX_MERGE_PARTICIPANTS) {
+    throw new MemoryValidationError(`merge decisions require 2-${MAX_MERGE_PARTICIPANTS} distinct relatedMemoryIds`);
+  }
+  const byId = new Map(Array.from(records, (record) => [record.id, record]));
+  const participants = canonical.map((id) => {
+    const record = byId.get(id);
+    if (!record || record.metadata.deleted === true || record.supersededBy || isExpired(record, now2)) {
+      throw new MemoryValidationError(`merge participant is not active: ${id}`);
+    }
+    return record;
+  });
+  const scopeKey = stableScopeKey(participants[0].scope);
+  if (participants.some((record) => stableScopeKey(record.scope) !== scopeKey)) {
+    throw new MemoryValidationError("merge participants must share one memory scope");
+  }
+  const index = buildMemoryRelationIndex(proposals);
+  for (const id of canonical) {
+    const degree = new Set([
+      ...index.get(id)?.map((relation) => relation.memoryId) ?? [],
+      ...canonical.filter((candidate) => candidate !== id)
+    ]).size;
+    if (degree > MAX_RELATIONS_PER_MEMORY) {
+      throw new MemoryValidationError(`merge would exceed ${MAX_RELATIONS_PER_MEMORY} relations for ${id}`);
+    }
+  }
+  return canonical;
+}
+function expandRelatedRecallItems(items, allRecords, request) {
+  const normal = items.filter((item) => !item.explored).slice(0, request.maxItems);
+  const explored = items.filter((item) => item.explored);
+  if (normal.length < request.maxItems) {
+    const byId = new Map(allRecords.map((record) => [record.id, record]));
+    const selected = new Set([...normal, ...explored].map((item) => item.record.id));
+    const directSources = [...normal];
+    for (const source of directSources) {
+      const sourceRecord = byId.get(source.record.id) ?? source.record;
+      let addedForSource = 0;
+      for (const relation of sourceRecord.relations ?? []) {
+        if (normal.length >= request.maxItems || addedForSource >= RELATED_RECALL_FANOUT) {
+          break;
+        }
+        if (selected.has(relation.memoryId))
+          continue;
+        const record = byId.get(relation.memoryId);
+        if (!record)
+          continue;
+        const scored = scoreMemoryRecord(record, {
+          ...request,
+          requireQuerySignal: false
+        });
+        if (!scored)
+          continue;
+        normal.push({
+          ...scored,
+          reason: `${scored.reason}, relation=${relation.type}, related_from=${source.record.id}`,
+          relation: { type: relation.type, sourceMemoryId: source.record.id }
+        });
+        selected.add(record.id);
+        addedForSource++;
+      }
+    }
+  }
+  const seen = new Set;
+  return [...normal, ...explored].filter((item) => {
+    if (seen.has(item.record.id))
+      return false;
+    seen.add(item.record.id);
+    return true;
+  });
+}
+
+// src/memory/curator-decision-helpers.ts
+var CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH = 500;
+function validateDecisionMatchesProposal(decision, proposal) {
+  if (decision.action === "add" && proposal.operation !== "add" || decision.action === "update" && proposal.operation !== "update" || decision.action === "supersede" && proposal.operation !== "supersede" || decision.action === "merge" && proposal.operation !== "merge") {
+    throw new MemoryValidationError(`curator ${decision.action} decision does not match ${proposal.operation} proposal`);
+  }
+  if (decision.action === "update" && proposal.targetMemoryId && proposal.targetMemoryId !== decision.targetMemoryId) {
+    throw new MemoryValidationError("curator update decision target does not match proposal target");
+  }
+  if (decision.action === "supersede" && proposal.targetMemoryId && proposal.targetMemoryId !== decision.oldMemoryId) {
+    throw new MemoryValidationError("curator supersede decision target does not match proposal target");
+  }
+  if (decision.action === "merge" && canonicalMemoryIds(proposal.relatedMemoryIds ?? []).join("\x00") !== canonicalMemoryIds(decision.relatedMemoryIds).join("\x00")) {
+    throw new MemoryValidationError("curator merge decision related memories do not match proposal");
+  }
+}
+function validateCuratorPromotableMemory(record) {
+  if (record.stability !== "durable") {
+    throw new MemoryValidationError("curator memory promotions must be durable facts");
+  }
+  if (!DURABLE_MEMORY_KINDS.has(record.kind)) {
+    throw new MemoryValidationError("curator memory promotions must use durable fact kinds; store raw docs, search results, and other bulky source material as evidence records instead");
+  }
+  if (normalizeMemoryText(record.text).length > CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH) {
+    throw new MemoryValidationError(`curator memory promotions must be concise durable facts under ${CURATOR_PROMOTED_MEMORY_MAX_TEXT_LENGTH} characters`);
+  }
+}
+function applyPatchToMemory(existing, patch, updatedAt) {
+  const base = {
+    scope: patch.scope ?? existing.scope,
+    kind: patch.kind ?? existing.kind,
+    text: patch.text === undefined ? existing.text : normalizeMemoryText(patch.text)
+  };
+  const tags = patch.tags === undefined ? existing.tags : normalizeTags(patch.tags);
+  return {
+    ...existing,
+    ...patch,
+    ...base,
+    id: createMemoryId(base),
+    tags,
+    updatedAt,
+    contentHash: computeMemoryContentHash(base),
+    metadata: patch.metadata === undefined ? existing.metadata : { ...existing.metadata, ...patch.metadata }
+  };
+}
+function markProposalReviewed(proposal, decision, status, reviewedAt, ids) {
+  const reason = curatorDecisionReason(decision);
+  return validateMemoryProposal({
+    ...proposal,
+    status,
+    reviewer: "curator_agent",
+    reviewedAt,
+    rejectionReason: decision.action === "reject" ? reason : undefined,
+    metadata: {
+      ...proposal.metadata,
+      curatorDecision: {
+        action: decision.action,
+        reason,
+        ...ids,
+        appliedAt: reviewedAt
+      }
+    }
+  });
+}
+function curatorDecisionReason(decision) {
+  switch (decision.action) {
+    case "add":
+      return;
+    case "update":
+    case "supersede":
+    case "merge":
+    case "reject":
+    case "noop":
+      return decision.reason;
+  }
+}
+function buildCuratorDecisionEvent(change, proposal) {
+  return {
+    ...change,
+    proposalOperation: proposal.operation
+  };
+}
+function normalizeTags(tags) {
+  return Array.from(new Set(tags.map((tag) => tag.toLowerCase().replace(/[^\w-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")).filter(Boolean))).slice(0, 32);
+}
+
+// src/memory/local-jsonl-provider.ts
+var import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
+import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import {
+  appendFile as appendFile3,
+  mkdir as mkdir9,
+  readFile as readFile10,
+  rename as rename5,
+  truncate,
+  writeFile as writeFile7
+} from "fs/promises";
+import * as path32 from "path";
+
 // src/memory/maintenance.ts
 var DEFAULT_IMPORTANCE_WEIGHTS = {
   wRecency: 0.2,
@@ -28601,6 +28748,56 @@ function compareText(a, b) {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
+// src/memory/proposal-load.ts
+var INVALID_PROPOSAL_LOAD_SAMPLE_LIMIT = 5;
+var UNKNOWN_PROPOSAL_ID = "<unknown>";
+var MAX_PROPOSAL_LOAD_REASON_LENGTH = 200;
+function parseLoadedProposal(value, rejectDurableSecrets) {
+  const proposal = validateMemoryProposal(value);
+  if (proposal.proposedRecord) {
+    validateMemoryRecordRules(proposal.proposedRecord, {
+      rejectDurableSecrets
+    });
+  }
+  return proposal;
+}
+function proposalLoadIssueFromValue(value, error2) {
+  return {
+    proposalId: extractProposalId(value) ?? UNKNOWN_PROPOSAL_ID,
+    reason: normalizeProposalLoadReason(error2)
+  };
+}
+function proposalLoadIssueFromId(proposalId, error2) {
+  return {
+    proposalId: proposalId || UNKNOWN_PROPOSAL_ID,
+    reason: normalizeProposalLoadReason(error2)
+  };
+}
+function buildProposalLoadDiagnostics(issues) {
+  return {
+    invalidCount: issues.length,
+    samples: issues.slice(0, INVALID_PROPOSAL_LOAD_SAMPLE_LIMIT)
+  };
+}
+function asStoredProposalValidationError(proposalId, error2) {
+  if (error2 instanceof MemoryValidationError)
+    return error2;
+  return new MemoryValidationError(`stored memory proposal is malformed: ${proposalId} (${normalizeProposalLoadReason(error2)})`, "stored_memory_proposal_invalid");
+}
+function extractProposalId(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const candidate = value.id;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : undefined;
+}
+function normalizeProposalLoadReason(error2) {
+  const raw = error2 instanceof Error ? error2.message : String(error2);
+  const trimmed = raw.replace(/\s+/g, " ").trim();
+  if (trimmed.length <= MAX_PROPOSAL_LOAD_REASON_LENGTH)
+    return trimmed;
+  return `${trimmed.slice(0, MAX_PROPOSAL_LOAD_REASON_LENGTH - 1)}\u2026`;
+}
+
 // src/memory/local-jsonl-provider.ts
 var lockfile6 = import_proper_lockfile6.default;
 
@@ -28612,6 +28809,7 @@ class LocalJsonlMemoryProvider {
   initialized = false;
   memories = new Map;
   proposals = new Map;
+  lastInvalidProposalLoadSignature = null;
   constructor(rootDirectory, config = {}, vettedCohortRoot) {
     this.rootDirectory = rootDirectory;
     this.cohortRoot = vettedCohortRoot ?? null;
@@ -28634,7 +28832,10 @@ class LocalJsonlMemoryProvider {
     const memoryPath = this.pathFor("memories");
     const proposalPath = this.pathFor("proposals");
     const memoryLoad = validateLoadedMemories(await readJsonl(memoryPath), this.config);
-    const proposalLoad = validateLoadedProposals(await readJsonl(proposalPath), this.config);
+    const rawProposalLoad = await readProposalJsonl(proposalPath);
+    const proposalLoad = validateLoadedProposals(rawProposalLoad.values, this.config);
+    proposalLoad.invalidCount += rawProposalLoad.invalidRows.length;
+    proposalLoad.invalidRows.unshift(...rawProposalLoad.invalidRows);
     const outcomeEvents = this.readOutcomeEventsSync();
     const materializedLoad = validateMaterializedMemories(memoryLoad.records, outcomeEvents, this.config);
     this.memories = new Map(materializedLoad.records.map((record) => [record.id, record]));
@@ -28645,7 +28846,9 @@ class LocalJsonlMemoryProvider {
       await this.audit("invalid_load", "memories", `${invalidMemoryCount} invalid memory JSONL row(s) skipped`);
     }
     if (proposalLoad.invalidCount > 0) {
-      await this.audit("invalid_load", "proposals", `${proposalLoad.invalidCount} invalid proposal JSONL row(s) skipped`);
+      await this.reportInvalidProposalLoad(proposalLoad.invalidRows);
+    } else {
+      this.lastInvalidProposalLoadSignature = null;
     }
   }
   async upsert(record) {
@@ -28657,7 +28860,7 @@ class LocalJsonlMemoryProvider {
         throw new MemoryValidationError("memory is tombstoned and cannot be upserted");
       }
       let parsed = validateMemoryRecordRules({
-        ...record,
+        ...stripDerivedRelations(record),
         createdAt: existing?.createdAt ?? record.createdAt,
         metadata: {
           ...record.metadata,
@@ -28702,7 +28905,9 @@ class LocalJsonlMemoryProvider {
     await this.initialize();
     return this.withOutcomeStoreLock(async () => {
       await this.refreshMemoriesUnlocked();
-      return this.memories.get(id) ?? null;
+      await this.refreshProposalsUnlocked();
+      const record = this.memories.get(id);
+      return record ? projectMemoryRelations([record], this.proposals.values())[0] : null;
     });
   }
   async appendOutcome(memoryId, event, anchors = []) {
@@ -28790,12 +28995,13 @@ class LocalJsonlMemoryProvider {
     });
     const result = scoreMemoryRecordsWithDiagnostics(records, request, this.config.qLearning);
     const sliced = sliceRecallItemsWithExploration(result.items, request.maxItems);
+    const expanded = expandRelatedRecallItems(sliced, projectMemoryRelations(Array.from(this.memories.values()), this.proposals.values()), request);
     return {
-      items: sliced,
+      items: expanded,
       diagnostics: {
         ...result.diagnostics,
-        exploredCount: sliced.some((item) => item.explored) ? 1 : 0,
-        returnedCount: sliced.length
+        exploredCount: expanded.some((item) => item.explored) ? 1 : 0,
+        returnedCount: expanded.length
       }
     };
   }
@@ -28848,8 +29054,9 @@ class LocalJsonlMemoryProvider {
     await this.initialize();
     await this.withOutcomeStoreLock(async () => {
       await this.refreshMemoriesUnlocked();
+      await this.refreshProposalsUnlocked();
     });
-    let records = Array.from(this.memories.values());
+    let records = projectMemoryRelations(Array.from(this.memories.values()), this.proposals.values());
     if (filter.scopes && filter.scopes.length > 0) {
       records = records.filter((record) => scopeAllowed(record.scope, filter.scopes ?? []));
     }
@@ -28874,8 +29081,13 @@ class LocalJsonlMemoryProvider {
   async createProposal(proposal) {
     await this.initialize();
     const next = validateMemoryProposal(proposal);
-    this.proposals.set(next.id, next);
-    await appendJsonl(this.pathFor("proposals"), next);
+    await this.withOutcomeStoreLock(async () => {
+      await this.refreshProposalsUnlocked();
+      const filePath = this.pathFor("proposals");
+      await repairIncompleteJsonlTail(filePath);
+      await appendJsonl(filePath, next);
+      this.proposals.set(next.id, next);
+    });
     await this.audit("proposal", next.id);
     this.bumpCohortGeneration();
     return next;
@@ -28968,11 +29180,24 @@ class LocalJsonlMemoryProvider {
       oldMemoryId = oldMemory.id;
       replacementMemoryId = replacement.id;
       memoryId = replacement.id;
+    } else if (decision.action === "merge") {
+      decision = {
+        ...decision,
+        relatedMemoryIds: validateMergeParticipants(decision.relatedMemoryIds, this.memories.values(), this.proposals.values(), new Date(appliedAt))
+      };
     }
     const proposalStatus = decision.action === "reject" ? "rejected" : "applied";
-    const reviewedProposal = markProposalReviewed(proposal, decision, proposalStatus, appliedAt, { memoryId, targetMemoryId, oldMemoryId, replacementMemoryId });
+    const reviewedProposal = markProposalReviewed(proposal, decision, proposalStatus, appliedAt, {
+      memoryId,
+      targetMemoryId,
+      oldMemoryId,
+      replacementMemoryId,
+      relatedMemoryIds: decision.action === "merge" ? decision.relatedMemoryIds : undefined
+    });
+    const proposalsPath = this.pathFor("proposals");
+    await repairIncompleteJsonlTail(proposalsPath);
+    await appendJsonl(proposalsPath, reviewedProposal);
     this.proposals.set(reviewedProposal.id, reviewedProposal);
-    await appendJsonl(this.pathFor("proposals"), reviewedProposal);
     const change = {
       action: decision.action,
       proposalId: decision.proposalId,
@@ -28982,9 +29207,16 @@ class LocalJsonlMemoryProvider {
       targetMemoryId,
       oldMemoryId,
       replacementMemoryId,
+      relatedMemoryIds: decision.action === "merge" ? decision.relatedMemoryIds : undefined,
       reason: curatorDecisionReason(decision)
     };
-    await this.audit("curator_decision", decision.proposalId, change.reason, buildCuratorDecisionEvent(change, proposal));
+    try {
+      await this.audit("curator_decision", decision.proposalId, change.reason, buildCuratorDecisionEvent(change, proposal));
+    } catch (error2) {
+      warn("[memory] failed to persist curator decision audit event", {
+        reason: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
     return change;
   }
   async compact() {
@@ -29070,8 +29302,32 @@ class LocalJsonlMemoryProvider {
     await appendJsonl(filePath, stripMaterializedOutcomes(record));
   }
   async refreshProposalsUnlocked() {
-    const loaded = validateLoadedProposals(await readJsonl(this.pathFor("proposals")), this.config);
+    const proposalPath = this.pathFor("proposals");
+    await repairIncompleteJsonlTail(proposalPath);
+    const rawProposalLoad = await readProposalJsonl(proposalPath);
+    const loaded = validateLoadedProposals(rawProposalLoad.values, this.config);
+    loaded.invalidCount += rawProposalLoad.invalidRows.length;
+    loaded.invalidRows.unshift(...rawProposalLoad.invalidRows);
     this.proposals = new Map(loaded.records.map((proposal) => [proposal.id, proposal]));
+    if (loaded.invalidCount > 0) {
+      await this.reportInvalidProposalLoad(loaded.invalidRows);
+    } else {
+      this.lastInvalidProposalLoadSignature = null;
+    }
+  }
+  async reportInvalidProposalLoad(issues) {
+    const eventJson = buildProposalLoadDiagnostics(issues);
+    const signature = JSON.stringify(eventJson);
+    if (signature === this.lastInvalidProposalLoadSignature)
+      return;
+    this.lastInvalidProposalLoadSignature = signature;
+    try {
+      await this.audit("invalid_load", "proposals", `${issues.length} invalid proposal JSONL row(s) skipped`, eventJson);
+    } catch (error2) {
+      warn("[memory] failed to persist invalid proposal load audit event", {
+        reason: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
   }
   readOutcomeEventsSync() {
     const filePath = this.pathFor("outcome-events");
@@ -29230,21 +29486,18 @@ function compareText2(a, b) {
 }
 function validateLoadedProposals(values, config) {
   const records = [];
+  const invalidRows = [];
   let invalidCount = 0;
   for (const value of values) {
     try {
-      const proposal = validateMemoryProposal(value);
-      if (proposal.proposedRecord) {
-        validateMemoryRecordRules(proposal.proposedRecord, {
-          rejectDurableSecrets: config.redaction.rejectDurableSecrets
-        });
-      }
+      const proposal = parseLoadedProposal(value, config.redaction.rejectDurableSecrets);
       records.push(proposal);
-    } catch {
+    } catch (error2) {
       invalidCount++;
+      invalidRows.push(proposalLoadIssueFromValue(value, error2));
     }
   }
-  return { records, invalidCount };
+  return { records, invalidCount, invalidRows };
 }
 async function readJsonl(filePath) {
   if (!existsSync17(filePath))
@@ -29262,6 +29515,28 @@ async function readJsonl(filePath) {
   }
   return records;
 }
+async function readProposalJsonl(filePath) {
+  if (!existsSync17(filePath))
+    return { values: [], invalidRows: [] };
+  const content = await readFile10(filePath, "utf-8");
+  const values = [];
+  const invalidRows = [];
+  for (const [index, line] of content.split(`
+`).entries()) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      values.push(JSON.parse(trimmed));
+    } catch {
+      invalidRows.push({
+        proposalId: "<unknown>",
+        reason: `invalid JSONL at line ${index + 1}`
+      });
+    }
+  }
+  return { values, invalidRows };
+}
 async function readAuditEvents(filePath) {
   const values = await readJsonl(filePath);
   const events = [];
@@ -29740,7 +30015,7 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
   const memoryLoad = await readMemoryJsonl(path35.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path35.join(storageDir, "proposals.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl2(path35.join(storageDir, "proposals.jsonl"), resolved);
   const outcomeLoad = await readOutcomeJsonl(path35.join(storageDir, "outcome-events.jsonl"));
   return {
     memories: memoryLoad.records,
@@ -29939,24 +30214,20 @@ async function readMemoryJsonl(filePath, config) {
     totalRows: rows.totalRows
   };
 }
-async function readProposalJsonl(filePath, config) {
+async function readProposalJsonl2(filePath, config) {
   const rows = await readJsonlRows(filePath);
   const records = [];
   const invalidRows = [];
   for (const row of rows.rows) {
     try {
-      const proposal = validateMemoryProposal(row.value);
-      if (proposal.proposedRecord) {
-        validateMemoryRecordRules(proposal.proposedRecord, {
-          rejectDurableSecrets: config.redaction.rejectDurableSecrets
-        });
-      }
+      const proposal = parseLoadedProposal(row.value, config.redaction.rejectDurableSecrets);
       records.push(proposal);
     } catch (err) {
+      const issue = proposalLoadIssueFromValue(row.value, err);
       invalidRows.push({
         file: "proposals.jsonl",
         line: row.line,
-        error: err instanceof Error ? err.message : String(err)
+        error: issue.reason
       });
     }
   }
@@ -30299,6 +30570,24 @@ var MIGRATIONS2 = [
     sql: `
 			ALTER TABLE memory_events ADD COLUMN prev_hash TEXT;
 		`
+  },
+  {
+    version: 14,
+    name: "create_memory_relations",
+    sql: `
+			CREATE TABLE IF NOT EXISTS memory_relations (
+				source_id TEXT NOT NULL,
+				target_id TEXT NOT NULL,
+				proposal_id TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				PRIMARY KEY (source_id, target_id),
+				FOREIGN KEY (source_id) REFERENCES memory_items(id) ON DELETE CASCADE,
+				FOREIGN KEY (target_id) REFERENCES memory_items(id) ON DELETE CASCADE,
+				FOREIGN KEY (proposal_id) REFERENCES memory_proposals(id)
+			);
+			CREATE INDEX IF NOT EXISTS idx_memory_relations_source
+				ON memory_relations(source_id, target_id);
+		`
   }
 ];
 var EVENT_CHAIN_SCHEMA_MIGRATION_NAME = "add_memory_events_prev_hash";
@@ -30431,6 +30720,14 @@ class SQLiteMemoryProvider {
       await this.migrateLegacyJsonlIfNeeded();
       const memoryLoad = this.loadMemories();
       const proposalLoad = this.loadProposals();
+      for (const proposal of proposalLoad.records) {
+        if (proposal.operation === "merge" && proposal.status === "applied") {
+          this.writeProposal(proposal, {
+            records: memoryLoad.records,
+            proposals: proposalLoad.records
+          });
+        }
+      }
       this.memories = new Map(memoryLoad.records.map((record) => [record.id, record]));
       this.proposals = new Map(proposalLoad.records.map((proposal) => [proposal.id, proposal]));
       this.initialized = true;
@@ -30438,7 +30735,13 @@ class SQLiteMemoryProvider {
         await this.event("invalid_load", "memory_items", `${memoryLoad.invalidCount} invalid SQLite memory row(s) skipped`);
       }
       if (proposalLoad.invalidCount > 0) {
-        await this.event("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`);
+        try {
+          this.insertEvent("invalid_load", "memory_proposals", `${proposalLoad.invalidCount} invalid SQLite proposal row(s) skipped`, JSON.stringify(buildProposalLoadDiagnostics(proposalLoad.invalidRows)));
+        } catch (error2) {
+          warn("[memory] failed to persist invalid SQLite proposal load event", {
+            reason: error2 instanceof Error ? error2.message : String(error2)
+          });
+        }
       }
     } catch (err) {
       try {
@@ -30463,7 +30766,8 @@ class SQLiteMemoryProvider {
       if (existing?.metadata.deleted === true) {
         throw new MemoryValidationError("memory is tombstoned and cannot be upserted");
       }
-      const merged = existingRow ? mergeProvenanceColumns(record, existingRow) : record;
+      const storedRecord = stripDerivedRelations(record);
+      const merged = existingRow ? mergeProvenanceColumns(storedRecord, existingRow) : storedRecord;
       next = validateMemoryRecordRules({
         ...merged,
         createdAt: existing?.createdAt ?? merged.createdAt,
@@ -30512,7 +30816,7 @@ class SQLiteMemoryProvider {
     const record = this.readMemoryById(id);
     if (record)
       this.memories.set(id, record);
-    return record;
+    return record ? this.projectRelationsFromStorage([record])[0] : null;
   }
   async appendOutcome(memoryId, event, anchors = []) {
     await this.initialize();
@@ -30629,12 +30933,13 @@ class SQLiteMemoryProvider {
       const result = scoreMemoryRecordsWithDiagnostics(candidates.records, request, this.config.qLearning);
       const reranked = candidates.ftsOrder ? rerankWithFts(result.items, candidates.ftsOrder) : result.items;
       const disabledPathSliced = sliceRecallItemsWithExploration(reranked, request.maxItems);
+      const expanded2 = this.expandRelated(disabledPathSliced, request);
       return {
-        items: disabledPathSliced,
+        items: expanded2,
         diagnostics: {
           ...result.diagnostics,
-          exploredCount: disabledPathSliced.some((item) => item.explored) ? 1 : 0,
-          returnedCount: disabledPathSliced.length
+          exploredCount: expanded2.some((item) => item.explored) ? 1 : 0,
+          returnedCount: expanded2.length
         }
       };
     }
@@ -30675,12 +30980,13 @@ class SQLiteMemoryProvider {
         });
       }
       const denseFailedSliced = sliceRecallItemsWithExploration(lexicalReranked, request.maxItems);
+      const expanded2 = this.expandRelated(denseFailedSliced, request);
       return {
-        items: denseFailedSliced,
+        items: expanded2,
         diagnostics: {
           ...lexicalResult.diagnostics,
-          exploredCount: denseFailedSliced.some((item) => item.explored) ? 1 : 0,
-          returnedCount: denseFailedSliced.length
+          exploredCount: expanded2.some((item) => item.explored) ? 1 : 0,
+          returnedCount: expanded2.length
         }
       };
     }
@@ -30751,16 +31057,33 @@ class SQLiteMemoryProvider {
       }
     }
     const fusionSliced = sliceRecallItemsWithExploration(rerankedItems, request.maxItems);
+    const expanded = this.expandRelated(fusionSliced, request);
     return {
-      items: fusionSliced,
+      items: expanded,
       diagnostics: {
         ...lexicalResult.diagnostics,
-        exploredCount: fusionSliced.some((item) => item.explored) ? 1 : 0,
-        returnedCount: fusionSliced.length,
+        exploredCount: expanded.some((item) => item.explored) ? 1 : 0,
+        returnedCount: expanded.length,
         fusionActive: true
       }
     };
   }
+  expandRelated(items, request) {
+    const sources = this.projectRelationsFromStorage(items.map((item) => item.record));
+    const sourceById = new Map(sources.map((record) => [record.id, record]));
+    const relatedRecords = [];
+    for (const source of sources) {
+      for (const relation of (source.relations ?? []).slice(0, RELATED_RECALL_FANOUT)) {
+        const record = this.readMemoryById(relation.memoryId);
+        if (record)
+          relatedRecords.push(record);
+      }
+    }
+    return expandRelatedRecallItems(items.map((item) => ({
+      ...item,
+      record: sourceById.get(item.record.id) ?? item.record
+    })), [...sources, ...relatedRecords], request);
+  }
   async recordRecallUsage(event) {
     await this.initialize();
     this.requireDb().run(`INSERT INTO memory_recall_usage (
@@ -30956,7 +31279,7 @@ class SQLiteMemoryProvider {
         return !Number.isFinite(expires) || expires > now2;
       });
     }
-    return records;
+    return this.projectRelationsFromStorage(records);
   }
   async createProposal(proposal) {
     await this.initialize();
@@ -30973,7 +31296,7 @@ class SQLiteMemoryProvider {
   }
   async listProposals(filter = {}) {
     await this.initialize();
-    let proposals = Array.from(this.proposals.values());
+    let proposals = this.refreshProposalsFromStorage();
     if (filter.status) {
       proposals = proposals.filter((proposal) => proposal.status === filter.status);
     }
@@ -31113,7 +31436,8 @@ class SQLiteMemoryProvider {
     const provenanceById = new Map(this.requireDb().query("SELECT id, source_task_id, agent_role, embedding_model_version, valid_from, supersedes_reason FROM memory_items").all().map((row) => [row.id, row]));
     const enriched = memories.map((memory) => {
       const row = provenanceById.get(memory.id);
-      return row ? mergeProvenanceColumns(memory, row) : memory;
+      const stored = stripDerivedRelations(memory);
+      return row ? mergeProvenanceColumns(stored, row) : stored;
     });
     const proposals = await this.listProposals();
     const outcomeEvents = this.readOutcomeEvents();
@@ -31542,21 +31866,41 @@ class SQLiteMemoryProvider {
   loadProposals() {
     const rows = this.requireDb().query("SELECT id, proposal_json FROM memory_proposals ORDER BY created_at ASC").all();
     const records = [];
+    const invalidRows = [];
     let invalidCount = 0;
     for (const row of rows) {
       try {
-        const proposal = validateMemoryProposal(JSON.parse(row.proposal_json));
-        if (proposal.proposedRecord) {
-          validateMemoryRecordRules(proposal.proposedRecord, {
-            rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
-          });
-        }
+        const proposal = parseLoadedProposal(JSON.parse(row.proposal_json), this.config.redaction.rejectDurableSecrets);
         records.push(proposal);
-      } catch {
+      } catch (error2) {
         invalidCount++;
+        invalidRows.push(proposalLoadIssueFromId(row.id, error2));
       }
     }
-    return { records, invalidCount };
+    return { records, invalidCount, invalidRows };
+  }
+  refreshProposalsFromStorage() {
+    const records = this.loadProposals().records;
+    this.proposals.clear();
+    for (const proposal of records)
+      this.proposals.set(proposal.id, proposal);
+    return records;
+  }
+  projectRelationsFromStorage(records) {
+    if (records.length === 0)
+      return [];
+    const query = this.requireDb().prepare(" SELECT target_id FROM memory_relations WHERE source_id = ? ORDER BY target_id ASC LIMIT ?");
+    try {
+      return records.map(({ relations: _derived, ...record }) => {
+        const relations = query.all(record.id, MAX_RELATIONS_PER_MEMORY).map((row) => ({
+          memoryId: row.target_id,
+          type: "merged_with"
+        }));
+        return relations.length ? { ...record, relations } : record;
+      });
+    } finally {
+      query.finalize();
+    }
   }
   writeMemory(record) {
     const stored = stripMaterializedOutcomes(record);
@@ -31778,7 +32122,7 @@ class SQLiteMemoryProvider {
       this.requireDb().run("DELETE FROM memory_items_vec WHERE id = ?", [id]);
     } catch {}
   }
-  writeProposal(proposal) {
+  writeProposal(proposal, validationContext) {
     this.requireDb().run(`INSERT OR REPLACE INTO memory_proposals (
 				id,
 				status,
@@ -31790,6 +32134,33 @@ class SQLiteMemoryProvider {
       proposal.createdAt,
       JSON.stringify(proposal)
     ]);
+    if (proposal.operation === "merge" && proposal.status === "applied") {
+      this.requireDb().run("DELETE FROM memory_relations WHERE proposal_id = ?", [proposal.id]);
+      let ids;
+      try {
+        ids = validateMergeParticipants(proposal.relatedMemoryIds ?? [], validationContext?.records ?? this.loadMemories().records, validationContext?.proposals ?? this.loadProposals().records, proposal.reviewedAt ? new Date(proposal.reviewedAt) : new Date);
+      } catch (error2) {
+        warn("Skipping invalid applied merge during relation materialization", {
+          proposalId: proposal.id,
+          reason: error2 instanceof Error ? error2.message : String(error2)
+        });
+        return;
+      }
+      const existingIds = new Set(ids.filter((id) => Boolean(this.requireDb().query("SELECT id FROM memory_items WHERE id = ? LIMIT 1").get(id))));
+      for (const sourceId of ids) {
+        for (const targetId of ids) {
+          if (sourceId === targetId || !existingIds.has(sourceId) || !existingIds.has(targetId)) {
+            continue;
+          }
+          this.requireDb().run("INSERT OR IGNORE INTO memory_relations (source_id, target_id, proposal_id, created_at) VALUES (?, ?, ?, ?)", [
+            sourceId,
+            targetId,
+            proposal.id,
+            proposal.reviewedAt ?? proposal.createdAt
+          ]);
+        }
+      }
+    }
   }
   applyDecisionToStorage(decision, proposal, appliedAt) {
     const memories = [];
@@ -31854,13 +32225,21 @@ class SQLiteMemoryProvider {
       oldMemoryId = oldMemory.id;
       replacementMemoryId = replacement.id;
       memoryId = replacement.id;
+    } else if (decision.action === "merge") {
+      const currentMemories = this.loadMemories().records;
+      const currentProposals = this.loadProposals().records;
+      decision = {
+        ...decision,
+        relatedMemoryIds: validateMergeParticipants(decision.relatedMemoryIds, currentMemories, currentProposals, new Date(appliedAt))
+      };
     }
     const proposalStatus = decision.action === "reject" ? "rejected" : "applied";
     const reviewedProposal = markProposalReviewed(proposal, decision, proposalStatus, appliedAt, {
       memoryId,
       targetMemoryId,
       oldMemoryId,
-      replacementMemoryId
+      replacementMemoryId,
+      relatedMemoryIds: decision.action === "merge" ? decision.relatedMemoryIds : undefined
     });
     const change = {
       action: decision.action,
@@ -31871,6 +32250,7 @@ class SQLiteMemoryProvider {
       targetMemoryId,
       oldMemoryId,
       replacementMemoryId,
+      relatedMemoryIds: decision.action === "merge" ? decision.relatedMemoryIds : undefined,
       reason: curatorDecisionReason(decision)
     };
     return {
@@ -31885,15 +32265,15 @@ class SQLiteMemoryProvider {
     if (!row) {
       throw new MemoryValidationError("memory proposal was not found");
     }
-    const proposal = validateMemoryProposal(JSON.parse(row.proposal_json));
+    let proposal;
+    try {
+      proposal = parseLoadedProposal(JSON.parse(row.proposal_json), this.config.redaction.rejectDurableSecrets);
+    } catch (error2) {
+      throw asStoredProposalValidationError(row.id, error2);
+    }
     if (proposal.status !== "pending") {
       throw new MemoryValidationError("memory proposal is not pending");
     }
-    if (proposal.proposedRecord) {
-      validateMemoryRecordRules(proposal.proposedRecord, {
-        rejectDurableSecrets: this.config.redaction.rejectDurableSecrets
-      });
-    }
     return proposal;
   }
   readActiveMemory(memoryId) {
@@ -31954,7 +32334,7 @@ class SQLiteMemoryProvider {
     for (const sourceRow of payload.memoryRows) {
       const rawRecord = sourceRow.record;
       const record = (rawRecord.outcomes?.length ?? 0) > 0 ? ensureOutcomeGeneration(rawRecord) : rawRecord;
-      this.writeMemory(stripMaterializedOutcomes(record));
+      this.writeMemory(stripDerivedRelations(stripMaterializedOutcomes(record)));
       if (typeof record.metadata.outcomeGeneration === "string") {
         try {
           materializedRows.push({
@@ -37586,7 +37966,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-xb7d31wq.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-9ebqj7mv.js");
     const { config: pmLoadedConfig } = _internals41.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -39810,9 +40190,9 @@ var _internals45 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-xb7d31wq.js"),
-      import("./curator-q017rjfk.js"),
-      import("./curator-llm-factory-m1ke17eq.js")
+      import("./schema-9ebqj7mv.js"),
+      import("./curator-p0dwpn2x.js"),
+      import("./curator-llm-factory-g65xmh8f.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -40821,7 +41201,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-fbtgyeft.js");
+    const { getScanStatus } = await import("./scan-cursor-wjad4yd7.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -40829,19 +41209,19 @@ async function computeCurationDiagnostics(directory, entries) {
   } catch {}
   let configMatch = null;
   try {
-    const { isLinked: isLinked2 } = await import("./knowledge-link-8knefv8x.js");
+    const { isLinked: isLinked2 } = await import("./knowledge-link-0byjmj0w.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-xb7d31wq.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-9ebqj7mv.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-9kp3cp5n.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-1wapt173.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-ej9xc0cd.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-ayq5kmnf.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -42182,7 +42562,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-1yn317qf.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-636h188h.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -43122,7 +43502,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-6jzfa547.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-hvbqyb4g.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -63033,7 +63413,7 @@ async function mergeStagedSqlite(destStoragePath, stagedPath) {
     return { merged: await countRowsSafe(destDbPath), skipped: 0 };
   }
   try {
-    const { loadDatabaseCtor: loadDatabaseCtor2 } = await import("./sqlite-loader-r1kgt2pq.js");
+    const { loadDatabaseCtor: loadDatabaseCtor2 } = await import("./sqlite-loader-c92413n7.js");
     const Db = loadDatabaseCtor2();
     const db = new Db(destDbPath);
     let attached = false;
@@ -63130,7 +63510,7 @@ async function mergeStagedSqlite(destStoragePath, stagedPath) {
 }
 async function countRowsSafe(dbPath) {
   try {
-    const { loadDatabaseCtor: loadDatabaseCtor2 } = await import("./sqlite-loader-r1kgt2pq.js");
+    const { loadDatabaseCtor: loadDatabaseCtor2 } = await import("./sqlite-loader-c92413n7.js");
     const Db = loadDatabaseCtor2();
     const db = new Db(dbPath);
     try {
@@ -78481,7 +78861,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-fzgkd6m1.js");
+      const { createModelEvaluationExecutor: createModelEvaluationExecutor2 } = await import("./runner-rddddxmq.js");
       const executor = createModelEvaluationExecutor2(input.dispatcher, input.sessionId);
       const result = await withProtectedSetIntegrity([evalInputRoot, ...protectedRoots(input.directory)], () => _internals98.evaluateCandidateV1({
         projectRoot: input.directory,
@@ -80606,7 +80986,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-e0re84cx.js");
+    const { buildHelpText } = await import("./index-25xvw7hq.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -80615,7 +80995,7 @@ async function handleHelpCommand(ctx) {
     return _internals101.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals101.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-e0re84cx.js");
+  const { buildHelpText: fullHelp } = await import("./index-25xvw7hq.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -80946,7 +81326,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-xw3ma90f.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-s0dzn8c6.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -80956,7 +81336,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-z9fkxksy.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-cxkf5h0x.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -80965,7 +81345,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-xw3ma90f.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-s0dzn8c6.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -80975,7 +81355,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-z9fkxksy.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-cxkf5h0x.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -80985,7 +81365,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-etmzhbge.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-qc7rfhv2.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -86981,7 +87361,7 @@ function getDisplayFinalPromptPressure() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-3zwthnan.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-4e64sbwg.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -87427,7 +87807,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-jfam09nj.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-g5n5xbqy.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function runRecoveryGit(directory, args, timeoutMs = 15000) {
@@ -87836,7 +88216,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, handle.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-k687jrr3.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-h3hsczyq.js");
       await writeLaneProfileToDiskReal(handle.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -88761,7 +89141,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-k687jrr3.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-h3hsczyq.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);