@remnic/core 1.1.31 → 9.3.515

package/src/transfer/fs-utils.ts

@@ -1,10 +1,13 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import {
   lstat,
   mkdir,
+  open,
   readdir,
   readFile,
   realpath,
+  rename,
+  rm,
   stat,
   writeFile,
 } from "node:fs/promises";
@@ -182,6 +185,54 @@ export async function resolveSafeArchiveTarget(
   return targetAbs;
 }
 
+export async function writeSafeArchiveTarget(
+  root: SafeArchiveRoot,
+  relPath: string,
+  content: string | Uint8Array,
+): Promise<void> {
+  const targetAbs = await resolveSafeArchiveTarget(root, relPath);
+  const parentAbs = path.dirname(targetAbs);
+  await mkdir(parentAbs, { recursive: true });
+  await assertRealpathInsideRoot(
+    root.real,
+    parentAbs,
+    relPath,
+    root.errorPrefix,
+  );
+  const parentStat = await lstat(parentAbs);
+  if (!parentStat.isDirectory() || parentStat.isSymbolicLink()) {
+    throw new Error(
+      `${root.errorPrefix}: record path parent is not a safe directory: ${relPath}`,
+    );
+  }
+  const targetStat = await lstat(targetAbs).catch((error: unknown) => {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  });
+  if (targetStat?.isSymbolicLink()) {
+    throw new Error(
+      `${root.errorPrefix}: record path targets a symlink: ${relPath}`,
+    );
+  }
+
+  const tempAbs = path.join(parentAbs, `.remnic-import-${process.pid}-${randomUUID()}.tmp`);
+  let renamed = false;
+  try {
+    const handle = await open(tempAbs, "wx", 0o600);
+    try {
+      await handle.writeFile(content);
+    } finally {
+      await handle.close();
+    }
+    await rename(tempAbs, targetAbs);
+    renamed = true;
+  } finally {
+    if (!renamed) {
+      await rm(tempAbs, { force: true }).catch(() => undefined);
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Shared path-safety helpers (used by capsule-import, capsule-merge, and
 // capsule-fork).

package/src/transfer/import-json.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
 import { ExportBundleV1Schema } from "./types.js";
 import {
   fileExists,
@@ -7,6 +6,7 @@ import {
   readJsonFile,
   resolveSafeArchiveTarget,
   type SafeArchiveRoot,
+  writeSafeArchiveTarget,
 } from "./fs-utils.js";
 import { parseConflictPolicy, type ConflictPolicy } from "./conflict-policy.js";
 import { validateExportBundleRecords } from "./integrity.js";
@@ -38,13 +38,15 @@ export async function importJsonBundle(opts: ImportJsonOptions): Promise<{ writt
     "importJsonBundle",
     "targetMemoryDir",
   );
-  const written: Array<{ abs: string; content: string }> = [];
+  const written: Array<{ root: SafeArchiveRoot; relPath: string; content: string }> = [];
 
   let skipped = 0;
   let workspaceRoot: SafeArchiveRoot | null = null;
 
   for (const rec of bundle.records) {
     const isWorkspace = rec.path.startsWith("workspace/");
+    let writeRoot: SafeArchiveRoot;
+    let writeRelPath: string;
     let absTarget: string;
     if (isWorkspace) {
       if (!opts.workspaceDir) {
@@ -56,12 +58,16 @@ export async function importJsonBundle(opts: ImportJsonOptions): Promise<{ writt
         "importJsonBundle",
         "workspaceDir",
       );
+      writeRoot = workspaceRoot;
+      writeRelPath = rec.path.slice("workspace/".length);
       absTarget = await resolveSafeArchiveTarget(
         workspaceRoot,
-        rec.path.slice("workspace/".length),
+        writeRelPath,
       );
     } else {
-      absTarget = await resolveSafeArchiveTarget(memoryRoot, rec.path);
+      writeRoot = memoryRoot;
+      writeRelPath = rec.path;
+      absTarget = await resolveSafeArchiveTarget(writeRoot, writeRelPath);
     }
 
     const exists = await fileExists(absTarget);
@@ -84,7 +90,7 @@ export async function importJsonBundle(opts: ImportJsonOptions): Promise<{ writt
       // overwrite: proceed
     }
 
-    written.push({ abs: absTarget, content: rec.content });
+    written.push({ root: writeRoot, relPath: writeRelPath, content: rec.content });
   }
 
   if (opts.dryRun) {
@@ -92,8 +98,7 @@ export async function importJsonBundle(opts: ImportJsonOptions): Promise<{ writt
   }
 
   for (const w of written) {
-    await mkdir(path.dirname(w.abs), { recursive: true });
-    await writeFile(w.abs, w.content, "utf-8");
+    await writeSafeArchiveTarget(w.root, w.relPath, w.content);
   }
 
   return { written: written.length, skipped };

package/src/transfer/import-md.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import {
   fileExists,
   listFilesRecursive,
@@ -7,6 +7,7 @@ import {
   readJsonFile,
   resolveSafeArchiveTarget,
   toPosixRelPath,
+  writeSafeArchiveTarget,
 } from "./fs-utils.js";
 import { parseConflictPolicy, type ConflictPolicy } from "./conflict-policy.js";
 import { validateManifestRecords } from "./integrity.js";
@@ -43,7 +44,7 @@ export async function importMarkdownBundle(opts: ImportMdOptions): Promise<{ wri
   }
   validateManifestRecords(manifest, records, "importMarkdownBundle");
 
-  const writes: Array<{ abs: string; content: Uint8Array }> = [];
+  const writes: Array<{ relPath: string; content: Uint8Array }> = [];
   let skipped = 0;
 
   for (const record of records) {
@@ -70,14 +71,13 @@ export async function importMarkdownBundle(opts: ImportMdOptions): Promise<{ wri
       }
     }
 
-    writes.push({ abs: dstAbs, content });
+    writes.push({ relPath: relPosix, content });
   }
 
   if (opts.dryRun) return { written: 0, skipped };
 
   for (const w of writes) {
-    await mkdir(path.dirname(w.abs), { recursive: true });
-    await writeFile(w.abs, w.content);
+    await writeSafeArchiveTarget(targetRoot, w.relPath, w.content);
   }
 
   return { written: writes.length, skipped };

package/src/transfer/import-sqlite.ts

@@ -1,10 +1,10 @@
 import path from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
 import { SQLITE_SCHEMA_VERSION } from "./sqlite-schema.js";
 import {
   fileExists,
   prepareSafeArchiveRoot,
   resolveSafeArchiveTarget,
+  writeSafeArchiveTarget,
 } from "./fs-utils.js";
 import { parseConflictPolicy, type ConflictPolicy } from "./conflict-policy.js";
 import { openBetterSqlite3 } from "../runtime/better-sqlite.js";
@@ -34,7 +34,7 @@ export async function importSqlite(opts: ImportSqliteOptions): Promise<{ written
   const fromAbs = path.resolve(opts.fromFile);
   const db = openBetterSqlite3(fromAbs, { readonly: true });
 
-  const written: Array<{ abs: string; content: string }> = [];
+  const written: Array<{ relPath: string; content: string }> = [];
   let skipped = 0;
 
   try {
@@ -83,7 +83,7 @@ export async function importSqlite(opts: ImportSqliteOptions): Promise<{ written
           }
         }
       }
-      written.push({ abs: absTarget, content: r.content });
+      written.push({ relPath: r.path_rel, content: r.content });
     }
   } finally {
     db.close();
@@ -92,8 +92,7 @@ export async function importSqlite(opts: ImportSqliteOptions): Promise<{ written
   if (opts.dryRun) return { written: 0, skipped };
 
   for (const w of written) {
-    await mkdir(path.dirname(w.abs), { recursive: true });
-    await writeFile(w.abs, w.content, "utf-8");
+    await writeSafeArchiveTarget(memoryRoot, w.relPath, w.content);
   }
 
   return { written: written.length, skipped };

package/src/trust-zones.ts

@@ -225,7 +225,7 @@ export async function recordTrustZoneRecord(options: {
   const zoneDir = path.join(rootDir, "zones", validated.zone, day);
   const filePath = path.join(zoneDir, `${validated.recordId}.json`);
   await mkdir(zoneDir, { recursive: true });
-  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  await writeFile(filePath, JSON.stringify(validated, null, 2), { encoding: "utf8", flag: "wx" });
   return filePath;
 }
 

package/src/types.ts

@@ -1222,6 +1222,30 @@ export interface PluginConfig {
   localLlmDisableThinking: boolean;
   // Gateway config for fallback AI
   gatewayConfig?: GatewayConfig;
+  /**
+   * Optional host-supplied resolver for provider API keys. Core never discovers
+   * host runtimes directly; adapters inject their native secret resolver here.
+   */
+  providerApiKeyResolver?: (params: {
+    provider: string;
+    cfg?: unknown;
+    agentDir?: string;
+  }) => Promise<{ apiKey?: string; source?: string; mode?: string } | null>;
+  /**
+   * Optional host-supplied resolver for request-ready model auth, including
+   * provider transforms such as OAuth token exchange or base URL overrides.
+   */
+  runtimeAuthForModelResolver?: (params: {
+    model: { provider: string; id: string; api?: string; baseUrl?: string };
+    cfg?: unknown;
+    workspaceDir?: string;
+  }) => Promise<{
+    apiKey?: string;
+    baseUrl?: string;
+    source?: string;
+    mode?: string;
+    profileId?: string;
+  } | null>;
   // Gateway model source (v9.2) — route LLM calls through gateway agent model chain
   modelSource: "plugin" | "gateway";
   gatewayAgentId: string;
@@ -2032,6 +2056,7 @@ export interface BufferTurn {
   parts?: import("./message-parts/index.js").LcmMessagePartInput[];
   rawContent?: unknown;
   sourceFormat?: import("./message-parts/index.js").MessagePartSourceFormat;
+  importProvenance?: import("./bulk-import/types.js").ImportTurnProvenance;
 }
 
 export interface BufferEntryState {

package/src/utility-telemetry.ts

@@ -126,7 +126,7 @@ export async function recordUtilityTelemetryEvent(options: {
   const eventsDir = path.join(rootDir, "events", day);
   const filePath = path.join(eventsDir, `${validated.eventId}.json`);
   await mkdir(eventsDir, { recursive: true });
-  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  await writeFile(filePath, JSON.stringify(validated, null, 2), { encoding: "utf8", flag: "wx" });
   return filePath;
 }
 

package/src/utils/category-dir.test.ts

@@ -0,0 +1,15 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+
+import { getCategoryDir } from "./category-dir.js";
+
+test("getCategoryDir falls back for unknown and prototype category names", () => {
+  const memoryDir = "/tmp/remnic";
+  for (const category of ["unknown", "constructor", "toString", "__proto__"]) {
+    assert.equal(
+      getCategoryDir(memoryDir, category),
+      path.join(memoryDir, "facts"),
+    );
+  }
+});

package/src/utils/category-dir.ts

@@ -39,6 +39,8 @@ export const ALL_CATEGORY_KEYS: string[] = [
  * Falls back to `facts/` for unknown categories.
  */
 export function getCategoryDir(memoryDir: string, category: string): string {
-  const dir = CATEGORY_DIR_MAP[category];
+  const dir = Object.hasOwn(CATEGORY_DIR_MAP, category)
+    ? CATEGORY_DIR_MAP[category]
+    : undefined;
   return dir ? path.join(memoryDir, dir) : path.join(memoryDir, "facts");
 }

package/src/work/boundary.ts

@@ -74,25 +74,37 @@ export function applyWorkExtractionBoundary(conversation: string): string {
   let strippedUnterminated = bounded;
   const opener = "[WORK_LAYER_CONTEXT";
   const closer = "[/WORK_LAYER_CONTEXT]";
-  const lastOpenerIdx = bounded.lastIndexOf(opener);
-  if (lastOpenerIdx >= 0) {
-    // Require line-start: either position 0 or preceded by \n
-    const isLineStart = lastOpenerIdx === 0 || bounded[lastOpenerIdx - 1] === "\n";
-    if (isLineStart) {
-      const afterOpener = bounded.indexOf("]", lastOpenerIdx);
-      if (afterOpener >= 0) {
-        const closerAfter = bounded.indexOf(closer, afterOpener);
-        if (closerAfter < 0) {
-          // Unterminated — only strip if it has real metadata attributes
-          const bracketContent = bounded.substring(lastOpenerIdx, afterOpener + 1);
-          if (bracketContent.includes("link_to_memory=") || bracketContent.includes("encoding=")) {
-            strippedUnterminated = lastOpenerIdx > 0
-              ? bounded.substring(0, lastOpenerIdx - 1)  // exclude the preceding \n
-              : "";
-          }
-        }
-      }
+  let unterminatedSearchFrom = 0;
+  while (true) {
+    const openerIdx = bounded.indexOf(opener, unterminatedSearchFrom);
+    if (openerIdx < 0) break;
+
+    const isLineStart = openerIdx === 0 || bounded[openerIdx - 1] === "\n";
+    if (!isLineStart) {
+      unterminatedSearchFrom = openerIdx + opener.length;
+      continue;
+    }
+
+    const afterOpener = bounded.indexOf("]", openerIdx);
+    const bracketContent = afterOpener >= 0
+      ? bounded.substring(openerIdx, afterOpener + 1)
+      : bounded.substring(openerIdx);
+    const hasWrapperMetadata =
+      bracketContent.includes("link_to_memory=") || bracketContent.includes("encoding=");
+    if (!hasWrapperMetadata) {
+      unterminatedSearchFrom = openerIdx + opener.length;
+      continue;
     }
+
+    const closerAfter = afterOpener >= 0 ? bounded.indexOf(closer, afterOpener) : -1;
+    if (closerAfter < 0) {
+      strippedUnterminated = openerIdx > 0
+        ? bounded.substring(0, openerIdx - 1)  // exclude the preceding \n
+        : "";
+      break;
+    }
+
+    unterminatedSearchFrom = closerAfter + closer.length;
   }
 
   const restoredEscapes = strippedUnterminated

package/src/work/storage.ts

@@ -22,6 +22,8 @@ const TASK_TRANSITIONS: Record<WorkTaskStatus, Set<WorkTaskStatus>> = {
   cancelled: new Set(),
 };
 
+const PROJECT_MUTATION_CHAINS = new Map<string, Promise<unknown>>();
+
 function serializeFrontmatter(values: object): string {
   const lines = Object.entries(values).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
   return `---\n${lines.join("\n")}\n---`;
@@ -145,6 +147,10 @@ export class WorkStorage {
     }
   }
 
+  private async writeTaskRecord(task: WorkTask): Promise<void> {
+    await writeFile(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+  }
+
   private async writeNewProject(project: WorkProject): Promise<void> {
     try {
       await writeFile(this.projectPath(project.id), this.serializeProject(project), { encoding: "utf-8", flag: "wx" });
@@ -156,6 +162,23 @@ export class WorkStorage {
     }
   }
 
+  private async writeProjectRecord(project: WorkProject): Promise<void> {
+    await writeFile(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+  }
+
+  private async enqueueProjectMutation<T>(projectId: string, op: () => Promise<T>): Promise<T> {
+    const mutationKey = this.projectPath(projectId);
+    const previous = PROJECT_MUTATION_CHAINS.get(mutationKey) ?? Promise.resolve();
+    const run = previous.catch(() => undefined).then(op);
+    const cleanup = run.then(() => undefined, () => undefined).then(() => {
+      if (PROJECT_MUTATION_CHAINS.get(mutationKey) === cleanup) {
+        PROJECT_MUTATION_CHAINS.delete(mutationKey);
+      }
+    });
+    PROJECT_MUTATION_CHAINS.set(mutationKey, cleanup);
+    return run;
+  }
+
   private parseTask(raw: string): WorkTask | null {
     const parsed = parseFrontmatter(raw);
     if (!parsed) return null;
@@ -218,10 +241,20 @@ export class WorkStorage {
       }
     }
 
-    await this.writeNewTask(task);
-
     if (task.projectId) {
-      await this.addTaskIdToProject(task.projectId, task.id, now);
+      let taskFileCreated = false;
+      try {
+        await this.writeNewTask(task);
+        taskFileCreated = true;
+        await this.addTaskIdToProject(task.projectId, task.id, now);
+      } catch (error) {
+        if (taskFileCreated) {
+          await rm(this.taskPath(task.id), { force: true }).catch(() => undefined);
+        }
+        throw error;
+      }
+    } else {
+      await this.writeNewTask(task);
     }
 
     return task;
@@ -285,15 +318,6 @@ export class WorkStorage {
       }
     }
 
-    if (projectIdPatched && existing.projectId !== nextProjectId) {
-      if (existing.projectId) {
-        await this.removeTaskIdFromProject(existing.projectId, id, now);
-      }
-      if (nextProjectId) {
-        await this.addTaskIdToProject(nextProjectId, id, now);
-      }
-    }
-
     const next: WorkTask = {
       ...existing,
       ...patch,
@@ -301,7 +325,26 @@ export class WorkStorage {
       tags: patch.tags ?? existing.tags,
       updatedAt: now.toISOString(),
     };
-    await writeFile(this.taskPath(id), this.serializeTask(next), "utf-8");
+    await this.writeTaskRecord(next);
+    if (projectIdPatched && existing.projectId !== nextProjectId) {
+      try {
+        if (nextProjectId) {
+          await this.addTaskIdToProject(nextProjectId, id, now);
+        }
+        if (existing.projectId) {
+          await this.removeTaskIdFromProject(existing.projectId, id, now);
+        }
+      } catch (error) {
+        await this.writeTaskRecord(existing);
+        if (nextProjectId) {
+          await this.removeTaskIdFromProject(nextProjectId, id, now).catch(() => undefined);
+        }
+        if (existing.projectId) {
+          await this.addTaskIdToProject(existing.projectId, id, now).catch(() => undefined);
+        }
+        throw error;
+      }
+    }
     return next;
   }
 
@@ -318,15 +361,22 @@ export class WorkStorage {
   }
 
   async deleteTask(id: string): Promise<boolean> {
+    const existing = await this.getTask(id);
+    if (!existing) return false;
+    let removedProjectLink = false;
+    if (existing.projectId) {
+      await this.removeTaskIdFromProject(existing.projectId, id);
+      removedProjectLink = true;
+    }
     try {
-      const existing = await this.getTask(id);
       await rm(this.taskPath(id));
-      if (existing?.projectId) {
-        await this.removeTaskIdFromProject(existing.projectId, id);
-      }
       return true;
-    } catch {
-      return false;
+    } catch (error) {
+      if (isErrnoCode(error, "ENOENT")) return false;
+      if (removedProjectLink && existing.projectId) {
+        await this.addTaskIdToProject(existing.projectId, id).catch(() => undefined);
+      }
+      throw error;
     }
   }
 
@@ -372,6 +422,10 @@ export class WorkStorage {
   }
 
   async updateProject(id: string, patch: UpdateWorkProjectInput, now = new Date()): Promise<WorkProject | null> {
+    return this.enqueueProjectMutation(id, async () => this.updateProjectUnlocked(id, patch, now));
+  }
+
+  private async updateProjectUnlocked(id: string, patch: UpdateWorkProjectInput, now = new Date()): Promise<WorkProject | null> {
     const existing = await this.getProject(id);
     if (!existing) return null;
     const next: WorkProject = {
@@ -381,22 +435,42 @@ export class WorkStorage {
       taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
       updatedAt: now.toISOString(),
     };
-    await writeFile(this.projectPath(id), this.serializeProject(next), "utf-8");
+    await this.writeProjectRecord(next);
     return next;
   }
 
   async deleteProject(id: string): Promise<boolean> {
+    return this.enqueueProjectMutation(id, async () => this.deleteProjectUnlocked(id));
+  }
+
+  private async deleteProjectUnlocked(id: string): Promise<boolean> {
+    const existing = await this.getProject(id);
+    if (!existing) return false;
+    const unlinkedTasks: WorkTask[] = [];
     try {
-      const existing = await this.getProject(id);
-      if (existing) {
-        for (const taskId of existing.taskIds) {
-          await this.updateTask(taskId, { projectId: null });
-        }
+      for (const taskId of existing.taskIds) {
+        const task = await this.getTask(taskId);
+        if (!task || task.projectId !== id) continue;
+        const next: WorkTask = {
+          ...task,
+          projectId: null,
+          updatedAt: new Date().toISOString(),
+        };
+        await this.writeTaskRecord(next);
+        unlinkedTasks.push(task);
       }
       await rm(this.projectPath(id));
       return true;
-    } catch {
-      return false;
+    } catch (error) {
+      for (const task of unlinkedTasks.reverse()) {
+        try {
+          await this.writeTaskRecord(task);
+        } catch {
+          // Preserve the original relationship failure for callers.
+        }
+      }
+      if (isErrnoCode(error, "ENOENT")) return false;
+      throw error;
     }
   }
 
@@ -416,21 +490,25 @@ export class WorkStorage {
   }
 
   private async removeTaskIdFromProject(projectId: string, taskId: string, now = new Date()): Promise<void> {
-    const project = await this.getProject(projectId);
-    if (!project) return;
+    await this.enqueueProjectMutation(projectId, async () => {
+      const project = await this.getProject(projectId);
+      if (!project) return;
 
-    const filtered = project.taskIds.filter((id) => id !== taskId);
-    if (filtered.length === project.taskIds.length) return;
+      const filtered = project.taskIds.filter((id) => id !== taskId);
+      if (filtered.length === project.taskIds.length) return;
 
-    await this.updateProject(projectId, { taskIds: filtered }, now);
+      await this.updateProjectUnlocked(projectId, { taskIds: filtered }, now);
+    });
   }
 
   private async addTaskIdToProject(projectId: string, taskId: string, now = new Date()): Promise<void> {
-    const project = await this.getProject(projectId);
-    if (!project) return;
-
-    const taskIds = new Set(project.taskIds);
-    taskIds.add(taskId);
-    await this.updateProject(projectId, { taskIds: Array.from(taskIds) }, now);
+    await this.enqueueProjectMutation(projectId, async () => {
+      const project = await this.getProject(projectId);
+      if (!project) throw new Error(`project not found: ${projectId}`);
+
+      const taskIds = new Set(project.taskIds);
+      taskIds.add(taskId);
+      await this.updateProjectUnlocked(projectId, { taskIds: Array.from(taskIds) }, now);
+    });
   }
 }

package/src/work-product-ledger.ts

@@ -116,7 +116,7 @@ export async function recordWorkProductLedgerEntry(options: {
   const entriesDir = path.join(rootDir, "entries", day);
   const filePath = path.join(entriesDir, `${validated.entryId}.json`);
   await mkdir(entriesDir, { recursive: true });
-  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  await writeFile(filePath, JSON.stringify(validated, null, 2), { encoding: "utf8", flag: "wx" });
   return filePath;
 }