@remnic/core 9.3.612 → 9.3.614

package/src/temporal-index.ts

@@ -322,6 +322,12 @@ function removePathFromSet(record: Record<string, string[]>, key: string, p: str
   }
 }
 
+function removePathFromAllSets(record: Record<string, string[]>, p: string): void {
+  for (const key of Object.keys(record)) {
+    removePathFromSet(record, key, p);
+  }
+}
+
 function normalizeTagSegment(segment: string): string {
   return segment
     .trim()
@@ -499,6 +505,41 @@ function removeTagGraphEntry(index: TagIndex, rawTag: string, memoryPath: string
   node.paths = node.paths.filter((value) => value !== memoryPath);
   if (node.paths.length === 0) {
     delete index.tags[canonical];
+    pruneTagAliases(index);
+  }
+}
+
+function removePathFromAllTagEntries(index: TagIndex, memoryPath: string): void {
+  for (const [canonical, nodeOrPaths] of Object.entries(index.tags)) {
+    if (Array.isArray(nodeOrPaths)) {
+      const paths = nodeOrPaths.filter((value) => value !== memoryPath);
+      if (paths.length === 0) {
+        delete index.tags[canonical];
+      } else {
+        index.tags[canonical] = paths;
+      }
+      continue;
+    }
+
+    nodeOrPaths.paths = nodeOrPaths.paths.filter((value) => value !== memoryPath);
+    if (nodeOrPaths.paths.length === 0) {
+      delete index.tags[canonical];
+    }
+  }
+  pruneTagAliases(index);
+}
+
+function pruneTagAliases(index: TagIndex): void {
+  if (!index.aliases) return;
+  for (const [alias, canonicals] of Object.entries(index.aliases)) {
+    const filtered = [...new Set(canonicals.map(normalizeCanonicalTag))].filter(
+      (canonical) => canonical.length > 0 && index.tags[canonical] !== undefined
+    );
+    if (filtered.length === 0) {
+      delete index.aliases[alias];
+    } else {
+      index.aliases[alias] = filtered;
+    }
   }
 }
 
@@ -555,10 +596,12 @@ export function indexMemory(memoryDir: string, memoryPath: string, createdAt: st
 
     const dateKey = isoDateFromTimestamp(createdAt);
     updateTemporalIndex(memoryDir, (index) => {
+      removePathFromAllSets(index.dates, memoryPath);
       addPathToSet(index.dates, dateKey, memoryPath);
     });
 
     updateTagIndex(memoryDir, (index) => {
+      removePathFromAllTagEntries(index, memoryPath);
       for (const tag of tags) {
         if (tag && typeof tag === "string") {
           addTagGraphEntry(index, tag, memoryPath);
@@ -645,12 +688,14 @@ export function indexMemoriesBatch(
     updateTemporalIndex(memoryDir, (index) => {
       for (const entry of entries) {
         const dateKey = isoDateFromTimestamp(entry.createdAt);
+        removePathFromAllSets(index.dates, entry.path);
         addPathToSet(index.dates, dateKey, entry.path);
       }
     });
 
     updateTagIndex(memoryDir, (index) => {
       for (const entry of entries) {
+        removePathFromAllTagEntries(index, entry.path);
         for (const tag of entry.tags) {
           if (tag && typeof tag === "string") {
             addTagGraphEntry(index, tag, entry.path);

package/src/training-export/cli-date-validation.test.ts

@@ -135,6 +135,42 @@ describe("parseStrictCliDate", () => {
     assert.equal(d.getUTCHours(), 9);
   });
 
+  it("accepts ISO datetime with ordinary negative timezone offset", () => {
+    const d = parseStrictCliDate("2026-01-15T23:00:00-08:00", "--since");
+    // 2026-01-15T23:00:00-08:00 => 2026-01-16T07:00:00Z
+    assert.equal(d.getUTCFullYear(), 2026);
+    assert.equal(d.getUTCDate(), 16);
+    assert.equal(d.getUTCHours(), 7);
+  });
+
+  it("rejects timezone offset hour beyond UTC+14", () => {
+    assert.throws(
+      () => parseStrictCliDate("2024-01-15T10:00:00+15:00", "--since"),
+      /timezone offset out of range/,
+    );
+  });
+
+  it("rejects timezone offset minute beyond 59", () => {
+    assert.throws(
+      () => parseStrictCliDate("2024-01-15T10:00:00+05:61", "--since"),
+      /timezone offset out of range/,
+    );
+  });
+
+  it("rejects timezone offset minutes at the UTC+14 boundary", () => {
+    assert.throws(
+      () => parseStrictCliDate("2024-01-15T10:00:00+14:01", "--until"),
+      /timezone offset out of range/,
+    );
+  });
+
+  it("rejects timezone offset minutes at the UTC-14 boundary", () => {
+    assert.throws(
+      () => parseStrictCliDate("2024-01-15T10:00:00-14:01", "--until"),
+      /timezone offset out of range/,
+    );
+  });
+
   it("still rejects overflow dates in UTC form (Z suffix)", () => {
     assert.throws(
       () => parseStrictCliDate("2026-02-31T00:00:00Z", "--since"),

package/src/training-export/date-parse.ts

@@ -10,6 +10,7 @@
  *   - Calendar overflows (Feb 30, Feb 29 in non-leap years, Apr 31, etc.)
  *     regardless of timezone suffix
  *   - Out-of-range time components (hour >= 24, minute >= 60, second >= 60)
+ *   - Out-of-range timezone offsets (beyond ±14:00, or offset minute >= 60)
  *
  * Calendar overflow is validated structurally on the Y-M-D components, so
  * results are independent of the host's local timezone.
@@ -65,7 +66,7 @@ export function parseStrictCliDate(value: string, flagName: string): Date {
   // 1. Shape check: must begin YYYY-MM-DD and use ISO 8601 structure.
   //    This rejects "12/25/2026", "December 25, 2026", RFC 2822, etc.
   const shape =
-    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(Z|[+-]\d{2}:\d{2})?)?$/;
+    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?(?:Z|([+-])(\d{2}):(\d{2}))?)?$/;
   const match = value.match(shape);
   if (!match) {
     throw new Error(
@@ -103,7 +104,25 @@ export function parseStrictCliDate(value: string, flagName: string): Date {
     }
   }
 
-  // 4. Finally parse via Date for the actual timestamp value. At this point
+  // 4. Timezone offset validation.
+  //    Date accepts offset hours beyond the real-world UTC offset range and
+  //    normalizes impossible offsets into a shifted instant. Reject those
+  //    before constructing the Date so the CLI cannot silently apply them.
+  if (match[8] !== undefined) {
+    const offsetHour = Number(match[9]);
+    const offsetMinute = Number(match[10]);
+    if (
+      offsetHour > 14 ||
+      offsetMinute > 59 ||
+      (offsetHour === 14 && offsetMinute !== 0)
+    ) {
+      throw new Error(
+        `Invalid ${flagName} value "${value}": timezone offset out of range.`,
+      );
+    }
+  }
+
+  // 5. Finally parse via Date for the actual timestamp value. At this point
   //    we've already validated structure and calendar correctness, so any
   //    remaining NaN (extremely unlikely) still fails closed.
   const d = new Date(value);

package/src/transfer/export-sqlite.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { mkdir } from "node:fs/promises";
 import { SQLITE_SCHEMA_VERSION, SQLITE_TABLES_SQL } from "./sqlite-schema.js";
 import { listFilesRecursive, readUtf8FileStrict, toPosixRelPath } from "./fs-utils.js";
 import { openBetterSqlite3 } from "../runtime/better-sqlite.js";
@@ -26,6 +27,8 @@ export async function exportSqlite(opts: ExportSqliteOptions): Promise<void> {
     rows.push({ rel: relPosix, bytes, sha256, content });
   }
 
+  await mkdir(path.dirname(outAbs), { recursive: true });
+
   const db = openBetterSqlite3(outAbs);
   try {
     db.exec("PRAGMA journal_mode=WAL;");

package/src/types.ts

@@ -576,6 +576,12 @@ export interface PluginConfig {
   qmdChunkStrategy: "auto" | "regex";
   qmdCandidateLimit?: number;
   qmdQueryRerankEnabled: boolean;
+  // Daemon search plan; "hybrid" (default) = lex+vec+hyde. Issue #1335.
+  qmdSearchStrategy: "hybrid" | "lex-vec" | "lex";
+  // Subprocess fallback command; "query" (default) keeps LLM expansion. Issue #1335.
+  qmdSubprocessStrategy: "query" | "search";
+  // Per-call daemon search timeout in ms; default 8000. Issue #1335.
+  qmdDaemonTimeoutMs: number;
   qmdIndexName?: string;
   qmdForceCpu: boolean;
   qmdGpuBackend?: "auto" | "metal" | "cuda" | "vulkan" | "false";
@@ -1262,6 +1268,18 @@ export 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;
 
   // v3.0 Multi-agent memory (namespaces)
   namespacesEnabled: boolean;
@@ -1453,6 +1471,15 @@ export interface PluginConfig {
   behaviorLoopProtectedParams: string[];
   // v8.0 Phase 1: recall planner + intent routing + verbatim artifacts
   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;
@@ -1732,6 +1759,14 @@ export interface PluginConfig {
   /** 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;
   // Codex citation parity (issue #379)
   /** Enable oai-mem-citation blocks in recall responses. Default false. */
   citationsEnabled: boolean;

package/src/utility-learner.ts

@@ -293,6 +293,7 @@ export async function learnUtilityPromotionWeights(options: {
   };
 
   if (weights.length === 0) {
+    await writeUtilityLearningSnapshot(statePath, snapshot);
     return {
       applied: false,
       reason: "insufficient_events",

package/src/work/storage.ts

@@ -23,6 +23,7 @@ const TASK_TRANSITIONS: Record<WorkTaskStatus, Set<WorkTaskStatus>> = {
 };
 
 const PROJECT_MUTATION_CHAINS = new Map<string, Promise<unknown>>();
+const TASK_MUTATION_CHAINS = new Map<string, Promise<unknown>>();
 
 function serializeFrontmatter(values: object): string {
   const lines = Object.entries(values).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
@@ -179,6 +180,19 @@ export class WorkStorage {
     return run;
   }
 
+  private async enqueueTaskMutation<T>(taskId: string, op: () => Promise<T>): Promise<T> {
+    const mutationKey = this.taskPath(taskId);
+    const previous = TASK_MUTATION_CHAINS.get(mutationKey) ?? Promise.resolve();
+    const run = previous.catch(() => undefined).then(op);
+    const cleanup = run.then(() => undefined, () => undefined).then(() => {
+      if (TASK_MUTATION_CHAINS.get(mutationKey) === cleanup) {
+        TASK_MUTATION_CHAINS.delete(mutationKey);
+      }
+    });
+    TASK_MUTATION_CHAINS.set(mutationKey, cleanup);
+    return run;
+  }
+
   private parseTask(raw: string): WorkTask | null {
     const parsed = parseFrontmatter(raw);
     if (!parsed) return null;
@@ -293,6 +307,15 @@ export class WorkStorage {
     patch: UpdateWorkTaskInput,
     now = new Date(),
     options?: { skipStatusTransitionValidation?: boolean },
+  ): Promise<WorkTask | null> {
+    return this.enqueueTaskMutation(id, async () => this.updateTaskUnlocked(id, patch, now, options));
+  }
+
+  private async updateTaskUnlocked(
+    id: string,
+    patch: UpdateWorkTaskInput,
+    now = new Date(),
+    options?: { skipStatusTransitionValidation?: boolean },
   ): Promise<WorkTask | null> {
     const existing = await this.getTask(id);
     if (!existing) return null;