opencode-swarm 7.103.2 → 7.104.0

package/dist/cli/{index-3ahcme4e.js → index-n3ys2eny.js}

@@ -57,7 +57,7 @@ import {
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-h0h4qjmc.js";
+} from "./index-5tywmqeh.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -70,7 +70,7 @@ import {
   TOOL_NAME_SET,
   resolveExternalSkillsConfig,
   stripKnownSwarmPrefix
-} from "./index-ga7et2xw.js";
+} from "./index-t1vfvtg9.js";
 import {
   MAX_TRANSIENT_RETRIES,
   PlanSchema,
@@ -912,7 +912,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.103.2",
+  version: "7.104.0",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -3589,7 +3589,7 @@ function classifySwarmCommandToolUse(resolved) {
       return { allowed: true };
     return {
       allowed: false,
-      message: "Use `/swarm memory status`, `/swarm memory pending`, `/swarm memory recall-log`, `/swarm memory stale`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import, migrate, and compact are intentionally excluded from chat-tool execution."
+      message: "Use `/swarm memory status`, `/swarm memory pending`, `/swarm memory recall-log`, `/swarm memory value-log`, `/swarm memory stale`, `/swarm memory export`, or `/swarm memory evaluate --json` through swarm_command. Memory import, migrate, and compact are intentionally excluded from chat-tool execution."
     };
   }
   if (canonicalKey === "memory evaluate") {
@@ -3625,7 +3625,7 @@ function classifySwarmCommandToolUse(resolved) {
       message: "Usage through swarm_command: `/swarm sdd validate`, `/swarm sdd validate --json`, or `/swarm sdd validate --change <id>`."
     };
   }
-  if (canonicalKey === "memory pending" || canonicalKey === "memory recall-log" || canonicalKey === "memory stale") {
+  if (canonicalKey === "memory pending" || canonicalKey === "memory recall-log" || canonicalKey === "memory value-log" || canonicalKey === "memory stale") {
     if (args.length === 0)
       return { allowed: true };
     if (args.length === 2 && args[0] === "--limit" && /^\d+$/.test(args[1])) {
@@ -13377,7 +13377,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-az0hgfv0.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-yxkdx5g5.js");
     const { config: pmLoadedConfig } = _internals20.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -17203,7 +17203,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-4rxjsg22.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-5m8z8jeg.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
@@ -20605,6 +20605,17 @@ var DEFAULT_CONSOLIDATION_CONFIG = {
   autoApplyMinConfidence: 0.6,
   decayHalfLifeDays: { ...DEFAULT_DECAY_HALF_LIFE_DAYS }
 };
+var DEFAULT_MEMORY_LEARNING_CONFIG = {
+  learningRate: 0.1,
+  propagationFactor: 0.3,
+  qValueBoostWeight: 0.1,
+  suppressionThreshold: 0.15,
+  promotionThreshold: 0.85,
+  propagationTokenOverlapThreshold: 0.4,
+  propagationEmbeddingCosineThreshold: 0.7,
+  propagationFanout: 20,
+  propagationLookbackDays: 30
+};
 var DEFAULT_EMBEDDINGS_CONFIG = {
   enabled: false,
   model: "Xenova/all-MiniLM-L6-v2",
@@ -20643,6 +20654,7 @@ var DEFAULT_MEMORY_CONFIG = {
       tokenBudget: 1000
     }
   },
+  learning: { ...DEFAULT_MEMORY_LEARNING_CONFIG },
   writes: {
     mode: "propose"
   },
@@ -20694,6 +20706,10 @@ function resolveMemoryConfig(input) {
         ...input?.recall?.injection ?? {}
       }
     },
+    learning: {
+      ...DEFAULT_MEMORY_CONFIG.learning,
+      ...input?.learning ?? {}
+    },
     writes: {
       ...DEFAULT_MEMORY_CONFIG.writes,
       ...input?.writes ?? {}
@@ -20887,6 +20903,7 @@ var MemoryRecordSchema = exports_external.object({
   updatedAt: exports_external.string().datetime(),
   lastAccessedAt: exports_external.string().datetime().optional(),
   expiresAt: exports_external.string().datetime().optional(),
+  qValue: exports_external.number().min(0).max(1).optional(),
   supersedes: exports_external.array(exports_external.string()).optional(),
   supersededBy: exports_external.string().optional(),
   contentHash: exports_external.string().regex(/^[a-f0-9]{64}$/),
@@ -21242,6 +21259,7 @@ var SCORING_WEIGHTS = {
   roleBoost: 0.05,
   confidence: 0.08
 };
+var DEFAULT_MEMORY_Q_VALUE = 0.5;
 function tokenize(text) {
   return new Set(text.toLowerCase().replace(/[^\w\s-]/g, " ").split(/\s+/).map((token) => token.trim()).filter(Boolean));
 }
@@ -21320,6 +21338,11 @@ function scoreMemoryRecordDetailed(record, request, context) {
   if (record.metadata.deleted === true) {
     return { item: null, skipReason: "filtered" };
   }
+  const qValue = memoryQValue(record);
+  const suppressionThreshold = request.suppressionThreshold ?? 0;
+  if (request.includeLowQ !== true && suppressionThreshold > 0 && qValue < suppressionThreshold) {
+    return { item: null, skipReason: "filtered" };
+  }
   if (!scopeAllowed(record.scope, request.scopes)) {
     return { item: null, skipReason: "filtered" };
   }
@@ -21355,7 +21378,7 @@ function scoreMemoryRecordDetailed(record, request, context) {
   if (request.mode === "injection" && request.requireQuerySignal !== false && !hasQuerySignal) {
     return { item: null, skipReason: "no_signal" };
   }
-  const score = textOverlap * SCORING_WEIGHTS.textOverlap + tagOverlap * SCORING_WEIGHTS.tagOverlap + fileOverlap * SCORING_WEIGHTS.fileOverlap + symbolOverlap * SCORING_WEIGHTS.symbolOverlap + taskTermOverlap * SCORING_WEIGHTS.taskTermOverlap + scopeSpecificityBoost(record.scope) * SCORING_WEIGHTS.scopeSpecificityBoost + kindProfileBoost(record.kind, request) * SCORING_WEIGHTS.kindProfileBoost + roleBoost * SCORING_WEIGHTS.roleBoost + record.confidence * SCORING_WEIGHTS.confidence;
+  const score = textOverlap * SCORING_WEIGHTS.textOverlap + tagOverlap * SCORING_WEIGHTS.tagOverlap + fileOverlap * SCORING_WEIGHTS.fileOverlap + symbolOverlap * SCORING_WEIGHTS.symbolOverlap + taskTermOverlap * SCORING_WEIGHTS.taskTermOverlap + scopeSpecificityBoost(record.scope) * SCORING_WEIGHTS.scopeSpecificityBoost + kindProfileBoost(record.kind, request) * SCORING_WEIGHTS.kindProfileBoost + roleBoost * SCORING_WEIGHTS.roleBoost + record.confidence * SCORING_WEIGHTS.confidence + (qValue - DEFAULT_MEMORY_Q_VALUE) * (request.qValueBoostWeight ?? 0);
   const reasonParts = [
     textOverlap > 0 ? `text_overlap=${textOverlap.toFixed(2)}` : null,
     tagOverlap > 0 ? `tag_overlap=${tagOverlap.toFixed(2)}` : null,
@@ -21364,6 +21387,7 @@ function scoreMemoryRecordDetailed(record, request, context) {
     taskTermOverlap > 0 ? `task_terms=${taskTermOverlap.toFixed(2)}` : null,
     kindQueryOverlap > 0 ? `kind_query=${kindQueryOverlap.toFixed(2)}` : null,
     roleBoost > 0 ? "role_profile" : null,
+    request.qValueBoostWeight && request.qValueBoostWeight > 0 ? `q_value=${qValue.toFixed(2)}` : null,
     `scope=${record.scope.type}`,
     `confidence=${record.confidence.toFixed(2)}`
   ].filter(Boolean);
@@ -21377,12 +21401,26 @@ function scoreMemoryRecordDetailed(record, request, context) {
         tagOverlap,
         fileOverlap,
         symbolOverlap,
+        qValue,
         kindMatch,
         scopeMatch
       }
     }
   };
 }
+function memoryQValue(record) {
+  if (typeof record.qValue === "number" && Number.isFinite(record.qValue)) {
+    return clamp01(record.qValue);
+  }
+  const metadataValue = record.metadata.qValue;
+  if (typeof metadataValue === "number" && Number.isFinite(metadataValue)) {
+    return clamp01(metadataValue);
+  }
+  return DEFAULT_MEMORY_Q_VALUE;
+}
+function clamp01(value) {
+  return Math.min(1, Math.max(0, value));
+}
 function scoreMemoryRecordsWithDiagnostics(records, request) {
   const minScore = request.minScore ?? 0;
   const context = createScoringContext(request);
@@ -21453,6 +21491,14 @@ async function buildMemoryMaintenanceReport(provider, options = {}) {
   });
   const proposals = await loadMaintenanceProposals(provider, limit);
   const recallUsage = provider.listRecallUsage ? await provider.listRecallUsage() : [];
+  const suppressionValueLog = provider.listMemoryValueLog ? await provider.listMemoryValueLog({
+    includeSuppressionCandidatesOnly: true,
+    limit
+  }) : [];
+  const promotionValueLog = provider.listMemoryValueLog ? await provider.listMemoryValueLog({
+    includePromotionCandidatesOnly: true,
+    limit
+  }) : [];
   const usageByMemory = summarizeRecallByMemory(recallUsage);
   const usageByRole = summarizeRecallByRole(recallUsage);
   const activeMemories = memories.filter((memory) => isActiveMemory(memory, now));
@@ -21475,6 +21521,8 @@ async function buildMemoryMaintenanceReport(provider, options = {}) {
     supersededMemories: supersededMemories.slice(0, limit),
     supersededChains: buildSupersededChains(memories).slice(0, limit),
     lowUtilityMemories: lowUtilityMemories.slice(0, limit),
+    lowQValueMemories: suppressionValueLog.slice(0, limit),
+    promotionCandidates: promotionValueLog.slice(0, limit),
     neverRecalledMemories: neverRecalledMemories.slice(0, limit),
     mostRecalledMemories: Array.from(usageByMemory.values()).sort((a, b) => b.count - a.count || b.lastRecalledAt.localeCompare(a.lastRecalledAt) || a.memoryId.localeCompare(b.memoryId)).slice(0, limit),
     recallByAgentRole: Array.from(usageByRole.values()).sort((a, b) => b.count - a.count || a.agentRole.localeCompare(b.agentRole)).slice(0, limit),
@@ -22740,6 +22788,23 @@ var MIGRATIONS2 = [
 				value TEXT
 			);
 		`
+  },
+  {
+    version: 7,
+    name: "add_recall_learning_columns",
+    sql: `
+			ALTER TABLE memory_recall_usage ADD COLUMN q_value REAL DEFAULT 0.5;
+			ALTER TABLE memory_recall_usage ADD COLUMN last_reward REAL;
+			ALTER TABLE memory_recall_usage ADD COLUMN task_outcome TEXT;
+			ALTER TABLE memory_recall_usage ADD COLUMN council_verdict_json TEXT;
+		`
+  },
+  {
+    version: 8,
+    name: "add_recall_reward_idempotency_key",
+    sql: `
+			ALTER TABLE memory_recall_usage ADD COLUMN reward_key TEXT;
+		`
   }
 ];
 
@@ -22760,36 +22825,15 @@ class SQLiteMemoryProvider {
   lastAutomaticJsonlMigration = null;
   recallCountSinceLastCompaction = 0;
   isCompacting = false;
+  _internals = {
+    writeMemory: (record) => this.writeMemory(record),
+    setEmbeddingProvider: (provider) => {
+      this.embeddingProvider = provider;
+    }
+  };
   constructor(rootDirectory, config = {}) {
     this.rootDirectory = rootDirectory;
-    this.config = {
-      ...DEFAULT_MEMORY_CONFIG,
-      ...config,
-      sqlite: {
-        ...DEFAULT_MEMORY_CONFIG.sqlite,
-        ...config.sqlite ?? {}
-      },
-      recall: {
-        ...DEFAULT_MEMORY_CONFIG.recall,
-        ...config.recall ?? {},
-        injection: {
-          ...DEFAULT_MEMORY_CONFIG.recall.injection,
-          ...config.recall?.injection ?? {}
-        }
-      },
-      writes: {
-        ...DEFAULT_MEMORY_CONFIG.writes,
-        ...config.writes ?? {}
-      },
-      redaction: {
-        ...DEFAULT_MEMORY_CONFIG.redaction,
-        ...config.redaction ?? {}
-      },
-      maintenance: {
-        ...DEFAULT_MEMORY_CONFIG.maintenance,
-        ...config.maintenance ?? {}
-      }
-    };
+    this.config = resolveMemoryConfig(config);
   }
   databasePath() {
     const relativePath = this.config.sqlite.path.replace(/^\.swarm[/\\]?/, "");
@@ -23040,12 +23084,25 @@ class SQLiteMemoryProvider {
   }
   async recordRecallUsage(event) {
     await this.initialize();
+    const recalledRecords = event.memoryIds.map((id) => this.memories.get(id)).filter(isMemoryRecord);
+    const qValue = typeof event.qValue === "number" && Number.isFinite(event.qValue) ? clamp012(event.qValue) : averageMemoryQValue(recalledRecords);
+    const eventWithQValue = {
+      ...event,
+      qValue
+    };
     this.requireDb().run(`INSERT INTO memory_recall_usage (
 				id,
 				bundle_id,
 				timestamp,
-				usage_json
-			) VALUES (?, ?, ?, ?)`, [randomUUID6(), event.bundleId, event.timestamp, JSON.stringify(event)]);
+				usage_json,
+				q_value
+			) VALUES (?, ?, ?, ?, ?)`, [
+      randomUUID6(),
+      event.bundleId,
+      event.timestamp,
+      JSON.stringify(eventWithQValue),
+      qValue
+    ]);
     this.recallCountSinceLastCompaction++;
     const threshold = this.config.maintenance?.autoCompactEveryNRecalls ?? 50;
     if (threshold > 0 && this.recallCountSinceLastCompaction >= threshold && !this.isCompacting) {
@@ -23072,24 +23129,163 @@ class SQLiteMemoryProvider {
   }
   async listRecallUsage(filter = {}) {
     await this.initialize();
-    const rows = typeof filter.limit === "number" ? this.requireDb().query(`SELECT usage_json
+    const rows = typeof filter.limit === "number" ? this.requireDb().query(`SELECT id, usage_json, q_value, last_reward, task_outcome, council_verdict_json, reward_key
 				FROM memory_recall_usage
 				ORDER BY timestamp DESC
-				LIMIT ?`).all(Math.max(1, Math.trunc(filter.limit))) : this.requireDb().query(`SELECT usage_json
+				LIMIT ?`).all(Math.max(1, Math.trunc(filter.limit))) : this.requireDb().query(`SELECT id, usage_json, q_value, last_reward, task_outcome, council_verdict_json, reward_key
 				FROM memory_recall_usage
 				ORDER BY timestamp DESC
 				`).all();
     const events = [];
     for (const row of rows) {
-      try {
-        const parsed = JSON.parse(row.usage_json);
-        if (Array.isArray(parsed.memoryIds) && typeof parsed.query === "string") {
-          events.push(parsed);
-        }
-      } catch {}
+      const parsed = parseRecallUsageRow(row);
+      if (parsed)
+        events.push(parsed);
     }
     return events;
   }
+  async applyRecallReward(input) {
+    await this.initialize();
+    const matches = this.matchingRecallUsageRows(input.runIds);
+    if (matches.length === 0) {
+      return emptyRewardResult(input.outcome, "no_recall_usage_for_run");
+    }
+    const rewardKey = deriveRewardKey(input.verdictPayload);
+    const pending = rewardKey === null ? matches : matches.filter((match) => match.rewardKey !== rewardKey);
+    if (pending.length === 0) {
+      const first = matches[0];
+      return {
+        success: true,
+        bundleId: first?.event.bundleId,
+        bundleIds: matches.map((match) => match.event.bundleId),
+        outcome: input.outcome,
+        memoryIds: uniqueStrings(matches.flatMap((match) => match.event.memoryIds)),
+        reward: rewardForOutcome(input.outcome),
+        updatedMemoryIds: [],
+        propagatedMemoryIds: [],
+        qValue: first?.event.qValue,
+        reason: "already_rewarded"
+      };
+    }
+    const reward = rewardForOutcome(input.outcome);
+    const updatedAt = input.timestamp ?? new Date().toISOString();
+    const sourceIds = uniqueStrings(pending.flatMap((match) => match.event.memoryIds));
+    const directUpdates = new Map;
+    const propagatedUpdates = new Map;
+    for (const memoryId of sourceIds) {
+      const nextQValue = this.updateMemoryQValue(memoryId, reward, updatedAt);
+      if (nextQValue !== null) {
+        directUpdates.set(memoryId, nextQValue);
+      }
+    }
+    const promotionThreshold = this.config.learning.promotionThreshold;
+    const promotionRecallThreshold = 5;
+    const usageSummary = summarizeRecallUsage(this.listRecallUsageSync());
+    for (const [memoryId, nextQValue] of directUpdates) {
+      const memory = this.memories.get(memoryId);
+      const recallCount = usageSummary.get(memoryId)?.count ?? 0;
+      if (memory && memory.stability === "session" && nextQValue > promotionThreshold && recallCount > promotionRecallThreshold) {
+        memory.stability = "durable";
+        this._internals.writeMemory(memory);
+      }
+    }
+    const propagationTargets = await this.findPropagationTargets(sourceIds);
+    const db = this.requireDb();
+    const verdictJson = truncateJsonPayload(input.verdictPayload);
+    const result = db.transaction(() => {
+      for (const targetId of propagationTargets) {
+        const propagatedSignal = propagatedRewardSignal(reward, this.config.learning.propagationFactor);
+        const nextQValue = this.updateMemoryQValue(targetId, propagatedSignal, updatedAt);
+        if (nextQValue !== null) {
+          propagatedUpdates.set(targetId, nextQValue);
+        }
+      }
+      const updatedMemoryIds = [...directUpdates.keys()];
+      const propagatedMemoryIds = [...propagatedUpdates.keys()];
+      const combinedQValues = [
+        ...directUpdates.values(),
+        ...propagatedUpdates.values()
+      ];
+      const qValue = combinedQValues.length > 0 ? averageNumbers(combinedQValues) : pending[0]?.event.qValue;
+      for (const match of pending) {
+        const updatedEvent = {
+          ...match.event,
+          qValue,
+          lastReward: reward,
+          taskOutcome: input.outcome
+        };
+        db.run(`UPDATE memory_recall_usage
+					SET usage_json = ?,
+						q_value = ?,
+						last_reward = ?,
+						task_outcome = ?,
+						council_verdict_json = ?,
+						reward_key = ?
+					WHERE id = ?`, [
+          JSON.stringify(updatedEvent),
+          qValue ?? null,
+          reward,
+          input.outcome,
+          verdictJson,
+          rewardKey,
+          match.id
+        ]);
+      }
+      return {
+        updatedMemoryIds,
+        propagatedMemoryIds,
+        qValue
+      };
+    })();
+    for (const match of pending) {
+      await this.event("recall", match.event.bundleId, `applied ${input.outcome} recall reward`);
+    }
+    return {
+      success: true,
+      bundleId: pending[0]?.event.bundleId,
+      bundleIds: pending.map((match) => match.event.bundleId),
+      outcome: input.outcome,
+      memoryIds: sourceIds,
+      reward,
+      updatedMemoryIds: result.updatedMemoryIds,
+      propagatedMemoryIds: result.propagatedMemoryIds,
+      qValue: result.qValue
+    };
+  }
+  async listMemoryValueLog(filter = {}) {
+    await this.initialize();
+    const usageSummary = summarizeRecallUsage(this.listRecallUsageSync());
+    const threshold = this.config.learning.suppressionThreshold;
+    const promotionThreshold = this.config.learning.promotionThreshold;
+    const entries = Array.from(this.memories.values()).map((record) => {
+      const recall = usageSummary.get(record.id);
+      const qValue = memoryQValue(record);
+      const recallCount = recall?.count ?? 0;
+      return {
+        memoryId: record.id,
+        kind: record.kind,
+        scopeKey: stableScopeKey(record.scope),
+        textPreview: truncateText(record.text, 120),
+        qValue,
+        recallCount,
+        lastRecalledAt: recall?.lastRecalledAt,
+        lastReward: recall?.lastReward,
+        taskOutcome: recall?.taskOutcome,
+        promotionCandidate: qValue > promotionThreshold && recallCount > 5,
+        suppressionCandidate: qValue < threshold
+      };
+    });
+    const filtered = entries.filter((entry) => {
+      if (filter.includePromotionCandidatesOnly) {
+        return entry.promotionCandidate;
+      }
+      if (filter.includeSuppressionCandidatesOnly) {
+        return entry.suppressionCandidate;
+      }
+      return true;
+    }).sort((a, b) => (b.lastRecalledAt ?? "").localeCompare(a.lastRecalledAt ?? "") || b.qValue - a.qValue || a.memoryId.localeCompare(b.memoryId));
+    return filtered.slice(0, Math.max(1, Math.trunc(filter.limit ?? 20)));
+  }
   async list(filter = {}) {
     await this.initialize();
     const db = this.requireDb();
@@ -23314,6 +23510,145 @@ class SQLiteMemoryProvider {
     this.memories = new Map(kept.map((memory) => [memory.id, memory]));
     return result;
   }
+  matchingRecallUsageRows(runIds) {
+    const idSet = new Set(runIds.filter((id) => id.length > 0));
+    if (idSet.size === 0)
+      return [];
+    const rows = this.requireDb().query(`SELECT id, usage_json, q_value, last_reward, task_outcome, council_verdict_json, reward_key
+				FROM memory_recall_usage
+				ORDER BY timestamp DESC
+				LIMIT ?`).all(100);
+    const matches = [];
+    const seenRunIds = new Set;
+    for (const row of rows) {
+      if (!row.id)
+        continue;
+      const event = parseRecallUsageRow(row);
+      if (!event?.runId || !idSet.has(event.runId))
+        continue;
+      if (seenRunIds.has(event.runId))
+        continue;
+      seenRunIds.add(event.runId);
+      matches.push({ id: row.id, event, rewardKey: row.reward_key ?? null });
+    }
+    return matches;
+  }
+  updateMemoryQValue(memoryId, rewardSignal, updatedAt) {
+    const current = this.memories.get(memoryId);
+    if (!current)
+      return null;
+    if (current.metadata.deleted === true || current.supersededBy)
+      return null;
+    const eta = this.config.learning.learningRate;
+    const nextQValue = clamp012((1 - eta) * memoryQValue(current) + eta * rewardSignal);
+    const next = {
+      ...current,
+      updatedAt,
+      qValue: nextQValue
+    };
+    this.memories.set(memoryId, next);
+    this.writeMemory(next);
+    return nextQValue;
+  }
+  async findPropagationTargets(sourceMemoryIds) {
+    const lookbackIds = this.recentlyRecalledMemoryIds(this.config.learning.propagationLookbackDays);
+    if (lookbackIds.size === 0)
+      return [];
+    const sourceRecords = sourceMemoryIds.map((id) => this.memories.get(id)).filter(isMemoryRecord);
+    if (sourceRecords.length === 0)
+      return [];
+    const targets = [];
+    const sourceTokenSets = sourceRecords.map((record) => tokenizeText(record.text));
+    const cosineEnabled = this.config.embeddings.enabled && Boolean(this.embeddingProvider);
+    const cosineThreshold = this.config.learning.propagationEmbeddingCosineThreshold;
+    const sourceVectors = cosineEnabled ? await Promise.all(sourceRecords.map((record) => this.getCachedEmbeddingForPropagation(record.text))) : [];
+    for (const candidate of this.memories.values()) {
+      if (sourceMemoryIds.includes(candidate.id))
+        continue;
+      if (!lookbackIds.has(candidate.id))
+        continue;
+      if (candidate.metadata.deleted === true || candidate.supersededBy)
+        continue;
+      const candidateTokens = tokenizeText(candidate.text);
+      let bestOverlap = 0;
+      let sameScopeAsAnySource = false;
+      const sameScopeBySourceIndex = [];
+      for (let i = 0;i < sourceRecords.length; i++) {
+        const source = sourceRecords[i];
+        const sameScope2 = stableScopeKey(candidate.scope) === stableScopeKey(source.scope);
+        sameScopeBySourceIndex[i] = sameScope2;
+        if (sameScope2)
+          sameScopeAsAnySource = true;
+        if (!sameScope2 || candidate.kind !== source.kind)
+          continue;
+        bestOverlap = Math.max(bestOverlap, jaccard(sourceTokenSets[i] ?? new Set, candidateTokens));
+      }
+      let bestCosine = 0;
+      if (cosineEnabled && sameScopeAsAnySource) {
+        const candidateVector = await this.getCachedEmbeddingForPropagation(candidate.text);
+        if (candidateVector) {
+          for (let i = 0;i < sourceVectors.length; i++) {
+            if (!sameScopeBySourceIndex[i])
+              continue;
+            const sourceVector = sourceVectors[i];
+            if (!sourceVector)
+              continue;
+            bestCosine = Math.max(bestCosine, cosineSimilarity(sourceVector, candidateVector));
+          }
+        }
+      }
+      const qualifiesByOverlap = bestOverlap >= this.config.learning.propagationTokenOverlapThreshold;
+      const qualifiesByCosine = cosineEnabled && bestCosine >= cosineThreshold;
+      if (qualifiesByOverlap || qualifiesByCosine) {
+        targets.push({
+          id: candidate.id,
+          overlap: Math.max(bestOverlap, bestCosine)
+        });
+      }
+    }
+    return targets.sort((a, b) => b.overlap - a.overlap || a.id.localeCompare(b.id)).slice(0, this.config.learning.propagationFanout).map((target) => target.id);
+  }
+  async getCachedEmbeddingForPropagation(text) {
+    if (!this.embeddingProvider)
+      return null;
+    const modelVersion = this.embeddingProvider.modelVersion;
+    const normalized = normalizeMemoryText(text).toLowerCase();
+    if (!normalized)
+      return null;
+    const cached = this.embeddingCache?.get(modelVersion, normalized)?.vector;
+    if (cached)
+      return cached;
+    try {
+      const vector = await this.embeddingProvider.embed(normalized);
+      this.embeddingCache?.set(modelVersion, normalized, {
+        vector,
+        modelVersion,
+        queryHash: normalized
+      });
+      return vector;
+    } catch {
+      return null;
+    }
+  }
+  recentlyRecalledMemoryIds(lookbackDays) {
+    const cutoffMs = Date.now() - Math.max(0, lookbackDays) * 24 * 60 * 60 * 1000;
+    const memoryIds = new Set;
+    for (const event of this.listRecallUsageSync(500)) {
+      const timestamp = Date.parse(event.timestamp);
+      if (Number.isFinite(timestamp) && timestamp < cutoffMs)
+        continue;
+      for (const memoryId of event.memoryIds)
+        memoryIds.add(memoryId);
+    }
+    return memoryIds;
+  }
+  listRecallUsageSync(limit = 1000) {
+    const rows = this.requireDb().query(`SELECT id, usage_json, q_value, last_reward, task_outcome, council_verdict_json, reward_key
+				FROM memory_recall_usage
+				ORDER BY timestamp DESC
+				LIMIT ?`).all(Math.max(1, Math.trunc(limit)));
+    return rows.map((row) => parseRecallUsageRow(row)).filter(isRecallUsageEvent);
+  }
   hasMigration(name) {
     const row = this.requireDb().query("SELECT version, name FROM schema_migrations WHERE name = ? LIMIT 1").get(name);
     return Boolean(row);
@@ -23413,7 +23748,13 @@ class SQLiteMemoryProvider {
         continue;
       const apply = db.transaction(() => {
         for (const statement of splitSql(migration.sql)) {
-          db.run(statement);
+          try {
+            db.run(statement);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!/duplicate column name/i.test(message))
+              throw err;
+          }
         }
         db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
           migration.version,
@@ -23845,6 +24186,178 @@ class SQLiteMemoryProvider {
     return this.db;
   }
 }
+function averageMemoryQValue(records) {
+  if (records.length === 0)
+    return DEFAULT_MEMORY_Q_VALUE;
+  return averageNumbers(records.map((record) => memoryQValue(record)));
+}
+function averageNumbers(values) {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0)
+    return DEFAULT_MEMORY_Q_VALUE;
+  return finite.reduce((sum, value) => sum + value, 0) / finite.length;
+}
+function isMemoryRecord(record) {
+  return record !== undefined;
+}
+function isRecallUsageEvent(event) {
+  return event !== null;
+}
+function rewardForOutcome(outcome) {
+  switch (outcome) {
+    case "approved":
+      return 1;
+    case "rejected":
+      return -1;
+    case "concerns":
+    case "unknown":
+      return 0;
+  }
+}
+function propagatedRewardSignal(reward, propagationFactor) {
+  const factor = Math.max(0, Math.min(1, propagationFactor));
+  return DEFAULT_MEMORY_Q_VALUE + factor * (reward - DEFAULT_MEMORY_Q_VALUE);
+}
+function emptyRewardResult(outcome, reason) {
+  return {
+    success: false,
+    outcome,
+    memoryIds: [],
+    reward: rewardForOutcome(outcome),
+    updatedMemoryIds: [],
+    propagatedMemoryIds: [],
+    reason
+  };
+}
+function parseRecallUsageRow(row) {
+  try {
+    const parsed = JSON.parse(row.usage_json);
+    if (!Array.isArray(parsed.memoryIds) || typeof parsed.query !== "string") {
+      return null;
+    }
+    const event = { ...parsed };
+    if (typeof row.q_value === "number" && Number.isFinite(row.q_value)) {
+      event.qValue = clamp012(row.q_value);
+    }
+    if (typeof row.last_reward === "number" && Number.isFinite(row.last_reward)) {
+      event.lastReward = row.last_reward;
+    }
+    const taskOutcome = normalizeTaskOutcome(row.task_outcome);
+    if (taskOutcome)
+      event.taskOutcome = taskOutcome;
+    return event;
+  } catch {
+    return null;
+  }
+}
+function normalizeTaskOutcome(value) {
+  if (value === "approved" || value === "rejected" || value === "concerns" || value === "unknown") {
+    return value;
+  }
+  return;
+}
+function truncateJsonPayload(value) {
+  if (value === undefined)
+    return null;
+  let json;
+  try {
+    json = JSON.stringify(value);
+  } catch (err) {
+    return JSON.stringify({
+      unserializable: true,
+      reason: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const maxLength = 8192;
+  if (json.length <= maxLength)
+    return json;
+  return JSON.stringify({
+    truncated: true,
+    preview: json.slice(0, maxLength - 32)
+  });
+}
+function deriveRewardKey(verdictPayload) {
+  if (!verdictPayload || typeof verdictPayload !== "object")
+    return null;
+  const payload = verdictPayload;
+  const swarmId = payload.swarmId;
+  const roundNumber = payload.roundNumber;
+  const unit = payload.taskId ?? payload.phaseNumber;
+  const unitOk = typeof unit === "string" || typeof unit === "number";
+  const roundOk = typeof roundNumber === "string" || typeof roundNumber === "number";
+  if (typeof swarmId !== "string" || swarmId.length === 0 || !unitOk || !roundOk) {
+    return null;
+  }
+  return `${swarmId}:${unit}:${roundNumber}`;
+}
+function summarizeRecallUsage(events) {
+  const summary = new Map;
+  for (const event of events) {
+    for (const memoryId of event.memoryIds) {
+      const existing = summary.get(memoryId) ?? {
+        count: 0,
+        lastRecalledAt: event.timestamp
+      };
+      existing.count++;
+      if (event.timestamp >= existing.lastRecalledAt) {
+        existing.lastRecalledAt = event.timestamp;
+        existing.lastReward = event.lastReward;
+        existing.taskOutcome = event.taskOutcome;
+      }
+      summary.set(memoryId, existing);
+    }
+  }
+  return summary;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.filter((value) => value.length > 0)));
+}
+function truncateText(value, maxLength) {
+  if (value.length <= maxLength)
+    return value;
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+function tokenizeText(value) {
+  const tokens = new Set;
+  for (const match of value.toLowerCase().matchAll(/[a-z0-9_]{3,}/g)) {
+    const token = match[0];
+    if (!FTS_STOP_WORDS.has(token))
+      tokens.add(token);
+  }
+  return tokens;
+}
+function jaccard(left, right) {
+  if (left.size === 0 || right.size === 0)
+    return 0;
+  let intersection = 0;
+  for (const token of left) {
+    if (right.has(token))
+      intersection++;
+  }
+  const union = left.size + right.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || a.length !== b.length)
+    return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0;i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  if (normA === 0 || normB === 0)
+    return 0;
+  const similarity = dot / (Math.sqrt(normA) * Math.sqrt(normB));
+  return Number.isFinite(similarity) ? similarity : 0;
+}
+function clamp012(value) {
+  if (!Number.isFinite(value))
+    return DEFAULT_MEMORY_Q_VALUE;
+  return Math.min(1, Math.max(0, value));
+}
 function splitSql(sql) {
   const statements = [];
   let current = "";
@@ -24154,6 +24667,21 @@ function resolvePoolKey(directory) {
     return path47.resolve(directory);
   }
 }
+function evictAndClose(directory) {
+  const key = resolvePoolKey(directory);
+  const active = entriesByKey.get(key);
+  if (active) {
+    entriesByKey.delete(key);
+    unlinkEntry(active);
+    callRealClose(active.provider);
+  }
+  for (const deferred of [...deferredEntries]) {
+    if (deferred.key === key) {
+      deferredEntries.delete(deferred);
+      callRealClose(deferred.provider);
+    }
+  }
+}
 
 // src/memory/gateway.ts
 function createConfiguredMemoryProvider(directory, config) {
@@ -24256,7 +24784,8 @@ async function evaluateMemoryRecallFixtures(options) {
       } finally {
         await provider.close?.();
         if (!options.keepTempRoots) {
-          await fs19.rm(tempRoot, { recursive: true, force: true });
+          evictAndClose(tempRoot);
+          await rmTempRoot(tempRoot);
         }
       }
     }
@@ -24271,6 +24800,18 @@ async function evaluateMemoryRecallFixtures(options) {
     runs
   };
 }
+async function rmTempRoot(tempRoot) {
+  for (let attempt = 0;attempt < 10; attempt++) {
+    try {
+      await fs19.rm(tempRoot, { recursive: true, force: true });
+      return;
+    } catch (err) {
+      if (attempt === 9)
+        throw err;
+      await new Promise((resolve13) => setTimeout(resolve13, 50));
+    }
+  }
+}
 async function loadRecallEvaluationFixtures(fixtureDirectory) {
   const entries = await fs19.readdir(fixtureDirectory, { withFileTypes: true });
   const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
@@ -24585,6 +25126,7 @@ async function handleMemoryCommand(_directory, _args) {
     "- `/swarm memory status` - show provider, SQLite path, JSONL files, and last migration report",
     "- `/swarm memory pending` - show pending proposals and recent rejection reasons",
     "- `/swarm memory recall-log` - summarize recall usage by agent role and memory ID",
+    "- `/swarm memory value-log` - show recent Q-value, reward, suppression, and promotion signals",
     "- `/swarm memory stale` - list expired scratch, superseded, deleted, and low-utility memories",
     "- `/swarm memory compact` - dry-run compaction; pass `--confirm` to remove deleted, superseded, and expired scratch records",
     "- `/swarm memory export` - export current memory and proposals to `.swarm/memory/export/*.jsonl`",
@@ -24679,10 +25221,12 @@ async function handleMemoryPendingCommand(directory, args) {
       "## Swarm Memory Pending",
       "",
       `- Pending proposals shown: \`${report.pendingProposals.length}\``,
-      `- Rejected proposal reasons shown: \`${report.rejectedProposalReasons.length}\``
+      `- Rejected proposal reasons shown: \`${report.rejectedProposalReasons.length}\``,
+      `- Promotion candidates shown: \`${report.promotionCandidates.length}\``
     ];
     appendProposalLines(lines, "Pending proposals", report.pendingProposals);
     appendProposalLines(lines, "Rejected proposal reasons", report.rejectedProposalReasons);
+    appendValueLogLines(lines, "Promotion candidates", report.promotionCandidates);
     return lines.join(`
 `);
   } finally {
@@ -24719,6 +25263,39 @@ async function handleMemoryRecallLogCommand(directory, args) {
     await provider.close?.();
   }
 }
+async function handleMemoryValueLogCommand(directory, args) {
+  const parsed = parseMaintenanceArgs(args, {
+    usage: "Usage: /swarm memory value-log [--limit <n>]",
+    allowConfirm: false
+  });
+  if ("error" in parsed)
+    return parsed.error;
+  const config = resolveCommandMemoryConfig(directory);
+  const provider = createMaintenanceProvider(directory, config);
+  try {
+    await provider.initialize?.();
+    if (!provider.listMemoryValueLog) {
+      return "Memory provider does not support value-log reporting.";
+    }
+    const valueLog = await provider.listMemoryValueLog({ limit: parsed.limit });
+    const promotionCandidates = valueLog.filter((entry) => entry.promotionCandidate);
+    const suppressionCandidates = valueLog.filter((entry) => entry.suppressionCandidate);
+    const lines = [
+      "## Swarm Memory Value Log",
+      "",
+      `- Entries shown: \`${valueLog.length}\``,
+      `- Promotion candidates shown: \`${promotionCandidates.length}\``,
+      `- Suppression candidates shown: \`${suppressionCandidates.length}\``
+    ];
+    appendValueLogLines(lines, "Recent Q-value updates", valueLog);
+    appendValueLogLines(lines, "Promotion candidates", promotionCandidates);
+    appendValueLogLines(lines, "Suppression candidates", suppressionCandidates);
+    return lines.join(`
+`);
+  } finally {
+    await provider.close?.();
+  }
+}
 async function handleMemoryStaleCommand(directory, args) {
   const parsed = parseMaintenanceArgs(args, {
     usage: "Usage: /swarm memory stale [--limit <n>]",
@@ -24740,12 +25317,14 @@ async function handleMemoryStaleCommand(directory, args) {
       `- Expired scratch memories shown: \`${report.expiredScratchMemories.length}\``,
       `- Deleted tombstones shown: \`${report.deletedMemories.length}\``,
       `- Superseded memories shown: \`${report.supersededMemories.length}\``,
-      `- Low-utility memories shown: \`${report.lowUtilityMemories.length}\``
+      `- Low-utility memories shown: \`${report.lowUtilityMemories.length}\``,
+      `- Low-Q memories shown: \`${report.lowQValueMemories.length}\``
     ];
     appendMemoryLines(lines, "Expired scratch memories", report.expiredScratchMemories);
     appendMemoryLines(lines, "Deleted tombstones", report.deletedMemories);
     appendSupersededChains(lines, report);
     appendMemoryLines(lines, "Low-utility memories", report.lowUtilityMemories);
+    appendValueLogLines(lines, "Low-Q memories", report.lowQValueMemories);
     return lines.join(`
 `);
   } finally {
@@ -25022,6 +25601,19 @@ function appendRecallMemoryLines(lines, memories) {
     lines.push(`- \`${memory.memoryId}\`: ${memory.count} hit(s), last=${memory.lastRecalledAt}, avgScore=${memory.averageScore.toFixed(3)}`);
   }
 }
+function appendValueLogLines(lines, title, entries) {
+  lines.push("", `### ${title}`);
+  if (entries.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  for (const entry of entries) {
+    const outcome = entry.taskOutcome ? ` outcome=${entry.taskOutcome}` : "";
+    const reward = typeof entry.lastReward === "number" ? ` reward=${entry.lastReward.toFixed(2)}` : "";
+    const last = entry.lastRecalledAt ? ` last=${entry.lastRecalledAt}` : "";
+    lines.push(`- \`${entry.memoryId}\` ${entry.kind} q=${entry.qValue.toFixed(3)} recalls=${entry.recallCount}${reward}${outcome}${last} - ${entry.textPreview}`);
+  }
+}
 function appendSupersededChains(lines, report) {
   lines.push("", "### Superseded chains");
   if (report.supersededChains.length === 0) {
@@ -33373,7 +33965,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-4fnw0ebs.js");
+    const { buildHelpText } = await import("./index-e7nhwa9k.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -33382,7 +33974,7 @@ async function handleHelpCommand(ctx) {
     return _internals47.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals47.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-4fnw0ebs.js");
+  const { buildHelpText: fullHelp } = await import("./index-e7nhwa9k.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -33515,7 +34107,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-4pnnjmyb.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-2zat1bxh.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -33525,7 +34117,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-vg0atkrx.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-zhshjbpk.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -34184,6 +34776,14 @@ Subcommands:
     category: "diagnostics",
     toolPolicy: "agent"
   },
+  "memory value-log": {
+    handler: (ctx) => handleMemoryValueLogCommand(ctx.directory, ctx.args),
+    description: "Show Swarm memory Q-value and reward updates",
+    subcommandOf: "memory",
+    args: "--limit <n>",
+    category: "diagnostics",
+    toolPolicy: "agent"
+  },
   "memory compact": {
     handler: (ctx) => handleMemoryCompactCommand(ctx.directory, ctx.args),
     description: "Compact deleted, superseded, and expired scratch memories",
@@ -34459,4 +35059,4 @@ ${text}`;
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals47 as _internals, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals47 as _internals, resolveCommand };