@remnic/core 9.69.74 → 9.69.76

package/src/orchestration/recall-entry.ts

@@ -23,7 +23,12 @@ import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../ty
 import { stateViewPacketActive } from "../recall-state-view-anchors.js";
 import { resultStateViewKey, stateViewPacketKeys } from "../recall-state-view.js";
 import { applyRecallStateViews } from "../recall-state-view-wire.js";
-import { composeRecallContext } from "../recall-context-composition.js";
+import { composeRecallContext, type RecallContextComposition } from "../recall-context-composition.js";
+import {
+  memoriesToStandingEntries,
+  prefixStandingMemoryBlock,
+  renderStandingMemoryBlock,
+} from "../standing-memory-recall.js";
 import {
   notifyContextComposition,
   recallFailureComposition,
@@ -151,16 +156,53 @@ export class RecallEntryCoordinator {
       return lockedMsg;
     }
 
-    // Keep outer recall timeout above worst-case serialized hybrid search:
-    // QMD subprocess BM25 (30s) + vector (30s) can consume ~60s under contention.
+    let standingText = "";
+    const standingBudget =
+      typeof options.budgetCharsOverride === "number" &&
+      Number.isInteger(options.budgetCharsOverride) &&
+      options.budgetCharsOverride >= 0
+        ? options.budgetCharsOverride
+        : this.deps.config.recallBudgetChars;
+    if (this.deps.config.recallStandingBlock && !namespacesEnabled && standingBudget !== 0 && !options.asOf) {
+      try {
+        const memories = await this.deps.storage.readAllMemories({
+          abortSignal: abortController.signal,
+        });
+        standingText = renderStandingMemoryBlock(
+          this.deps.config,
+          memoriesToStandingEntries(memories, { requestingConnector: options.sourceConnector }),
+        );
+      } catch (err) {
+        log.warn(`standing memory block skipped: ${err}`);
+      }
+    }
+    const innerObserver = options.onContextComposition;
+    const innerBudget =
+      standingText.length > 0 && standingBudget && standingBudget > 0
+        ? Math.max(0, standingBudget - standingText.length - 2)
+        : options.budgetCharsOverride;
+    const recallOptions = {
+      ...options,
+      abortSignal: abortController.signal,
+      budgetCharsOverride: innerBudget,
+      onContextComposition:
+        standingText.length > 0
+          ? (composition: RecallContextComposition) =>
+              innerObserver?.({
+                ...composition,
+                context: prefixStandingMemoryBlock(
+                  composition.context ?? "",
+                  standingText,
+                  standingBudget,
+                ),
+              })
+          : innerObserver,
+    };
     try {
-      const recallPromise = this.deps.recallInternal(prompt, sessionKey, {
-        ...options,
-        abortSignal: abortController.signal,
-      }, caps, graphCaps);
+      const recallPromise = this.deps.recallInternal(prompt, sessionKey, recallOptions, caps, graphCaps);
       const RECALL_TIMEOUT_MS = this.deps.config.recallOuterTimeoutMs ?? 75_000;
       if (RECALL_TIMEOUT_MS <= 0) {
-        return await recallPromise;
+        return prefixStandingMemoryBlock(await recallPromise, standingText, standingBudget);
       }
 
       let timeoutHandle: NodeJS.Timeout | null = null;
@@ -196,18 +238,17 @@ export class RecallEntryCoordinator {
         }
       }
 
-      return recallResult;
+      return prefixStandingMemoryBlock(recallResult, standingText, standingBudget);
     } catch (err) {
       this.deps.logRecallFailure(err);
-      // endTrace() is safe here: if no trace is active (disabled or already
-      // closed by recallInternal's try/finally), it returns null immediately.
       this.deps.profiler.endTrace();
-      // Caller-cancelled recalls stay quiet: the failure was the caller's
-      // abort, not a recall degradation (issue #2972 contract).
       const missing = options.abortSignal?.aborted
         ? null
         : recallFailureComposition(err);
       if (!missing) return "";
+      if (standingText.length > 0) {
+        missing.context = prefixStandingMemoryBlock(missing.context ?? "", standingText, standingBudget);
+      }
       notifyContextComposition(options.onContextComposition, missing, (observerErr) => {
         log.warn("recall: context composition observer failed open", observerErr);
       });

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

@@ -22,6 +22,7 @@ import { abortError } from "../abort-error.js";
 import { type CapabilitySet, type GraphConstructionCapabilitySet, resolveCapabilities, resolveConversationContextCapabilities, resolveGraphConstructionCapabilities, resolveIndexingCapabilities, resolveMemoryLifecycleCapabilities, resolveNamespaceCapabilities, resolvePipelineProcessingCapabilities, resolveQmdCapabilities, resolveRecallEnhancementCapabilities } from "../capabilities.js";
 import { EmbeddingFallback } from "../embedding-fallback.js";
 import { StorageManager } from "../index.js";
+import { applyDirectorySidecarDrillDown, isDirectorySidecarsEnabledForDir } from "../directory-sidecars.js";
 import { inferIntentFromText, intentCompatibilityScore } from "../intent.js";
 import { log } from "../logger.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
@@ -342,9 +343,6 @@ export class RecallSearchPipelineCoordinator {
     const debugSearchOptions = backendHonorsQmdSearchSignals
       ? resolvedSearchOptions
       : undefined;
-    // Cross-lingual recall (#2197): lexical tiers cannot match a query whose
-    // dominant script differs from the corpus's, whatever the page fill.
-    // Supplement with the embedding-fallback tier ONCE, before widening.
     const crossScriptVectorHits = options.crossScript
       ? await this.searchEmbeddingFallback(prompt, fetchLimit)
       : [];
@@ -517,7 +515,7 @@ export class RecallSearchPipelineCoordinator {
       if (filteredResults.length >= qmdFetchLimit) {
         const capped = filteredResults.slice(0, qmdFetchLimit);
         await emitDebugSnapshot(capped, fetchLimit);
-        return capped;
+        return await applyDirectorySidecarDrillDown(this.deps.storage?.dir ?? "", prompt, capped, { enabled: Boolean(this.deps.storage?.dir) && isDirectorySidecarsEnabledForDir(this.deps.storage.dir), namespaces: options.namespacesEnabled ? options.recallNamespaces ?? [] : undefined });
       }
       if (filteredResults.length > bestFiltered.length) {
         bestFiltered = filteredResults;
@@ -526,7 +524,7 @@ export class RecallSearchPipelineCoordinator {
       // hits). Keep widening until the backend itself underfills the page.
       if (primaryResults.length < fetchLimit) {
         await emitDebugSnapshot(filteredResults, fetchLimit);
-        return filteredResults;
+        return await applyDirectorySidecarDrillDown(this.deps.storage?.dir ?? "", prompt, filteredResults, { enabled: Boolean(this.deps.storage?.dir) && isDirectorySidecarsEnabledForDir(this.deps.storage.dir), namespaces: options.namespacesEnabled ? options.recallNamespaces ?? [] : undefined });
       }
       if (fetchLimit >= maxFetchLimit) {
         break;
@@ -538,7 +536,7 @@ export class RecallSearchPipelineCoordinator {
 
     const capped = bestFiltered.slice(0, qmdFetchLimit);
     await emitDebugSnapshot(capped, fetchLimit);
-    return capped;
+    return await applyDirectorySidecarDrillDown(this.deps.storage?.dir ?? "", prompt, capped, { enabled: Boolean(this.deps.storage?.dir) && isDirectorySidecarsEnabledForDir(this.deps.storage.dir), namespaces: options.namespacesEnabled ? options.recallNamespaces ?? [] : undefined });
   }
 
   async searchEmbeddingFallback(

package/src/orchestrator.ts

@@ -143,6 +143,7 @@ import { WorkspaceOpsCoordinator } from "./orchestration/workspace-ops.js";
 import { NamespaceReadFanoutCoordinator } from "./orchestration/namespace-read-fanout.js";
 import { selfDeps } from "./orchestration/self-deps.js";
 import { RecallEntryCoordinator } from "./orchestration/recall-entry.js";
+import { setDirectorySidecarsEnabledForDir } from "./directory-sidecars.js";
 import { SessionContextCoordinator, type SessionFlushOptions } from "./orchestration/session-context.js";
 import { drainRecallWrites, trackRecallWrite } from "./orchestration/recall-background-writes.js";
 import { XrayCaptureQueue } from "./orchestration/xray-capture-queue.js";
@@ -1971,6 +1972,13 @@ export class Orchestrator {
   async initialize(): Promise<void> {
     this.extractionQueueCoordinator.resumeAccepting();
     await this.orchestratorInitCoordinator.initialize();
+    {
+      const memoryDir = this.storage?.dir;
+      if (typeof memoryDir === "string" && memoryDir.length > 0) {
+        const { directorySidecarsEnabled } = this.config;
+        setDirectorySidecarsEnabledForDir(memoryDir, directorySidecarsEnabled);
+      }
+    }
     if (isDependencyPropagationEnabled(this.config)) {
       this._dependencyPropagationRecovery = this.dependencyPropagationDelivery
         .recover()

package/src/standing-memory-block.test.ts

@@ -230,6 +230,7 @@ async function writeFact(memoryDir: string): Promise<void> {
     `created: ${now}`,
     `updated: ${now}`,
     "source: extraction",
+    "origin: user",
     "confidence: 0.8",
     "confidenceTier: high",
     "tags: []",
@@ -242,7 +243,7 @@ async function writeFact(memoryDir: string): Promise<void> {
   await writeFile(path.join(factsDir, "standing-fact.md"), `${fact.join("\n")}\n`, "utf-8");
 }
 
-test("zero-diff: recall output is byte-identical with the flag off vs on (pre-wiring)", async () => {
+test("recall injects the standing memory block when the flag is on", async () => {
   const off = await makeOrchestrator();
   const on = await makeOrchestrator({ recallStandingBlock: true });
   try {
@@ -250,8 +251,8 @@ test("zero-diff: recall output is byte-identical with the flag off vs on (pre-wi
     await writeFact(on.memoryDir);
     const outOff = await off.orchestrator.recall("how do deploys go out", "sess-standing-off");
     const outOn = await on.orchestrator.recall("how do deploys go out", "sess-standing-on");
-    assert.equal(outOn, outOff, "recall must not change until the wiring slice lands");
-    assert.ok(!outOn.includes("## Standing Memory (Remnic)"), "no standing block in recall output");
+    assert.ok(!outOff.includes("## Standing Memory (Remnic)"), "flag off keeps recall unchanged");
+    assert.ok(outOn.includes("## Standing Memory (Remnic)"), "flag on injects the standing block");
     assert.ok(outOn.includes("blue pipeline"), "sanity: the fact is recalled");
   } finally {
     await off.orchestrator.destroy();

package/src/standing-memory-recall.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseConfig } from "./config.js";
+import {
+  memoriesToStandingEntries,
+  prefixStandingMemoryBlock,
+  renderStandingMemoryBlock,
+} from "./standing-memory-recall.js";
+
+test("#3089 standing block is omitted when recallStandingBlock is off", () => {
+  const off = parseConfig({});
+  const on = parseConfig({ recallStandingBlock: true });
+  const entries = memoriesToStandingEntries([
+    {
+      id: "fact-1",
+      content: "The blue pipeline is the only deploy path.",
+      frontmatter: { id: "fact-1", pinned: true, origin: "user" },
+    },
+  ]);
+  const recall = "per-turn recall";
+  assert.equal(renderStandingMemoryBlock(off, entries), "");
+  assert.equal(prefixStandingMemoryBlock(recall, renderStandingMemoryBlock(off, entries)), recall);
+  const standing = renderStandingMemoryBlock(on, entries);
+  assert.ok(standing.includes("## Standing Memory (Remnic)"));
+  assert.ok(standing.includes("blue pipeline"));
+  const prefixed = prefixStandingMemoryBlock(recall, standing);
+  assert.ok(prefixed.startsWith(standing));
+  assert.ok(prefixed.includes("per-turn recall"));
+});

package/src/standing-memory-recall.ts

@@ -0,0 +1,87 @@
+import {
+  DEFAULT_UNTRUSTED_ORIGINS,
+  isUntrustedOrigin,
+  parseOriginClass,
+} from "./security/origin-authority.js";
+import type { PluginConfig } from "./types.js";
+import {
+  buildStandingMemoryBlock,
+  lintStandingBlockVolatility,
+  type StandingMemoryEntry,
+} from "./standing-memory-block.js";
+
+export interface StandingMemorySource {
+  id?: string;
+  path?: string;
+  content: string;
+  frontmatter: {
+    id?: unknown;
+    pinned?: unknown;
+    updated?: unknown;
+    origin?: unknown;
+    status?: unknown;
+    toolScoped?: unknown;
+    sourceConnector?: unknown;
+  };
+}
+
+export function memoriesToStandingEntries(
+  memories: readonly StandingMemorySource[],
+  opts: { requestingConnector?: string } = {},
+): StandingMemoryEntry[] {
+  const entries: StandingMemoryEntry[] = [];
+  for (const memory of memories) {
+    const id = String(memory.frontmatter.id ?? memory.id ?? memory.path ?? "");
+    if (!id) continue;
+    if (isUntrustedOrigin(parseOriginClass(memory.frontmatter.origin), DEFAULT_UNTRUSTED_ORIGINS)) {
+      continue;
+    }
+    if (typeof memory.frontmatter.status === "string" && memory.frontmatter.status !== "active") {
+      continue;
+    }
+    const requestingConnector = opts.requestingConnector?.trim();
+    const memoryConnector =
+      typeof memory.frontmatter.sourceConnector === "string" ? memory.frontmatter.sourceConnector.trim() : "";
+    if (memory.frontmatter.toolScoped === true && memoryConnector && requestingConnector && memoryConnector !== requestingConnector) {
+      continue;
+    }
+    const description =
+      memory.content
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("---")) ?? "";
+    if (description.length < 8) continue;
+    if (lintStandingBlockVolatility(description).length > 0) continue;
+    const pinned = memory.frontmatter.pinned === true;
+    const lastChangedAt =
+      typeof memory.frontmatter.updated === "string" ? memory.frontmatter.updated : undefined;
+    entries.push({ id, description: description.slice(0, 200), pinned, lastChangedAt });
+  }
+  return entries;
+}
+
+export function renderStandingMemoryBlock(config: PluginConfig, entries: StandingMemoryEntry[]): string {
+  if (!config.recallStandingBlock || entries.length === 0) return "";
+  try {
+    return buildStandingMemoryBlock({
+      entries,
+      nowMs: Date.now(),
+      maxChars: config.standingBlockMaxChars,
+      freshDays: config.standingBlockFreshDays,
+    }).text;
+  } catch {
+    return "";
+  }
+}
+
+export function prefixStandingMemoryBlock(
+  recallResult: string,
+  standingText: string,
+  budgetChars?: number,
+): string {
+  if (standingText.length === 0) return recallResult;
+  if (budgetChars === 0) return recallResult;
+  const combined = `${standingText}\n\n${recallResult}`;
+  if (!budgetChars || combined.length <= budgetChars) return combined;
+  return combined.slice(0, budgetChars);
+}

package/src/storage.ts

@@ -248,8 +248,7 @@ import {
   sealedWriteToLegacyArgs,
   type SealedMemoryEnvelope,
 } from "./write-envelope.js";
-// stripCitation import removed: legacy rebuild fallback was replaced by a
-// skip-with-warning strategy (Finding 1 — Uhol).  See ensureFactHashIndexAuthoritative.
+import { isDirectorySidecarsEnabledForDir, refreshDirectorySidecarsAfterWrite } from "./directory-sidecars.js";
 type SharedVersionKind = "memory-status" | "artifact-write" | "cold-write" | "memory-corpus" | "entity-mutation";
 
 type OfflineSyncDigestCacheEntry = {
@@ -3973,25 +3972,7 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
     return { id, tombstoneBlocked, ...(fm.blockedBy ? { blockedBy: fm.blockedBy } : {}), memory: { path: filePath, frontmatter: fm, content: sanitized.text } };
   }
 
-  /**
-   * Sealed-envelope write entry point (issue #1989 PR2).
-   *
-   * Byte-identity with `writeMemory` is BY DELEGATION: the envelope-owned
-   * fields are unpacked into the exact `writeMemory` arguments a legacy
-   * caller would have passed, so the persisted output is produced by the
-   * same code path. The composer's `persistedBody` was assembled with the
-   * same `assemblePersistedBody` helper `writeMemory` uses, so fingerprints
-   * derived from the envelope match the stored body (§13).
-   *
-   * Differences from a raw `writeMemory` call are REJECTIONS, not silent
-   * changes: the composer enforces tag/attribute caps, strict validAt, and
-   * plain-object attributes that the legacy path never validated.
-   *
-   * `envelope.ttl` maps to `expiresAt` verbatim; converting duration
-   * expressions (`"90d"`) to instants remains the access layer's job (PR3).
-   * `envelope.sourceReason` is access-layer metadata with no frontmatter
-   * field and is deliberately not persisted here.
-   */
+  /** Sealed-envelope write entry point (issue #1989 PR2). */
   async writeSealedMemory(envelope: SealedMemoryEnvelope, extras: SealedWriteExtras = {}) {
     if (!isSealedMemoryEnvelope(envelope)) {
       throw new Error(
@@ -3999,7 +3980,17 @@ export class StorageManager extends TombstoneBlockedCaptureIndexHost {
       );
     }
     const { category, content, options } = sealedWriteToLegacyArgs(envelope, extras);
-    return this.writeMemory(category, content, options as WriteMemoryOptions);
+    const result = await this.writeMemory(category, content, options as WriteMemoryOptions);
+    try {
+      await refreshDirectorySidecarsAfterWrite(
+        this.dir,
+        result.memory?.path ?? "",
+        isDirectorySidecarsEnabledForDir(this.dir),
+      );
+    } catch (err) {
+      log.warn(`directory sidecar refresh failed after write: ${err}`);
+    }
+    return result;
   }
 
   async hasFactContentHash(content: string): Promise<boolean> {

package/src/types.ts

@@ -996,12 +996,12 @@ export interface PluginConfig
   recallDirectAnswerEnabled: boolean;
   /** Recall state views (issue #1952): label current/historical/transition on change-intent queries. Default false. */
   recallStateViews: boolean;
-  /** Standing memory block (issue #2971): byte-stable pinned-memory index injected before per-turn recall; parsed now, injection lands in a later slice. Default false. */
+  /** Standing memory block (issue #2971). Default false. */
   recallStandingBlock: boolean;
-  /** Days a memory stays in the standing block's full-text fresh band. Default 14. */
   standingBlockFreshDays: number;
-  /** Hard character budget for the standing memory block. Default 2048. */
   standingBlockMaxChars: number;
+  /** Directory sidecars (issue #3088). Default false. */
+  directorySidecarsEnabled: boolean;
   /**
    * Disclosure auto-escalation policy (issue #677 PR 4/4).  `"auto"`
    * escalates chunk → section when top-K confidence falls below