@remnic/core 9.3.728 → 9.3.730

package/dist/{chunk-HGNOCPZX.js → chunk-QZHF4BWN.js}

@@ -11,19 +11,19 @@ import {
   processChatMessage,
   sessionBelongsToPrincipal,
   subscribeChatTranscript
-} from "./chunk-BQCHEV7O.js";
+} from "./chunk-O4ZIBPIW.js";
 import {
   validateRequest
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-4ESAR77N.js";
+} from "./chunk-NOU77OHX.js";
 import {
   EngramAccessInputError
-} from "./chunk-UM5AWJNQ.js";
+} from "./chunk-646B5ERJ.js";
 import {
   CorrectionContractError
-} from "./chunk-AQLOP5F4.js";
+} from "./chunk-WNGXQMRI.js";
 import {
   isTrustZoneName
 } from "./chunk-JGSKJHF7.js";
@@ -1669,7 +1669,7 @@ var EngramAccessHttpServer = class {
         this.respondJson(res, 400, { error: "pairId and verb are required" });
         return;
       }
-      const { isValidResolutionVerb, executeResolution } = await import("./resolution-MN36NW5P.js");
+      const { isValidResolutionVerb, executeResolution } = await import("./resolution-33PIX3TT.js");
       if (!isValidResolutionVerb(verb)) {
         this.respondJson(res, 400, { error: `Invalid verb: ${verb}. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context` });
         return;
@@ -2629,4 +2629,4 @@ function positiveIntQueryParam(value, label) {
 export {
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-HGNOCPZX.js.map
+//# sourceMappingURL=chunk-QZHF4BWN.js.map

package/dist/chunk-SYX73XD7.js

@@ -0,0 +1,283 @@
+import {
+  computeCompressionGuidelineCandidate,
+  refineCompressionGuidelineCandidateSemantically,
+  renderCompressionGuidelinesMarkdown
+} from "./chunk-OD4FM2U7.js";
+import {
+  log
+} from "./chunk-NU3CSQ4H.js";
+
+// src/orchestration/compression-guideline-coordinator.ts
+import { createHash } from "crypto";
+var CompressionGuidelineCoordinator = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  get storage() {
+    return this.deps.getStorage();
+  }
+  get config() {
+    return this.deps.config;
+  }
+  async optimizeCompressionGuidelines(options) {
+    const dryRun = options?.dryRun === true;
+    const eventLimit = typeof options?.eventLimit === "number" ? Math.max(0, Math.floor(options.eventLimit)) : 500;
+    const [activeState, draftState] = await Promise.all([
+      this.storage.readCompressionGuidelineOptimizerState(),
+      this.storage.readCompressionGuidelineDraftState().catch(() => null)
+    ]);
+    const previousState = draftState && ((activeState?.guidelineVersion ?? 0) < draftState.guidelineVersion || (activeState?.guidelineVersion ?? 0) === draftState.guidelineVersion) ? draftState : activeState;
+    if (!this.config.compressionGuidelineLearningEnabled) {
+      return {
+        enabled: false,
+        dryRun,
+        eventCount: 0,
+        previousGuidelineVersion: previousState?.guidelineVersion ?? null,
+        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,
+        changedRules: 0,
+        semanticRefinementApplied: false,
+        persisted: false,
+        draftContentHash: null
+      };
+    }
+    let events = await this.storage.readMemoryActionEvents(eventLimit);
+    if (eventLimit > 0) {
+      let effectiveEvents = events.filter((event) => event.dryRun !== true);
+      let fetchLimit = eventLimit;
+      while (effectiveEvents.length < eventLimit && events.length === fetchLimit) {
+        fetchLimit = Math.min(fetchLimit * 2, fetchLimit + 1e3);
+        if (fetchLimit <= events.length) break;
+        events = await this.storage.readMemoryActionEvents(fetchLimit);
+        effectiveEvents = events.filter((event) => event.dryRun !== true);
+      }
+      events = effectiveEvents.slice(-eventLimit);
+    }
+    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const candidate = computeCompressionGuidelineCandidate(events, {
+      generatedAtIso: generatedAt,
+      previousState
+    });
+    if (candidate.eventCounts.total === 0) {
+      return {
+        enabled: true,
+        dryRun,
+        eventCount: 0,
+        previousGuidelineVersion: previousState?.guidelineVersion ?? null,
+        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,
+        changedRules: 0,
+        semanticRefinementApplied: false,
+        persisted: false,
+        draftContentHash: null
+      };
+    }
+    const refinedCandidate = await refineCompressionGuidelineCandidateSemantically(candidate, {
+      enabled: this.config.compressionGuidelineSemanticRefinementEnabled,
+      timeoutMs: this.config.compressionGuidelineSemanticTimeoutMs,
+      runRefinement: async (baseline) => {
+        const prompt = [
+          "You refine compression policy suggestions conservatively.",
+          "Return JSON only in this shape:",
+          '{"updates":[{"action":"summarize_node","delta":0.02,"confidence":"medium","note":"..."}]}',
+          "Constraints:",
+          "- Keep updates sparse and conservative.",
+          "- delta must stay between -0.15 and 0.15.",
+          "- Only include actions present in the input.",
+          "Input candidate:",
+          JSON.stringify(baseline)
+        ].join("\n");
+        const response = await this.deps.fastChatCompletion(
+          [
+            {
+              role: "system",
+              content: "Respond with strict JSON only. No markdown."
+            },
+            { role: "user", content: prompt }
+          ],
+          {
+            temperature: 0.1,
+            maxTokens: 400,
+            operation: "compression_guideline_semantic_refinement",
+            priority: "background"
+          }
+        );
+        return this.parseCompressionSemanticRefinement(
+          response?.content ?? ""
+        );
+      }
+    });
+    const content = renderCompressionGuidelinesMarkdown(refinedCandidate);
+    const contentHash = createHash("sha256").update(content).digest("hex");
+    const semanticRefinementApplied = JSON.stringify(refinedCandidate.ruleUpdates) !== JSON.stringify(candidate.ruleUpdates);
+    const changedRules = refinedCandidate.ruleUpdates.filter(
+      (rule) => rule.delta !== 0
+    ).length;
+    if (!dryRun) {
+      await this.storage.writeCompressionGuidelineDraft(content);
+      await this.storage.writeCompressionGuidelineDraftState({
+        version: refinedCandidate.optimizerVersion,
+        updatedAt: refinedCandidate.generatedAt,
+        sourceWindow: refinedCandidate.sourceWindow,
+        eventCounts: refinedCandidate.eventCounts,
+        guidelineVersion: refinedCandidate.guidelineVersion,
+        contentHash,
+        activationState: "draft",
+        actionSummaries: refinedCandidate.actionSummaries,
+        ruleUpdates: refinedCandidate.ruleUpdates
+      });
+    }
+    return {
+      enabled: true,
+      dryRun,
+      eventCount: candidate.eventCounts.total,
+      previousGuidelineVersion: previousState?.guidelineVersion ?? null,
+      nextGuidelineVersion: refinedCandidate.guidelineVersion,
+      changedRules,
+      semanticRefinementApplied,
+      persisted: !dryRun,
+      draftContentHash: dryRun ? null : contentHash
+    };
+  }
+  async activateCompressionGuidelineDraft(options) {
+    if (!this.config.compressionGuidelineLearningEnabled) {
+      return {
+        enabled: false,
+        activated: false,
+        guidelineVersion: null,
+        reason: "disabled"
+      };
+    }
+    const draftState = await this.storage.readCompressionGuidelineDraftState();
+    if (!draftState) {
+      return {
+        enabled: true,
+        activated: false,
+        guidelineVersion: null,
+        reason: "missing_draft"
+      };
+    }
+    const expectedContentHash = options?.expectedContentHash?.trim();
+    const expectedGuidelineVersion = options?.expectedGuidelineVersion;
+    if ((!expectedContentHash || expectedContentHash.length === 0) && typeof expectedGuidelineVersion !== "number") {
+      return {
+        enabled: true,
+        activated: false,
+        guidelineVersion: null,
+        reason: "expected_revision_required"
+      };
+    }
+    if (expectedContentHash && draftState.contentHash !== expectedContentHash) {
+      return {
+        enabled: true,
+        activated: false,
+        guidelineVersion: null,
+        reason: "content_hash_mismatch"
+      };
+    }
+    if (typeof expectedGuidelineVersion === "number" && draftState.guidelineVersion !== expectedGuidelineVersion) {
+      return {
+        enabled: true,
+        activated: false,
+        guidelineVersion: null,
+        reason: "guideline_version_mismatch"
+      };
+    }
+    const activated = await this.storage.activateCompressionGuidelineDraft({
+      ...expectedContentHash ? { expectedContentHash } : {},
+      ...typeof expectedGuidelineVersion === "number" ? { expectedGuidelineVersion } : {}
+    });
+    return {
+      enabled: true,
+      activated,
+      guidelineVersion: activated ? draftState.guidelineVersion : null,
+      ...activated ? {} : { reason: "draft_changed" }
+    };
+  }
+  /** Consolidation-time hook: recompute the draft from recent events. */
+  async runCompressionGuidelineLearningPass() {
+    if (!this.config.compressionGuidelineLearningEnabled) return;
+    try {
+      const result = await this.optimizeCompressionGuidelines({
+        dryRun: false,
+        eventLimit: 500
+      });
+      log.info(
+        `compression guideline learning updated (${result.eventCount} events)`
+      );
+    } catch (err) {
+      log.warn(`compression guideline learning failed (ignored): ${err}`);
+    }
+  }
+  /** Recall-time hook: surface active guidelines as a recall section. */
+  async buildCompressionGuidelineRecallSection() {
+    if (!this.config.contextCompressionActionsEnabled) return null;
+    if (!this.config.compressionGuidelineLearningEnabled) return null;
+    const state = await this.storage.readCompressionGuidelineOptimizerState().catch(() => null);
+    if (!state || state.guidelineVersion <= 0) return null;
+    const raw = await this.storage.readCompressionGuidelines().catch(() => null);
+    const summary = raw ? formatCompressionGuidelinesForRecall(raw, 5) : null;
+    if (!summary) return null;
+    return [
+      "## Active Compression Guidelines",
+      "",
+      `Guideline version: ${state.guidelineVersion}`,
+      `Updated: ${state.updatedAt}`,
+      "",
+      summary
+    ].join("\n");
+  }
+  parseCompressionSemanticRefinement(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0) return null;
+    const trimmed = raw.trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) return null;
+    try {
+      const parsed = JSON.parse(trimmed.slice(start, end + 1));
+      if (!Array.isArray(parsed?.updates)) return null;
+      const validActions = /* @__PURE__ */ new Set([
+        "store_episode",
+        "store_note",
+        "update_note",
+        "create_artifact",
+        "summarize_node",
+        "discard",
+        "link_graph"
+      ]);
+      const updates = parsed.updates.filter(
+        (item) => item && typeof item.action === "string" && validActions.has(item.action)
+      ).map((item) => {
+        const confidence = item.confidence === "low" || item.confidence === "medium" || item.confidence === "high" ? item.confidence : void 0;
+        return {
+          action: item.action,
+          delta: typeof item.delta === "number" && Number.isFinite(item.delta) ? item.delta : void 0,
+          confidence,
+          note: typeof item.note === "string" ? item.note : void 0
+        };
+      });
+      return { updates };
+    } catch {
+      return null;
+    }
+  }
+};
+function formatCompressionGuidelinesForRecall(raw, maxLines = 5) {
+  if (typeof raw !== "string" || raw.trim().length === 0) return null;
+  const sectionMatch = raw.match(
+    // End the section at `\n## ` or end-of-string. Plain $ (not \s*$): the
+    // \s* branch overlapped the lazy body and backtracked polynomially
+    // (CodeQL js/polynomial-redos). Captured lines are trimmed/filtered below,
+    // so trailing whitespace handling is unchanged.
+    /## Suggested Guidelines\s*\n([\s\S]*?)(?:\n##\s+|$)/i
+  );
+  if (!sectionMatch) return null;
+  const lines = sectionMatch[1].split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).slice(0, Math.max(1, Math.floor(maxLines)));
+  if (lines.length === 0) return null;
+  return lines.join("\n");
+}
+
+export {
+  CompressionGuidelineCoordinator,
+  formatCompressionGuidelinesForRecall
+};
+//# sourceMappingURL=chunk-SYX73XD7.js.map

package/dist/chunk-SYX73XD7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/orchestration/compression-guideline-coordinator.ts"],"sourcesContent":["/**\n * Compression-guideline learning coordinator — extracted from the\n * orchestrator (issue #1526, seam 4).\n *\n * Owns the compression-guideline learning lifecycle:\n *   - candidate computation from recorded memory-action events\n *   - optional LLM semantic refinement of the candidate\n *   - draft persistence + activation (optimizer/draft state files)\n *   - the recall section that surfaces active guidelines during recall\n *   - the consolidation-time learning pass that recomputes the draft\n *\n * The orchestrator constructs one instance and delegates the public\n * entrypoints (`optimizeCompressionGuidelines`,\n * `activateCompressionGuidelineDraft`) plus the two internal hooks\n * (`runCompressionGuidelineLearningPass`, called from the consolidation\n * loop; `buildCompressionGuidelineRecallSection`, called from the recall\n * pipeline) to it. Storage is the orchestrator's stable `this.storage`;\n * the fast-tier LLM call arrives as a callback so gateway routing stays\n * owned by the orchestrator.\n *\n * Behavior-preserving move from orchestrator.ts. No logic changes — the\n * orchestrator keeps thin delegating methods so existing call sites and\n * tests that exercise the public API continue to work.\n */\n\nimport { createHash } from \"node:crypto\";\n\n// StorageManager type comes from the package barrel (type-only) so this\n// module does not add a direct storage.ts import (#1533 ratchet).\nimport type { StorageManager } from \"../index.js\";\nimport type { PluginConfig, MemoryActionType, MemoryActionEvent } from \"../types.js\";\nimport { log } from \"../logger.js\";\nimport {\n  computeCompressionGuidelineCandidate,\n  refineCompressionGuidelineCandidateSemantically,\n  renderCompressionGuidelinesMarkdown,\n} from \"../compression-optimizer.js\";\n\n/** Dependencies injected by the orchestrator. All stable references or\n *  live accessors. */\nexport interface CompressionGuidelineCoordinatorDeps {\n  config: PluginConfig;\n  /** Live accessor: the orchestrator's storage manager (stable post-ctor). */\n  getStorage: () => StorageManager;\n  /** Fast-tier LLM call used for optional semantic refinement. Routes\n   *  through the gateway chain when configured — owned by the\n   *  orchestrator, injected here so this module stays LLM-agnostic. */\n  fastChatCompletion: (\n    messages: Array<{ role: string; content: string }>,\n    options: {\n      temperature?: number;\n      maxTokens?: number;\n      timeoutMs?: number;\n      operation?: string;\n      priority?: \"background\" | \"recall-critical\";\n    },\n  ) => Promise<{ content: string } | null>;\n}\n\n/**\n * Coordinates compression-guideline learning. Holds no mutable state of\n * its own — all persistence flows through the injected storage manager.\n */\nexport class CompressionGuidelineCoordinator {\n  constructor(private readonly deps: CompressionGuidelineCoordinatorDeps) {}\n\n  private get storage(): StorageManager {\n    return this.deps.getStorage();\n  }\n\n  private get config(): PluginConfig {\n    return this.deps.config;\n  }\n\n  async optimizeCompressionGuidelines(options?: {\n    dryRun?: boolean;\n    eventLimit?: number;\n  }): Promise<{\n    enabled: boolean;\n    dryRun: boolean;\n    eventCount: number;\n    previousGuidelineVersion: number | null;\n    nextGuidelineVersion: number;\n    changedRules: number;\n    semanticRefinementApplied: boolean;\n    persisted: boolean;\n    draftContentHash: string | null;\n  }> {\n    const dryRun = options?.dryRun === true;\n    const eventLimit =\n      typeof options?.eventLimit === \"number\"\n        ? Math.max(0, Math.floor(options.eventLimit))\n        : 500;\n\n    const [activeState, draftState] = await Promise.all([\n      this.storage.readCompressionGuidelineOptimizerState(),\n      this.storage.readCompressionGuidelineDraftState().catch(() => null),\n    ]);\n    const previousState =\n      draftState &&\n      ((activeState?.guidelineVersion ?? 0) < draftState.guidelineVersion ||\n        (activeState?.guidelineVersion ?? 0) === draftState.guidelineVersion)\n        ? draftState\n        : activeState;\n\n    if (!this.config.compressionGuidelineLearningEnabled) {\n      return {\n        enabled: false,\n        dryRun,\n        eventCount: 0,\n        previousGuidelineVersion: previousState?.guidelineVersion ?? null,\n        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,\n        changedRules: 0,\n        semanticRefinementApplied: false,\n        persisted: false,\n        draftContentHash: null,\n      };\n    }\n\n    let events = await this.storage.readMemoryActionEvents(eventLimit);\n    if (eventLimit > 0) {\n      let effectiveEvents = events.filter((event) => event.dryRun !== true);\n      let fetchLimit = eventLimit;\n      while (\n        effectiveEvents.length < eventLimit &&\n        events.length === fetchLimit\n      ) {\n        fetchLimit = Math.min(fetchLimit * 2, fetchLimit + 1000);\n        if (fetchLimit <= events.length) break;\n        events = await this.storage.readMemoryActionEvents(fetchLimit);\n        effectiveEvents = events.filter((event) => event.dryRun !== true);\n      }\n      events = effectiveEvents.slice(-eventLimit);\n    }\n    const generatedAt = new Date().toISOString();\n    const candidate = computeCompressionGuidelineCandidate(events, {\n      generatedAtIso: generatedAt,\n      previousState,\n    });\n    if (candidate.eventCounts.total === 0) {\n      return {\n        enabled: true,\n        dryRun,\n        eventCount: 0,\n        previousGuidelineVersion: previousState?.guidelineVersion ?? null,\n        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,\n        changedRules: 0,\n        semanticRefinementApplied: false,\n        persisted: false,\n        draftContentHash: null,\n      };\n    }\n    const refinedCandidate =\n      await refineCompressionGuidelineCandidateSemantically(candidate, {\n        enabled: this.config.compressionGuidelineSemanticRefinementEnabled,\n        timeoutMs: this.config.compressionGuidelineSemanticTimeoutMs,\n        runRefinement: async (baseline) => {\n          const prompt = [\n            \"You refine compression policy suggestions conservatively.\",\n            \"Return JSON only in this shape:\",\n            '{\"updates\":[{\"action\":\"summarize_node\",\"delta\":0.02,\"confidence\":\"medium\",\"note\":\"...\"}]}',\n            \"Constraints:\",\n            \"- Keep updates sparse and conservative.\",\n            \"- delta must stay between -0.15 and 0.15.\",\n            \"- Only include actions present in the input.\",\n            \"Input candidate:\",\n            JSON.stringify(baseline),\n          ].join(\"\\n\");\n\n          const response = await this.deps.fastChatCompletion(\n            [\n              {\n                role: \"system\",\n                content: \"Respond with strict JSON only. No markdown.\",\n              },\n              { role: \"user\", content: prompt },\n            ],\n            {\n              temperature: 0.1,\n              maxTokens: 400,\n              operation: \"compression_guideline_semantic_refinement\",\n              priority: \"background\",\n            },\n          );\n\n          return this.parseCompressionSemanticRefinement(\n            response?.content ?? \"\",\n          );\n        },\n      });\n\n    const content = renderCompressionGuidelinesMarkdown(refinedCandidate);\n    const contentHash = createHash(\"sha256\").update(content).digest(\"hex\");\n    const semanticRefinementApplied =\n      JSON.stringify(refinedCandidate.ruleUpdates) !==\n      JSON.stringify(candidate.ruleUpdates);\n    const changedRules = refinedCandidate.ruleUpdates.filter(\n      (rule) => rule.delta !== 0,\n    ).length;\n\n    if (!dryRun) {\n      await this.storage.writeCompressionGuidelineDraft(content);\n      await this.storage.writeCompressionGuidelineDraftState({\n        version: refinedCandidate.optimizerVersion,\n        updatedAt: refinedCandidate.generatedAt,\n        sourceWindow: refinedCandidate.sourceWindow,\n        eventCounts: refinedCandidate.eventCounts,\n        guidelineVersion: refinedCandidate.guidelineVersion,\n        contentHash,\n        activationState: \"draft\",\n        actionSummaries: refinedCandidate.actionSummaries,\n        ruleUpdates: refinedCandidate.ruleUpdates,\n      });\n    }\n\n    return {\n      enabled: true,\n      dryRun,\n      eventCount: candidate.eventCounts.total,\n      previousGuidelineVersion: previousState?.guidelineVersion ?? null,\n      nextGuidelineVersion: refinedCandidate.guidelineVersion,\n      changedRules,\n      semanticRefinementApplied,\n      persisted: !dryRun,\n      draftContentHash: dryRun ? null : contentHash,\n    };\n  }\n\n  async activateCompressionGuidelineDraft(options?: {\n    expectedContentHash?: string;\n    expectedGuidelineVersion?: number;\n  }): Promise<{\n    enabled: boolean;\n    activated: boolean;\n    guidelineVersion: number | null;\n    reason?:\n      | \"disabled\"\n      | \"missing_draft\"\n      | \"expected_revision_required\"\n      | \"content_hash_mismatch\"\n      | \"guideline_version_mismatch\"\n      | \"draft_changed\";\n  }> {\n    if (!this.config.compressionGuidelineLearningEnabled) {\n      return {\n        enabled: false,\n        activated: false,\n        guidelineVersion: null,\n        reason: \"disabled\",\n      };\n    }\n\n    const draftState = await this.storage.readCompressionGuidelineDraftState();\n    if (!draftState) {\n      return {\n        enabled: true,\n        activated: false,\n        guidelineVersion: null,\n        reason: \"missing_draft\",\n      };\n    }\n\n    const expectedContentHash = options?.expectedContentHash?.trim();\n    const expectedGuidelineVersion = options?.expectedGuidelineVersion;\n\n    if (\n      (!expectedContentHash || expectedContentHash.length === 0) &&\n      typeof expectedGuidelineVersion !== \"number\"\n    ) {\n      return {\n        enabled: true,\n        activated: false,\n        guidelineVersion: null,\n        reason: \"expected_revision_required\",\n      };\n    }\n\n    if (expectedContentHash && draftState.contentHash !== expectedContentHash) {\n      return {\n        enabled: true,\n        activated: false,\n        guidelineVersion: null,\n        reason: \"content_hash_mismatch\",\n      };\n    }\n\n    if (\n      typeof expectedGuidelineVersion === \"number\" &&\n      draftState.guidelineVersion !== expectedGuidelineVersion\n    ) {\n      return {\n        enabled: true,\n        activated: false,\n        guidelineVersion: null,\n        reason: \"guideline_version_mismatch\",\n      };\n    }\n\n    const activated = await this.storage.activateCompressionGuidelineDraft({\n      ...(expectedContentHash ? { expectedContentHash } : {}),\n      ...(typeof expectedGuidelineVersion === \"number\"\n        ? { expectedGuidelineVersion }\n        : {}),\n    });\n    return {\n      enabled: true,\n      activated,\n      guidelineVersion: activated ? draftState.guidelineVersion : null,\n      ...(activated ? {} : { reason: \"draft_changed\" as const }),\n    };\n  }\n\n  /** Consolidation-time hook: recompute the draft from recent events. */\n  async runCompressionGuidelineLearningPass(): Promise<void> {\n    if (!this.config.compressionGuidelineLearningEnabled) return;\n    try {\n      const result = await this.optimizeCompressionGuidelines({\n        dryRun: false,\n        eventLimit: 500,\n      });\n      log.info(\n        `compression guideline learning updated (${result.eventCount} events)`,\n      );\n    } catch (err) {\n      log.warn(`compression guideline learning failed (ignored): ${err}`);\n    }\n  }\n\n  /** Recall-time hook: surface active guidelines as a recall section. */\n  async buildCompressionGuidelineRecallSection(): Promise<string | null> {\n    if (!this.config.contextCompressionActionsEnabled) return null;\n    if (!this.config.compressionGuidelineLearningEnabled) return null;\n\n    const state = await this.storage\n      .readCompressionGuidelineOptimizerState()\n      .catch(() => null);\n    if (!state || state.guidelineVersion <= 0) return null;\n\n    const raw = await this.storage\n      .readCompressionGuidelines()\n      .catch(() => null);\n    const summary = raw ? formatCompressionGuidelinesForRecall(raw, 5) : null;\n    if (!summary) return null;\n\n    return [\n      \"## Active Compression Guidelines\",\n      \"\",\n      `Guideline version: ${state.guidelineVersion}`,\n      `Updated: ${state.updatedAt}`,\n      \"\",\n      summary,\n    ].join(\"\\n\");\n  }\n\n  private parseCompressionSemanticRefinement(raw: string): {\n    updates: Array<{\n      action: MemoryActionType;\n      delta?: number;\n      confidence?: \"low\" | \"medium\" | \"high\";\n      note?: string;\n    }>;\n  } | null {\n    if (typeof raw !== \"string\" || raw.trim().length === 0) return null;\n    const trimmed = raw.trim();\n    const start = trimmed.indexOf(\"{\");\n    const end = trimmed.lastIndexOf(\"}\");\n    if (start === -1 || end === -1 || end <= start) return null;\n\n    try {\n      const parsed = JSON.parse(trimmed.slice(start, end + 1)) as {\n        updates?: Array<{\n          action?: unknown;\n          delta?: unknown;\n          confidence?: unknown;\n          note?: unknown;\n        }>;\n      };\n      if (!Array.isArray(parsed?.updates)) return null;\n\n      const validActions = new Set<MemoryActionType>([\n        \"store_episode\",\n        \"store_note\",\n        \"update_note\",\n        \"create_artifact\",\n        \"summarize_node\",\n        \"discard\",\n        \"link_graph\",\n      ]);\n\n      const updates = parsed.updates\n        .filter(\n          (item) =>\n            item &&\n            typeof item.action === \"string\" &&\n            validActions.has(item.action as MemoryActionType),\n        )\n        .map((item) => {\n          const confidence: \"low\" | \"medium\" | \"high\" | undefined =\n            item.confidence === \"low\" ||\n            item.confidence === \"medium\" ||\n            item.confidence === \"high\"\n              ? item.confidence\n              : undefined;\n          return {\n            action: item.action as MemoryActionType,\n            delta:\n              typeof item.delta === \"number\" && Number.isFinite(item.delta)\n                ? item.delta\n                : undefined,\n            confidence,\n            note: typeof item.note === \"string\" ? item.note : undefined,\n          };\n        });\n\n      return { updates };\n    } catch {\n      return null;\n    }\n  }\n}\n\n/**\n * Format the active compression-guidelines section for recall. Extracted\n * from the orchestrator (was a module-level export there); re-exported by\n * the orchestrator barrel to preserve the public API. Pure — no state.\n */\nexport function formatCompressionGuidelinesForRecall(\n  raw: string,\n  maxLines: number = 5,\n): string | null {\n  if (typeof raw !== \"string\" || raw.trim().length === 0) return null;\n  const sectionMatch = raw.match(\n    // End the section at `\\n## ` or end-of-string. Plain $ (not \\s*$): the\n    // \\s* branch overlapped the lazy body and backtracked polynomially\n    // (CodeQL js/polynomial-redos). Captured lines are trimmed/filtered below,\n    // so trailing whitespace handling is unchanged.\n    /## Suggested Guidelines\\s*\\n([\\s\\S]*?)(?:\\n##\\s+|$)/i,\n  );\n  if (!sectionMatch) return null;\n\n  const lines = sectionMatch[1]\n    .split(\"\\n\")\n    .map((line) => line.trim())\n    .filter((line) => line.startsWith(\"- \"))\n    .slice(0, Math.max(1, Math.floor(maxLines)));\n  if (lines.length === 0) return null;\n\n  return lines.join(\"\\n\");\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ASKXIAHD.js → chunk-WDJCZQB4.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-ZBJMUXZH.js";
 import {
   StorageManager
-} from "./chunk-7RLCCNHU.js";
+} from "./chunk-Q6BAA57B.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -107,4 +107,4 @@ export {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-ASKXIAHD.js.map
+//# sourceMappingURL=chunk-WDJCZQB4.js.map

package/dist/{chunk-AQLOP5F4.js → chunk-WNGXQMRI.js}

@@ -1,6 +1,6 @@
 import {
   enqueuePassiveCorrectionNotification
-} from "./chunk-EY6MDMHK.js";
+} from "./chunk-F6OEXJQQ.js";
 import {
   stripAttributesSuffix
 } from "./chunk-SVOZFLIQ.js";
@@ -260,7 +260,7 @@ import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import { mkdir, readFile, rename, unlink, readdir, writeFile } from "fs/promises";
 import path from "path";
 var REDACTED_REQUEST_TEXT = "[redacted \u2014 never-store/redaction correction text withheld from the pending-plan file]";
-var CorrectionPlanner = class {
+var CorrectionPlanner = class _CorrectionPlanner {
   constructor(deps) {
     this.deps = deps;
   }
@@ -510,6 +510,11 @@ var CorrectionPlanner = class {
       const plan = parsePlan(raw);
       if (!plan) return;
       plan.status = status;
+      if (status === "applying") {
+        plan.applyingAt = this.deps.now().toISOString();
+      } else {
+        delete plan.applyingAt;
+      }
       if (status !== "applying") {
         plan.actions = plan.actions.map(
           (a) => a.kind === "redaction_rule" ? { ...a, pattern: "[redacted \u2014 pattern applied]" } : a
@@ -534,6 +539,58 @@ var CorrectionPlanner = class {
       }
     });
   }
+  /**
+   * Stale-applying TTL: a plan in `applying` state longer than this is
+   * assumed to be from a crashed process and is recovered on startup
+   * (#1713 Item 2). 10 minutes is generous for an apply that normally
+   * completes in seconds, yet short enough to avoid leaving stale state.
+   */
+  static STALE_APPLYING_TTL_MS = 10 * 60 * 1e3;
+  /**
+   * Recover stale `applying` plans past the stale-applying TTL (#1713 Item 2).
+   *
+   * A plan stuck in `applying` means the process died mid-apply. Re-applying
+   * wholesale would duplicate succeeded actions (replacements, tombstones,
+   * audits), so recovery discards + scrubs the plan instead. The operator
+   * inspects the outcome and files a NEW plan for any actions that did not
+   * complete. Plans without `applyingAt` (predating this fix) are recovered
+   * when they are past their `expiresAt` timestamp.
+   *
+   * @returns the ids of recovered (discarded) plans.
+   */
+  async recoverStaleApplyingPlans(namespace, opts) {
+    const ttl = opts?.ttlMs ?? _CorrectionPlanner.STALE_APPLYING_TTL_MS;
+    const now = (opts?.now ?? this.deps.now()).getTime();
+    const dir = await this.pendingDir(namespace);
+    let files;
+    try {
+      files = await readdir(dir);
+    } catch (err) {
+      const code = err?.code;
+      if (code === "ENOENT") return [];
+      throw err;
+    }
+    const recovered = [];
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      const planId = f.replace(/\.json$/, "");
+      let plan;
+      try {
+        plan = await this.loadPlan(namespace, planId);
+      } catch {
+        continue;
+      }
+      if (!plan || plan.status !== "applying") continue;
+      const stale = plan.applyingAt ? now - new Date(plan.applyingAt).getTime() >= ttl : now >= new Date(plan.expiresAt).getTime();
+      if (!stale) continue;
+      try {
+        await this.markConsumed(namespace, planId, "discarded");
+        recovered.push(planId);
+      } catch {
+      }
+    }
+    return recovered;
+  }
 };
 function assertSafePlanId(planId) {
   if (typeof planId !== "string" || planId.length === 0 || planId.includes("/") || planId.includes("\\") || planId.includes("\0") || planId === "." || planId === ".." || planId.startsWith(".") || planId.includes("..")) {
@@ -894,6 +951,28 @@ var CorrectionService = class {
     await this.planner.markConsumed(namespace, planId, "discarded");
     await this.planner.deletePlan(namespace, planId);
   }
+  /**
+   * Recover stale `applying` plans across the given namespaces (#1713 Item 2).
+   *
+   * Startup maintenance: scans each namespace for plans stuck in `applying`
+   * past the stale-applying TTL (process died mid-apply) and discards+scrubs
+   * them. Unlike plan/apply/listPending, this is NOT a per-caller request —
+   * it operates on all supplied namespaces directly because it is an
+   * internal maintenance operation invoked by the orchestrator at init.
+   *
+   * @returns the total count of recovered plans across all namespaces.
+   */
+  async recoverStaleApplyingPlans(namespaces) {
+    let recovered = 0;
+    for (const namespace of namespaces) {
+      try {
+        const ids = await this.planner.recoverStaleApplyingPlans(namespace);
+        recovered += ids.length;
+      } catch {
+      }
+    }
+    return recovered;
+  }
   requireEnabled() {
     if (!this.deps.isEnabled()) {
       throw new CorrectionContractError(
@@ -1164,7 +1243,7 @@ async function getExecutorMemory(wiring, namespace, memoryId) {
 }
 async function writeReplacementMemory(wiring, namespace, draft) {
   const storage = await wiring.orchestrator.getStorage(namespace);
-  const id = await storage.writeMemory(
+  const { id, tombstoneBlocked } = await storage.writeMemory(
     draft.category ?? "fact",
     draft.content,
     {
@@ -1178,6 +1257,11 @@ async function writeReplacementMemory(wiring, namespace, draft) {
       ...draft.supersedes ? { supersedes: draft.supersedes } : {}
     }
   );
+  if (tombstoneBlocked) {
+    throw new CorrectionContractError(
+      `correction replacement was tombstone-blocked (pending_review ${id}) \u2014 cannot supersede with a non-active replacement`
+    );
+  }
   return id;
 }
 async function applyEditMemory(wiring, namespace, memoryId, patch) {
@@ -1219,7 +1303,7 @@ async function rescopeMemoryFn(wiring, namespace, memoryId, toNamespace) {
   const destStorage = await wiring.orchestrator.getStorage(toNamespace);
   const fm = memory.frontmatter;
   const destContent = fm.structuredAttributes ? stripAttributesSuffix(memory.content) : memory.content;
-  const destId = await destStorage.writeMemory(fm.category, destContent, {
+  const { id: destId, tombstoneBlocked: destBlocked } = await destStorage.writeMemory(fm.category, destContent, {
     source: `correction:rescope:${namespace}`,
     ...typeof fm.confidence === "number" ? { confidence: fm.confidence } : {},
     ...Array.isArray(fm.tags) ? { tags: fm.tags } : {},
@@ -1231,6 +1315,11 @@ async function rescopeMemoryFn(wiring, namespace, memoryId, toNamespace) {
     ...Array.isArray(fm.links) ? { links: fm.links } : {},
     ...fm.intentGoal ? { intentGoal: fm.intentGoal } : {}
   });
+  if (destBlocked) {
+    throw new CorrectionContractError(
+      `rescope of ${memoryId} into "${toNamespace}" was tombstone-blocked (pending_review ${destId}) \u2014 keeping source active`
+    );
+  }
   try {
     await sourceStorage.writeMemoryFrontmatter(memory, {
       status: "archived",
@@ -1299,7 +1388,7 @@ async function registerRedactionRuleFn(wiring, namespace, pattern) {
 }
 async function appendAuditRecordFn(wiring, namespace, record) {
   const storage = await wiring.orchestrator.getStorage(namespace);
-  const id = await storage.writeMemory("correction", buildAuditBody(record), {
+  const { id } = await storage.writeMemory("correction", buildAuditBody(record), {
     source: "correction-contract",
     confidence: 1,
     tags: ["correction-audit", `plan:${record.planId}`, `classification:${record.classification}`]
@@ -1794,4 +1883,4 @@ export {
   capturePassiveCorrections,
   clusterByKey
 };
-//# sourceMappingURL=chunk-AQLOP5F4.js.map
+//# sourceMappingURL=chunk-WNGXQMRI.js.map