@remnic/core 9.69.89 → 9.69.91

package/src/access-recall-corpus-versions.ts

@@ -0,0 +1,59 @@
+import type { RecallInvocationOptions } from "./orchestration/orchestrator-helpers.js";
+
+export type RecallCorpusVersion = { namespace: string; version: number | null };
+
+const DEFAULT_CAPTURE_TIMEOUT_MS = 250;
+
+export function mergeRecallCorpusVersions(
+  current: RecallCorpusVersion[],
+  captured: RecallCorpusVersion[],
+): RecallCorpusVersion[] {
+  const versions = new Map(current.map((entry) => [entry.namespace, entry]));
+  for (const entry of captured) {
+    if (!versions.has(entry.namespace)) versions.set(entry.namespace, entry);
+  }
+  return [...versions.values()];
+}
+
+export function createRecallCorpusVersionCapture(
+  orchestrator: { getStorage(namespace: string): Promise<{ getMemoryCorpusVersion(): number }> },
+  signal: AbortSignal | undefined,
+  setVersions: (versions: RecallCorpusVersion[]) => void,
+  includeNoRecall = false,
+  timeoutMs = DEFAULT_CAPTURE_TIMEOUT_MS,
+): NonNullable<RecallInvocationOptions["onRecallPlanResolved"]> {
+  return async (mode, namespaces) => {
+    if ((mode === "no_recall" && !includeNoRecall) || signal?.aborted) return;
+    const captured = await Promise.all(namespaces.map(async (namespace) => {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      let abortCapture: (() => void) | undefined;
+      try {
+        const timeout = new Promise<null>((resolve) => {
+          timer = setTimeout(() => resolve(null), timeoutMs);
+        });
+        const aborted = signal
+          ? new Promise<null>((resolve) => {
+              if (signal.aborted) {
+                resolve(null);
+              } else {
+                abortCapture = () => resolve(null);
+                signal.addEventListener("abort", abortCapture, { once: true });
+              }
+            })
+          : undefined;
+        const version = await Promise.race([
+          orchestrator.getStorage(namespace).then((storage) => storage.getMemoryCorpusVersion()),
+          timeout,
+          ...(aborted ? [aborted] : []),
+        ]);
+        return { namespace, version };
+      } catch {
+        return { namespace, version: null };
+      } finally {
+        if (timer !== undefined) clearTimeout(timer);
+        if (abortCapture) signal?.removeEventListener("abort", abortCapture);
+      }
+    }));
+    if (!signal?.aborted) setVersions(captured);
+  };
+}

package/src/access-recall-response.ts

@@ -36,6 +36,7 @@ export async function assembleRecallResponse(
   request: EngramAccessRecallRequest;
   context: string;
   contextComposition?: RecallContextComposition;
+  storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }>;
   query: string;
   mode: RecallPlanMode | undefined;
   namespace: string;
@@ -55,6 +56,7 @@ export async function assembleRecallResponse(
     request,
     context,
     contextComposition,
+    storageCorpusVersionsAtRecallStart,
     query,
     mode,
     namespace,
@@ -321,6 +323,7 @@ export async function assembleRecallResponse(
       namespace: effectiveNamespace,
       context: effectiveContext,
       contextComposition: effectiveComposition,
+      storageCorpusVersionsAtRecallStart,
       ...(retrievalFailure ? { retrievalFailure } : {}),
       count: filterTags && filterTags.length > 0
         ? results.length

package/src/access-recall-surface.ts

@@ -21,9 +21,11 @@ import { type BudgetDecision, type BudgetReservation, CrossNamespaceBudget, toBu
 import { lcmEvidenceIdentity } from "./lcm/evidence-identity.js";
 import { normalizeProjectionTags } from "./memory-projection-format.js";
 import { namespaceIdentityFromToken } from "./namespaces/identity.js";
-import { canReadNamespace, defaultNamespaceForPrincipal, recallNamespacesForPrincipal, resolvePrincipal } from "./namespaces/principal.js";
-import { expandScopeProfileReadNamespaces, resolveScopeProfilePlan } from "./namespaces/scope-profiles.js";
+import { canReadNamespace, defaultNamespaceForPrincipal, resolvePrincipal } from "./namespaces/principal.js";
+import { resolveScopeProfilePlan } from "./namespaces/scope-profiles.js";
+import { resolveScopePlan } from "./scopes/scope-plan.js";
 import type { Orchestrator, RecallInvocationOptions } from "./orchestrator.js";
+import { createRecallCorpusVersionCapture, mergeRecallCorpusVersions } from "./access-recall-corpus-versions.js";
 import { decideDisclosureEscalation } from "./recall-disclosure-escalation.js";
 import { assembleRecallResponse } from "./access-recall-response.js";
 import { coerceIncludedMemories, type LastRecallSnapshot } from "./recall-state.js";
@@ -57,6 +59,7 @@ export interface AccessRecallSurfaceDeps {
     query: string;
     sessionKey?: string;
     snapshot: RecallXraySnapshot;
+    storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }>;
     disclosure: RecallDisclosure;
     startedAt: number;
     requestedMode?: RecallPlanMode | "auto";
@@ -187,6 +190,7 @@ export class AccessRecallSurface {
     query: string;
     sessionKey?: string;
     snapshot: RecallXraySnapshot;
+    storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }>;
     disclosure: RecallDisclosure;
     startedAt: number;
     requestedMode?: RecallPlanMode | "auto";
@@ -290,6 +294,7 @@ export class AccessRecallSurface {
       sourcesUsed,
       disclosure: options.disclosure,
       budgetsApplied: snapshotForSerialization.budgetsApplied,
+      storageCorpusVersionsAtRecallStart: options.storageCorpusVersionsAtRecallStart,
       latencyMs: snapshotForSerialization.latencyMs,
     };
   }
@@ -732,29 +737,17 @@ export class AccessRecallSurface {
           codingContext: profileCodingContext,
           codingOverlay: profileCodingOverlay,
         });
+    const recallScopePlan = resolveScopePlan({
+      config: this.deps.orchestrator.config,
+      sessionKey: request.sessionKey,
+      namespace: namespaceOverride,
+      principalOverride: authenticatedPrincipal,
+      codingContext: profileCodingContext,
+      namespacesEnabled: resolveNamespaceCapabilities(this.deps.orchestrator.config).namespaces,
+    });
     // Skip budget checks for modes that never perform a cross-namespace read.
     const modeSkipsBudget = mode === "no_recall";
-    // Derive the full set of namespaces the orchestrator will actually search.
-    // When no explicit override is provided, `recallNamespacesForPrincipal()` may
-    // expand to shared / policy-default namespaces.  Budget must be checked
-    // against every cross-namespace entry in the effective set so that omitting
-    // `namespace` cannot bypass the limiter (Cursor/Codex review feedback).
-    //
-    const legacyRecallNamespaces = Array.isArray(this.deps.orchestrator.config.defaultRecallNamespaces)
-      ? recallNamespacesForPrincipal(principal, this.deps.orchestrator.config)
-      : [];
-    const effectiveNamespaces = namespaceOverride
-      ? [namespaceOverride]
-      : profilePlan
-        ? expandScopeProfileReadNamespaces({
-            profilePlan,
-            principalSelfNamespace: profilePlan.baseNamespace,
-            config: this.deps.orchestrator.config,
-            principal,
-            codingOverlay: profileCodingOverlay,
-            legacyRecallNamespaces,
-          })
-        : legacyRecallNamespaces;
+    const effectiveNamespaces = recallScopePlan.readNamespaces;
     const budgetPrincipalNamespace = profilePlan?.baseNamespace ?? principalNamespace;
     let budgetDecision: BudgetDecision;
     let willReserveBudget = false;
@@ -860,6 +853,7 @@ export class AccessRecallSurface {
       onContextComposition: (composition) => {
         contextComposition = composition;
       },
+      onRecallPlanResolved: createRecallCorpusVersionCapture(this.deps.orchestrator, request.abortSignal, (versions) => { storageCorpusVersionsAtRecallStart = mergeRecallCorpusVersions(storageCorpusVersionsAtRecallStart, versions); }, true),
       ...(authenticatedPrincipal ? { principalOverride: authenticatedPrincipal } : {}),
       ...(request.sourceConnector ? { sourceConnector: request.sourceConnector } : {}),
       ...(request.stateView !== undefined ? { stateView: request.stateView } : {}),
@@ -897,6 +891,7 @@ export class AccessRecallSurface {
     // operation — orchestrator.recall AND serialization / debug / response
     // construction — so ANY failure after the reserve releases the exact
     // budget entry (by token, review #4) instead of leaking it.
+    let storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }> = [];
     try {
       const context = await this.deps.orchestrator.recall(
         query,
@@ -907,6 +902,7 @@ export class AccessRecallSurface {
         request,
         context,
         contextComposition,
+        storageCorpusVersionsAtRecallStart,
         query,
         mode,
         namespace,
@@ -1063,6 +1059,7 @@ export class AccessRecallSurface {
     let recallStartedAt = Date.now();
 
     const recallSessionKey = request.sessionKey?.trim() || undefined;
+    let storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }> = [];
     let xrayResponse: {
       snapshotFound: boolean;
       snapshot?: RecallXraySnapshot;
@@ -1084,6 +1081,7 @@ export class AccessRecallSurface {
             ? { budgetCharsOverride: budgetOverride }
             : {}),
           ...(mode !== undefined ? { mode } : {}),
+          onRecallPlanResolved: createRecallCorpusVersionCapture(this.deps.orchestrator, request.abortSignal, (versions) => { storageCorpusVersionsAtRecallStart = mergeRecallCorpusVersions(storageCorpusVersionsAtRecallStart, versions); }, true),
           // When the caller supplies an authenticated principal, forward
           // it via the dedicated override channel so orchestrator-side
           // ACL decisions use the SAME principal the access-surface
@@ -1395,6 +1393,7 @@ export class AccessRecallSurface {
           startedAt: recallStartedAt,
           requestedMode: request.mode,
           normalizedMode: mode,
+          storageCorpusVersionsAtRecallStart,
           ...(xrayRawExcerptNamespace
             ? { rawExcerptNamespace: xrayRawExcerptNamespace }
             : {}),

package/src/access-service-observe-lcm-parity.test.ts

@@ -989,11 +989,19 @@ test("#2128: post-flush retained cleanup stops on abort or deadline", async (t)
     /replay extraction deadline exceeded \(retained_turn_cleanup\)/,
   );
 });
-test("#3140: a duration deadline reaches scope resolution and aborts it when it elapses", async () => {
+test("#3140: a duration deadline reaches scope resolution and aborts it when it elapses", async (t) => {
   // Regression for issue #3140: `deadlineMs` is a BUDGET from now. The old
   // absolute-epoch reading compared a relative value (e.g. 30000) against
   // Date.now(), so a live-session force flush was rejected INSTANTLY with
   // `replay extraction deadline exceeded (scope_resolution)` before any work.
+  // The flush deadline is a real, unref'd timer in production
+  // (session-context.ts), so racing a 30ms wall-clock budget lets the event
+  // loop drain first under CI load: the flush promise then never settles and
+  // the runner cancels the rest of the file. Mocked timers make the ordering
+  // deterministic — the budget elapses only when ticked. The clock starts at
+  // an epoch-scale `now` so a duration budget (30) is genuinely distinguished
+  // from the old absolute-epoch reading the test guards against.
+  t.mock.timers.enable({ apis: ["setTimeout", "Date"], now: 1_700_000_000_000 });
   const probe = makeParityProbe({ namespacesEnabled: false } as Partial<PluginConfig>);
   const service = new EngramAccessService(probe.orch);
   let scopeResolutionStarted = false;
@@ -1005,19 +1013,25 @@ test("#3140: a duration deadline reaches scope resolution and aborts it when it
     return new Promise<never>(() => {});
   };
 
-  const started = Date.now();
-  await assert.rejects(
-    service.extractionForceFlush({
-      sessionKey: "duration-deadline-scope-resolution",
-      deadlineMs: 30,
-    }),
-    /scope_resolution/,
-  );
+  const flush = service.extractionForceFlush({
+    sessionKey: "duration-deadline-scope-resolution",
+    deadlineMs: 30,
+  });
+  // Yield once so the stub is entered before the budget is spent; the mocked
+  // clock does not move on its own.
+  await new Promise<void>((resolve) => setImmediate(resolve));
   assert.equal(scopeResolutionStarted, true, "the budget lets scope resolution start");
-  assert.ok(
-    Date.now() - started >= 25,
-    "the flush waits out the budget instead of failing instantly",
-  );
+  // Under mocked timers the budget cannot have elapsed yet, so the flush
+  // must still be pending — proves the deadline does not fire before its
+  // budget (#3140 regression: an absolute-epoch reading would reject
+  // instantly with `scope_resolution` before the stub ran).
+  const stillPending = Promise.race([
+    flush.then(() => "rejected", () => "rejected"),
+    new Promise<string>((resolve) => setImmediate(() => resolve("pending"))),
+  ]);
+  assert.equal(await stillPending, "pending");
+  t.mock.timers.tick(30);
+  await assert.rejects(flush, /scope_resolution/);
   assert.equal(probe.extractionForceFlushCalls.length, 0);
 });
 
@@ -1076,7 +1090,14 @@ test("#2206: abort during scope resolution cancels pre-resolution observe prepar
   assert.equal(probe.extractionCalls.length, 0);
 });
 
-test("#2206: scope-resolution deadline cancels preparations by raw projectTag and cwd hints", async () => {
+test("#2206: scope-resolution deadline cancels preparations by raw projectTag and cwd hints", async (t) => {
+  // The deadline budget is a real, unref'd timer in production
+  // (session-context.ts), so a 1ms wall-clock budget can elapse BEFORE the
+  // flush enters the blocked scope stub on a loaded runner (assertion then
+  // sees flushScopeStarted === false), and a drained event loop can leave
+  // the flush pending forever. Mocked timers pin the order: the stub is
+  // entered first, the budget elapses only when ticked, and the observe tail
+  // runs after timers are restored.
   const rawHintCases = [
     { projectTag: "Acme/Webshop" },
     { cwd: "/workspace/acme/webshop" },
@@ -1119,17 +1140,29 @@ test("#2206: scope-resolution deadline cancels preparations by raw projectTag an
       ...rawHintCase,
     }));
     await observeScopeStarted;
-    await assert.rejects(
-      service.extractionForceFlush({
+    // Mock the clock only for the flush: the observe is already parked on
+    // the gate, and its tail below needs the real clock back. A try/finally
+    // makes sure a failing assertion cannot leak the mocked window or the
+    // parked observe, which would otherwise reproduce the same
+    // event-loop-drain cascade this PR fixes.
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    try {
+      const flush = service.extractionForceFlush({
         sessionKey: "pi-geek:raw-hint-deadline",
         authenticatedPrincipal: "pi-geek",
         deadlineMs: 1,
         ...rawHintCase,
-      }),
-      /scope_resolution/,
-    );
-    assert.equal(flushScopeStarted, true);
-    releaseObserveScope();
+      });
+      // Yield once so the stub is entered before the budget is spent; the
+      // mocked clock does not move on its own.
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      assert.equal(flushScopeStarted, true);
+      t.mock.timers.tick(1);
+      await assert.rejects(flush, /scope_resolution/);
+    } finally {
+      t.mock.timers.reset();
+      releaseObserveScope();
+    }
     const response = await observe;
     assert.equal(response.extractionQueued, false);
     assert.equal(probe.extractionCalls.length, 0);

package/src/access-service-raw-excerpt-read-gate.test.ts

@@ -124,7 +124,7 @@ function makeRawExcerptProbe(options: {
     resolveSelfNamespace: (sk?: string) =>
       Orchestrator.prototype.resolveSelfNamespace.call(orch, sk),
     async getStorage() {
-      return storage;
+      return { ...storage, getMemoryCorpusVersion: () => 0 };
     },
     lastRecall: new Map<string, LastRecallSnapshot>([
       [options.sessionKey, snapshot],

package/src/access-service.ts

@@ -446,6 +446,8 @@ export interface EngramAccessRecallResponse {
   /** Request-local split used by adapters that must re-render a tighter prompt budget. */
   contextComposition?: RecallContextComposition;
   retrievalFailure?: { reason: "backend_unavailable"; detail: string };
+  /** Storage corpus sentinel values read immediately before retrieval; they do not attest to QMD index application. */
+  storageCorpusVersionsAtRecallStart?: Array<{ namespace: string; version: number | null }>;
   count: number;
   memoryIds: string[];
   results: EngramAccessMemorySummary[];
@@ -2034,6 +2036,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
   private async buildRecallResponseFromXraySnapshot(options: {
     query: string;
     sessionKey?: string;
+    storageCorpusVersionsAtRecallStart: Array<{ namespace: string; version: number | null }>;
     snapshot: RecallXraySnapshot;
     disclosure: RecallDisclosure;
     startedAt: number;

package/src/capabilities.test.ts

@@ -1184,6 +1184,7 @@ const RECALL_ENH_FIELD_TO_FLAG: Record<keyof RecallEnhancementCapabilitySet, str
   responseGuidanceRecall: "responseGuidanceRecallEnabled",
   eventOrderRecall: "eventOrderRecallEnabled",
   reinforcementRecallBoost: "reinforcementRecallBoostEnabled",
+  outcomeBoost: "outcomeBoostEnabled",
   recallPlannerTelemetry: "recallPlannerTelemetryEnabled",
   peerProfileRecall: "peerProfileRecallEnabled",
   graphAssistShadowEval: "graphAssistShadowEvalEnabled",

package/src/capabilities.ts

@@ -1031,14 +1031,9 @@ export function resolveRecallAuxiliaryCapabilities(config: RecallAuxiliaryConfig
 }
 
 // ---------------------------------------------------------------------------
-// RecallEnhancement capability set (issue #1523 batch 9).
-//
-// These 24 flags gate recall enrichment, memory reconstruction, entity
-// relationships, causal trajectory recall, CMC retrieval, and related
-// enhancement paths. Read sites span orchestrator, access-service, graph-recall,
-// and CLI research-status commands. All flags are non-optional booleans on
-// PluginConfig (defaults resolved at the parse boundary), so the projection
-// is a pure pass-through.
+// RecallEnhancement capability set (issue #1523 batch 9, outcome prior #1958).
+// Gates recall enrichment and related paths. Flags are booleans on PluginConfig
+// (defaults resolved at parse), so the projection is a pure pass-through.
 // ---------------------------------------------------------------------------
 
 /**
@@ -1051,6 +1046,7 @@ export interface RecallEnhancementCapabilitySet {
   readonly responseGuidanceRecall: boolean;
   readonly eventOrderRecall: boolean;
   readonly reinforcementRecallBoost: boolean;
+  readonly outcomeBoost: boolean;
   readonly recallPlannerTelemetry: boolean;
   readonly peerProfileRecall: boolean;
   readonly graphAssistShadowEval: boolean;
@@ -1081,6 +1077,7 @@ export type RecallEnhancementConfigProjection = Pick<
   | "responseGuidanceRecallEnabled"
   | "eventOrderRecallEnabled"
   | "reinforcementRecallBoostEnabled"
+  | "outcomeBoostEnabled"
   | "recallPlannerTelemetryEnabled"
   | "peerProfileRecallEnabled"
   | "graphAssistShadowEvalEnabled"
@@ -1111,6 +1108,7 @@ export function resolveRecallEnhancementCapabilities(config: RecallEnhancementCo
     responseGuidanceRecall: config.responseGuidanceRecallEnabled,
     eventOrderRecall: config.eventOrderRecallEnabled,
     reinforcementRecallBoost: config.reinforcementRecallBoostEnabled,
+    outcomeBoost: config.outcomeBoostEnabled,
     recallPlannerTelemetry: config.recallPlannerTelemetryEnabled,
     peerProfileRecall: config.peerProfileRecallEnabled,
     graphAssistShadowEval: config.graphAssistShadowEvalEnabled === true,

package/src/config.ts

@@ -44,6 +44,7 @@ import {
   parseStandingBlockMaxChars,
 } from "./standing-memory-block.js";
 import { parseDirectorySidecarsEnabled } from "./directory-sidecars.js";
+import { parseOutcomeBoostWeight } from "./rerank-outcome.js";
 import { parseRecognitionIndexMaxEntries, parseRecallRecognitionTier } from "./recall-recognition-tier.js";
 import { parseRecallConcurrencyConfig } from "./recall-concurrency-config.js";
 import { parseExtractionFields } from "./extraction-span-config.js";
@@ -2622,6 +2623,8 @@ export function parseConfig(
       }
       return n;
     })(),
+    outcomeBoostEnabled: coerceBool(cfg.outcomeBoostEnabled) ?? false,
+    outcomeBoostWeight: parseOutcomeBoostWeight(cfg.outcomeBoostWeight),
     // Async peer profile reasoner (issue #679 PR 2/5). Defaults to
     // `false` (opt-in) per Gotchas #30/#48 — least-privileged default.
     // `coerceBool` handles "true"/"1"/"yes"/"on" CLI strings (Gotcha

package/src/index.ts

@@ -393,7 +393,7 @@ export { auditMemoryStore, auditScreenProfile, formatAuditMemoryReport, type Aud
 // Access layer (HTTP + MCP + schema validation)
 // ---------------------------------------------------------------------------
 
-export { EngramAccessService, EngramAccessInputError } from "./access-service.js";
+export { EngramAccessService, EngramAccessInputError, type EngramAccessRecallResponse } from "./access-service.js";
 export {
   EngramAccessHttpServer,
   type RemnicAdminConfigPatch,

package/src/orchestration/orchestrator-helpers.ts

@@ -199,6 +199,7 @@ export interface RecallInvocationOptions {
   namespace?: string;
   topK?: number;
   mode?: RecallPlanMode;
+  onRecallPlanResolved?: (mode: RecallPlanMode, readNamespaces: readonly string[]) => void | Promise<void>;
   abortSignal?: AbortSignal;
   /** Server-resolved identity of the connector performing this recall. */
   sourceConnector?: string;
@@ -689,7 +690,6 @@ export function buildCompressionGuidelinesMarkdown(
   return buildCompressionGuidelinesMarkdownV2(events, generatedAtIso);
 }
 
-
 export function applyQueryAwareCandidateFilter(
   candidates: QmdSearchResult[],
   candidatePaths: Set<string> | null,

package/src/orchestration/recall-entry.ts

@@ -19,7 +19,7 @@ import { type RecallInvocationOptions, abortRecallError } from "./orchestrator-h
 import { ProfilingCollector } from "../profiling.js";
 import { trustResultFor, type TrustStageResultItem } from "../trust-score-stage.js";
 import type { RecallResultFormatter } from "./recall-result-formatter.js";
-import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../types.js";
+import type { IdentityInjectionMode, PluginConfig, QmdSearchResult, RecallPlanMode } from "../types.js";
 import { stateViewPacketActive } from "../recall-state-view-anchors.js";
 import { resultStateViewKey, stateViewPacketKeys } from "../recall-state-view.js";
 import { applyRecallStateViews } from "../recall-state-view-wire.js";
@@ -163,11 +163,16 @@ export class RecallEntryCoordinator {
       options.budgetCharsOverride >= 0
         ? options.budgetCharsOverride
         : this.deps.config.recallBudgetChars;
-    if (this.deps.config.recallStandingBlock && !namespacesEnabled && standingBudget !== 0 && !options.asOf) {
+    const shouldReadStandingBlock =
+      this.deps.config.recallStandingBlock && !namespacesEnabled && standingBudget !== 0 && !options.asOf;
+    if (shouldReadStandingBlock) {
       try {
-        const memories = await this.deps.storage.readAllMemories({
-          abortSignal: abortController.signal,
-        });
+        await options.onRecallPlanResolved?.("no_recall", [this.deps.config.defaultNamespace]);
+      } catch (err) {
+        log.warn(`standing-memory plan callback failed: ${err}`);
+      }
+      try {
+        const memories = await this.deps.storage.readAllMemories({ abortSignal: abortController.signal });
         standingText = renderStandingMemoryBlock(
           this.deps.config,
           memoriesToStandingEntries(memories, { requestingConnector: options.sourceConnector }),
@@ -176,25 +181,36 @@ export class RecallEntryCoordinator {
         log.warn(`standing memory block skipped: ${err}`);
       }
     }
+    let innerBudget = options.budgetCharsOverride;
     const innerObserver = options.onContextComposition;
-    const innerBudget =
-      standingText.length > 0 && standingBudget && standingBudget > 0
-        ? Math.max(0, standingBudget - standingText.length - 2)
-        : options.budgetCharsOverride;
-    const recallOptions = {
+    let recallOptions: RecallInvocationOptions;
+    recallOptions = {
       ...options,
       abortSignal: abortController.signal,
       budgetCharsOverride: innerBudget,
+      onRecallPlanResolved: options.onRecallPlanResolved || shouldReadStandingBlock
+        ? async (mode: RecallPlanMode, readNamespaces: readonly string[]) => {
+            const versionNamespaces =
+              mode === "no_recall" && !shouldReadStandingBlock
+                ? []
+                : shouldReadStandingBlock && !readNamespaces.includes(this.deps.config.defaultNamespace)
+                  ? [...readNamespaces, this.deps.config.defaultNamespace]
+                  : readNamespaces;
+            await options.onRecallPlanResolved?.(mode, versionNamespaces);
+            innerBudget = standingText.length > 0 && standingBudget > 0
+              ? Math.max(0, standingBudget - standingText.length - 2)
+              : options.budgetCharsOverride;
+            recallOptions.budgetCharsOverride = innerBudget;
+          }
+        : undefined,
       onContextComposition:
-        standingText.length > 0
+        shouldReadStandingBlock
           ? (composition: RecallContextComposition) =>
               innerObserver?.({
                 ...composition,
-                context: prefixStandingMemoryBlock(
-                  composition.context ?? "",
-                  standingText,
-                  standingBudget,
-                ),
+                context: standingText.length > 0
+                  ? prefixStandingMemoryBlock(composition.context ?? "", standingText, standingBudget)
+                  : composition.context,
               })
           : innerObserver,
     };

package/src/orchestration/recall-internal.ts

@@ -344,8 +344,7 @@ export class RecallInternalCoordinator {
       );
     }
     this.deps.profiler.endSpan("planning", profileTraceId);
-    const recallMode: RecallPlanMode =
-      requestedMode ?? recallDecision.effectiveMode;
+    const recallMode: RecallPlanMode = requestedMode ?? recallDecision.effectiveMode;
     const queryIntent = inferIntentFromText(retrievalQuery);
     const qmdSearchOptions =
       this.deps.buildConfiguredQmdSearchOptions(retrievalQuery);
@@ -467,6 +466,7 @@ export class RecallInternalCoordinator {
       scopeProfilePlan,
       lcmReadSessionIds,
     } = scopePlan;
+    await options.onRecallPlanResolved?.(recallMode, recallNamespaces);
     // `firstNonEmptyLcmRead`: query the ordered LCM read key set, return the
     // FIRST non-empty result (#1505). The query-SCORED sections no longer use
     // it — they MERGE candidates across every authorized key (a weak primary

package/src/orchestration/recall-search-pipeline.ts

@@ -58,6 +58,7 @@ import {
   memoryMapKey,
   resultHasKey,
 } from "../recall-memory-map.js";
+import { applyOutcomePriorScores, outcomePriorBoostActive } from "../rerank-outcome.js";
 import { type UtilityRuntimeValues, applyUtilityRankingRuntimeDelta } from "../utility-runtime.js";
 import {
   lifecycleRecallScoreAdjustment,
@@ -1710,6 +1711,8 @@ export class RecallSearchPipelineCoordinator {
       boosted.push({ ...r, score });
     }
 
+    if (outcomePriorBoostActive(this.deps.config)) applyOutcomePriorScores(boosted, memoryByPath, this.deps.config);
+
     // Re-sort by boosted score
     return boosted.sort((a, b) => b.score - a.score);
   }

package/src/orchestrator-init.test.ts

@@ -8,9 +8,19 @@ import { parseConfig } from "./config.js";
 import { Orchestrator } from "./orchestrator.js";
 import { NoopSearchBackend } from "./search/noop-backend.js";
 
+/**
+ * Watchdog for startup lifecycle awaits. This is a HANG guard, not a speed
+ * budget: a real Orchestrator.initialize() does real fs/sqlite discovery and
+ * can take well over a second on a loaded CI runner (a merge to main failed
+ * its shard when initialize settled ~40ms after the old 1250ms deadline had
+ * already resolved), and the discovery paths can block the loop so even
+ * in-file timers stall meanwhile. The deadline only needs to fire when the
+ * awaited lifecycle genuinely never settles, so keep it far above any
+ * legitimate startup cost.
+ */
 async function withTestDeadline<T>(
   promise: Promise<T>,
-  timeoutMs = 1_250,
+  timeoutMs = 10_000,
 ): Promise<T | "deadline"> {
   let timer: NodeJS.Timeout | undefined;
   const deadline = new Promise<"deadline">((resolve) => {

package/src/outcome-boost-config.ts

@@ -0,0 +1,16 @@
+/**
+ * H1 outcome-prior recall blend (issue #1958).
+ *
+ * Both fields default off/zero. Recall ranking stays on the existing
+ * boost path unless `outcomeBoostEnabled` is true and `outcomeBoostWeight`
+ * is greater than 0.
+ */
+export interface OutcomeBoostConfig {
+  /** Opt-in gate. Default false. */
+  outcomeBoostEnabled: boolean;
+  /**
+   * Blend weight in [0, 1]. Absent config parses as 0, which does not
+   * change scores. Invalid values throw.
+   */
+  outcomeBoostWeight: number;
+}