@remnic/core 9.3.613 → 9.3.615

package/dist/transfer/types.d.ts

@@ -313,13 +313,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -334,13 +334,13 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
+    schemaVersion: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
         identityAnchors: boolean;
         peerProfiles: boolean;
     };
-    schemaVersion: string;
     id: string;
     description: string;
     version: string;
@@ -464,13 +464,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -485,13 +485,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -518,13 +518,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -551,13 +551,13 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        schemaVersion: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
             identityAnchors: boolean;
             peerProfiles: boolean;
         };
-        schemaVersion: string;
         id: string;
         description: string;
         version: string;
@@ -683,13 +683,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -704,13 +704,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -737,13 +737,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -770,13 +770,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -815,13 +815,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;
@@ -854,13 +854,13 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            schemaVersion: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
                 identityAnchors: boolean;
                 peerProfiles: boolean;
             };
-            schemaVersion: string;
             id: string;
             description: string;
             version: string;

package/dist/types.d.ts

@@ -564,6 +564,9 @@ interface PluginConfig {
     qmdChunkStrategy: "auto" | "regex";
     qmdCandidateLimit?: number;
     qmdQueryRerankEnabled: boolean;
+    qmdSearchStrategy: "hybrid" | "lex-vec" | "lex";
+    qmdSubprocessStrategy: "query" | "search";
+    qmdDaemonTimeoutMs: number;
     qmdIndexName?: string;
     qmdForceCpu: boolean;
     qmdGpuBackend?: "auto" | "metal" | "cuda" | "vulkan" | "false";
@@ -1217,6 +1220,18 @@ interface PluginConfig {
     modelSource: "plugin" | "gateway";
     gatewayAgentId: string;
     fastGatewayAgentId: string;
+    /**
+     * Optional task-specific model chain for Remnic's background LLM work —
+     * extraction, the extraction judge, fact/profile/identity consolidation,
+     * summarization, semantic consolidation, calibration, and causal
+     * consolidation. When set, this chain is resolved through gateway providers
+     * instead of using gatewayAgentId or agents.defaults.model. All task paths
+     * route through the shared `gatewayTaskChainOptions` helper.
+     *
+     * Only takes effect when `modelSource: "gateway"`; ignored (with a startup
+     * warning) under `modelSource: "plugin"`. See issue #1365 / PR #1370.
+     */
+    taskModelChain?: AgentPersonaModelConfig;
     namespacesEnabled: boolean;
     defaultNamespace: string;
     sharedNamespace: string;
@@ -1378,6 +1393,15 @@ interface PluginConfig {
     behaviorLoopMaxDeltaPerCycle: number;
     behaviorLoopProtectedParams: string[];
     recallPlannerEnabled: boolean;
+    /**
+     * Opt-in gate for LLM-based recall planning (issue #1367 / Option C). When
+     * false (the default) recall mode is decided by the regex heuristic
+     * `planRecallMode()`. When true, the planner consults an LLM (routed through
+     * the gateway/fallback chain — provider-agnostic) and falls back to the
+     * heuristic on timeout/error/unavailable. `recallPlannerShadowMode` runs the
+     * LLM for telemetry only without changing the effective mode.
+     */
+    recallPlannerLlmEnabled: boolean;
     recallPlannerModel: string;
     recallPlannerTimeoutMs: number;
     recallPlannerUseResponsesApi: boolean;
@@ -1631,6 +1655,14 @@ interface PluginConfig {
     binaryLifecycleBackendType: "filesystem" | "s3" | "none";
     /** Base path for the filesystem backend. Required when backendType is "filesystem". */
     binaryLifecycleBackendPath: string;
+    /**
+     * Advertise legacy `engram_*` / `engram.*` MCP tool aliases alongside the
+     * canonical `remnic_*` names (issue #1427). Default true for backward
+     * compatibility. Set false to halve the advertised MCP `tools/list` surface;
+     * tools stay callable under both names regardless. Also settable via
+     * `REMNIC_EMIT_LEGACY_TOOLS` (falls back to `ENGRAM_EMIT_LEGACY_TOOLS`).
+     */
+    emitLegacyTools: boolean;
     /** Enable oai-mem-citation blocks in recall responses. Default false. */
     citationsEnabled: boolean;
     /** Auto-enable citations when the Codex adapter is detected. Default true. */

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-KGK2QKWL.js";
+} from "./chunk-4R4KTDIE.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-learner.js

@@ -3,7 +3,7 @@ import {
   learnUtilityPromotionWeights,
   readUtilityLearningSnapshot,
   resolveUtilityLearningStatePath
-} from "./chunk-3BP57I6J.js";
+} from "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
 import "./chunk-TBBDFYXW.js";
 import "./chunk-A2IYSXDQ.js";

package/dist/utility-runtime.js

@@ -2,8 +2,8 @@ import {
   applyUtilityPromotionRuntimePolicy,
   applyUtilityRankingRuntimeDelta,
   loadUtilityRuntimeValues
-} from "./chunk-W7L6HXUC.js";
-import "./chunk-3BP57I6J.js";
+} from "./chunk-LXOM6IQU.js";
+import "./chunk-2F6NP3NT.js";
 import "./chunk-TERNBNJB.js";
 import "./chunk-TBBDFYXW.js";
 import "./chunk-A2IYSXDQ.js";

package/dist/verified-recall.js

@@ -1,11 +1,11 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-ZT3EGNLR.js";
+} from "./chunk-QPD426WT.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-YFS5OEKO.js";
+import "./chunk-7MLB4NCL.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-4H5ZJHEN.js";
-import "./chunk-KGK2QKWL.js";
+import "./chunk-4R4KTDIE.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-KILOTVIF.js";

package/dist/work/board.js

@@ -2,8 +2,8 @@ import {
   exportWorkBoardMarkdown,
   exportWorkBoardSnapshot,
   importWorkBoardSnapshot
-} from "../chunk-ETUPBUHB.js";
-import "../chunk-L227SKTB.js";
+} from "../chunk-GDASG7NC.js";
+import "../chunk-GDB4J2H3.js";
 import "../chunk-5UZXUTVO.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/dist/work/storage.d.ts

@@ -16,6 +16,7 @@ declare class WorkStorage {
     private writeNewProject;
     private writeProjectRecord;
     private enqueueProjectMutation;
+    private enqueueTaskMutation;
     private parseTask;
     private parseProject;
     createTask(input: CreateWorkTaskInput, now?: Date): Promise<WorkTask>;
@@ -24,6 +25,7 @@ declare class WorkStorage {
     updateTask(id: string, patch: UpdateWorkTaskInput, now?: Date, options?: {
         skipStatusTransitionValidation?: boolean;
     }): Promise<WorkTask | null>;
+    private updateTaskUnlocked;
     transitionTask(id: string, nextStatus: WorkTaskStatus, now?: Date): Promise<WorkTask>;
     deleteTask(id: string): Promise<boolean>;
     createProject(input: CreateWorkProjectInput, now?: Date): Promise<WorkProject>;

package/dist/work/storage.js

@@ -1,7 +1,7 @@
 import {
   WORK_ID_PATTERN,
   WorkStorage
-} from "../chunk-L227SKTB.js";
+} from "../chunk-GDB4J2H3.js";
 import "../chunk-5UZXUTVO.js";
 import "../chunk-PZ5AY32C.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.613",
+  "version": "9.3.615",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-http.ts

@@ -49,6 +49,8 @@ export interface EngramAccessHttpServerOptions {
   citationsEnabled?: boolean;
   /** Auto-enable citations for Codex adapter connections (issue #379). */
   citationsAutoDetect?: boolean;
+  /** Advertise legacy engram.* tool aliases on tools/list (issue #1427). Default true. */
+  emitLegacyTools?: boolean;
 }
 
 export interface EngramAccessHttpServerStatus {
@@ -247,6 +249,7 @@ export class EngramAccessHttpServer {
       principal: options.principal,
       citationsEnabled: options.citationsEnabled,
       citationsAutoDetect: options.citationsAutoDetect,
+      emitLegacyTools: options.emitLegacyTools,
     });
   }
 
@@ -1091,12 +1094,20 @@ export class EngramAccessHttpServer {
         entityRef: body.entityRef,
         ttl: body.ttl,
         sourceReason: body.sourceReason,
+        cwd: body.cwd,
+        projectTag: body.projectTag,
       };
-      const idempotencyStatus = await this.service.peekMemoryStoreIdempotency(request);
-      if (idempotencyStatus === "miss" && request.dryRun !== true) {
-        this.ensureWriteRateLimitAvailable();
-      }
-      const response = await this.service.memoryStore(request);
+      // Rate-limit enforcement is SOLELY authoritative inside memoryStore via
+      // enforceWriteQuota: it runs atomically with the real idempotency-miss
+      // determination (and the real resolved namespace), and is never invoked
+      // for a replay. We deliberately do NOT pre-check here: the write namespace
+      // is resolved from mutable session/git context, so a stale peek could
+      // report "miss" for a request that is actually an idempotent replay in the
+      // now-scoped namespace and hard-reject a safe replay with 429 (#1434 Codex
+      // review). Letting the in-lock hook be the only hard gate avoids that.
+      const response = await this.service.memoryStore(request, {
+        enforceWriteQuota: () => this.ensureWriteRateLimitAvailable(),
+      });
       if (this.shouldCountWriteRateLimit(response as { dryRun?: boolean; idempotencyReplay?: boolean })) {
         this.recordWriteRateLimitHit();
       }
@@ -1120,12 +1131,15 @@ export class EngramAccessHttpServer {
         entityRef: body.entityRef,
         ttl: body.ttl,
         sourceReason: body.sourceReason,
+        cwd: body.cwd,
+        projectTag: body.projectTag,
       };
-      const idempotencyStatus = await this.service.peekSuggestionSubmitIdempotency(request);
-      if (idempotencyStatus === "miss" && request.dryRun !== true) {
-        this.ensureWriteRateLimitAvailable();
-      }
-      const response = await this.service.suggestionSubmit(request);
+      // Quota enforcement is solely authoritative inside suggestionSubmit
+      // (enforceWriteQuota), atomic with the real miss and never on a replay; no
+      // HTTP pre-check, so a stale peek can't 429 a safe replay (#1434 Codex review).
+      const response = await this.service.suggestionSubmit(request, {
+        enforceWriteQuota: () => this.ensureWriteRateLimitAvailable(),
+      });
       if (this.shouldCountWriteRateLimit(response as { dryRun?: boolean; idempotencyReplay?: boolean })) {
         this.recordWriteRateLimitHit();
       }

package/src/access-mcp.test.ts

@@ -262,6 +262,115 @@ test("MCP memory write tools reject malformed arguments before dispatch", async
   }
 });
 
+test("MCP write tools accept and forward client-injected cwd/projectTag (#1434)", async () => {
+  for (const toolName of ["engram.memory_store", "engram.suggestion_submit"]) {
+    let received: Record<string, unknown> | undefined;
+    const service = {
+      ...makeMockService(),
+      memoryStore: async (args: Record<string, unknown>) => {
+        received = args;
+        return {
+          schemaVersion: 1,
+          operation: "memory_store",
+          namespace: "default",
+          dryRun: true,
+          accepted: true,
+          queued: false,
+          status: "validated",
+        };
+      },
+      suggestionSubmit: async (args: Record<string, unknown>) => {
+        received = args;
+        return {
+          schemaVersion: 1,
+          operation: "suggestion_submit",
+          namespace: "default",
+          dryRun: true,
+          accepted: true,
+          queued: false,
+          status: "validated",
+        };
+      },
+    } as unknown as EngramAccessService;
+    const server = new EngramMcpServer(service);
+
+    const response = await server.handleRequest(
+      makeToolRequest(toolName, {
+        content: "valid durable content",
+        category: "fact",
+        dryRun: true,
+        cwd: "/home/dev/project-x",
+        projectTag: "Blend/Supply",
+      }),
+    );
+    const result = (response as Record<string, unknown> & {
+      result?: { isError?: boolean };
+    }).result;
+
+    assert.equal(result?.isError, false, `${toolName} should accept cwd/projectTag`);
+    assert.equal(received?.cwd, "/home/dev/project-x", `${toolName} must forward cwd`);
+    assert.equal(received?.projectTag, "Blend/Supply", `${toolName} must forward projectTag`);
+  }
+});
+
+test("MCP write tools still reject genuinely-unknown keys after the cwd fix (#1434)", async () => {
+  let dispatched = false;
+  const service = {
+    ...makeMockService(),
+    memoryStore: async () => {
+      dispatched = true;
+      return {
+        schemaVersion: 1,
+        operation: "memory_store",
+        namespace: "default",
+        dryRun: true,
+        accepted: true,
+        queued: false,
+        status: "validated",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+  const response = await server.handleRequest(
+    makeToolRequest("engram.memory_store", {
+      content: "valid durable content",
+      category: "fact",
+      dryRun: true,
+      cwd: "/ok",
+      bogusField: "must still be rejected",
+    }),
+  );
+  const result = (response as Record<string, unknown> & {
+    result?: { isError?: boolean; content?: Array<{ text?: string }> };
+  }).result;
+  assert.equal(result?.isError, true, "unknown keys must still be rejected");
+  assert.equal(dispatched, false, "malformed write must not dispatch");
+});
+
+test("MCP capsule tools tolerate client-injected cwd/projectTag (#1434)", async () => {
+  for (const toolName of [
+    "engram.capsule_list",
+    "engram.capsule_export",
+    "engram.capsule_import",
+  ]) {
+    const service = {
+      ...makeMockService(),
+      capsuleList: async () => ({ capsules: [] }),
+      capsuleExport: async () => ({ exported: true }),
+      capsuleImport: async () => ({ imported: true }),
+    } as unknown as EngramAccessService;
+    const server = new EngramMcpServer(service);
+    const args: Record<string, unknown> = { cwd: "/x", projectTag: "t" };
+    if (toolName === "engram.capsule_export") args.name = "cap-1";
+    if (toolName === "engram.capsule_import") args.archivePath = "/tmp/a.capsule.json.gz";
+    const response = await server.handleRequest(makeToolRequest(toolName, args));
+    const result = (response as Record<string, unknown> & {
+      result?: { isError?: boolean };
+    }).result;
+    assert.equal(result?.isError, false, `${toolName} should tolerate cwd/projectTag`);
+  }
+});
+
 test("MCP session override is injected only into tools that accept sessionKey", async () => {
   let capsuleListArgs: Record<string, unknown> | undefined;
   let observeArgs: Record<string, unknown> | undefined;
@@ -721,3 +830,54 @@ test("MCP profiling report rejects invalid argument types before dispatch", asyn
   assert.equal((badFormat as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, true);
   assert.equal((badLimit as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, true);
 });
+
+// ──────────────────────────────────────────────────────────────────────────
+// Issue #1427: opt-out of legacy engram.* tool aliases on tools/list
+// ──────────────────────────────────────────────────────────────────────────
+
+function listToolNames(response: unknown): string[] {
+  const tools = (response as { result?: { tools?: Array<{ name: string }> } }).result?.tools ?? [];
+  return tools.map((t) => t.name);
+}
+
+const TOOLS_LIST_REQUEST = { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} };
+
+test("tools/list advertises both remnic.* and engram.* by default (back-compat)", async () => {
+  const server = new EngramMcpServer(makeMockService());
+  const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
+  assert.ok(names.includes("remnic.recall"), "canonical name present");
+  assert.ok(names.includes("engram.recall"), "legacy alias present by default");
+  const legacyCount = names.filter((n) => n.startsWith("engram.")).length;
+  assert.ok(legacyCount > 0, "legacy aliases advertised by default");
+});
+
+test("tools/list omits engram.* aliases when emitLegacyTools is false", async () => {
+  const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
+  const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
+  assert.ok(names.includes("remnic.recall"), "canonical name still present");
+  assert.equal(
+    names.filter((n) => n.startsWith("engram.")).length,
+    0,
+    "no engram.* aliases advertised when opted out",
+  );
+  // Every advertised tool uses the canonical prefix; the surface is halved.
+  assert.ok(names.every((n) => n.startsWith("remnic.")), "all advertised tools are canonical");
+});
+
+test("emitLegacyTools=false still allows calling tools under BOTH names (advertising-only opt-out)", async () => {
+  const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
+  // Canonical call works.
+  const canonical = await server.handleRequest(makeToolRequest("remnic.recall", { query: "hello" }));
+  assert.notEqual(
+    (canonical as { result?: { isError?: boolean } }).result?.isError,
+    true,
+    "canonical remnic.recall call succeeds",
+  );
+  // Legacy call still dispatches even though it is no longer advertised.
+  const legacy = await server.handleRequest(makeToolRequest("engram.recall", { query: "hello" }));
+  assert.notEqual(
+    (legacy as { result?: { isError?: boolean } }).result?.isError,
+    true,
+    "legacy engram.recall call still works (callability preserved)",
+  );
+});