@remnic/core 1.1.31 → 9.3.516

package/src/offline-sync.ts

@@ -183,11 +183,13 @@ interface OfflineSyncFileRecordOptions {
   includeContent: boolean;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }
 
 const SYNC_INTERNAL_DIR = ".offline-sync";
 const OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS = 1_000;
+const OFFLINE_SYNC_FAST_BASE_CTIME_TOLERANCE_MS = 1;
 const EXCLUDED_FILE_NAMES = new Set([
   ".sync-state.json",
 ]);
@@ -205,6 +207,11 @@ function sha256Buffer(buffer: Buffer): { sha256: string; bytes: number } {
   return sha256Bytes(buffer);
 }
 
+function throwIfOfflineSyncAborted(signal: AbortSignal | undefined): void {
+  if (!signal?.aborted) return;
+  throw new Error("offline sync request aborted");
+}
+
 function compareByPath<T extends { path: string }>(left: T, right: T): number {
   return left.path.localeCompare(right.path);
 }
@@ -480,6 +487,7 @@ const REMOTE_AUTHORITATIVE_RUNTIME_STATE_FILES = new Set([
   "buffer.json",
   "embeddings.json",
   "index_time.json",
+  "last_intent.json",
   "last_recall.json",
   "memory-lifecycle-ledger.jsonl",
   "recall_impressions.jsonl",
@@ -508,22 +516,23 @@ function canReuseFastBaseFileState(
     return false;
   }
   if (baseCapturedAtMs === null) return false;
-  return st.ctimeMs - baseCapturedAtMs <= OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS;
+  // Node reports stat times as fractional milliseconds while Date snapshots are
+  // whole milliseconds, so allow only a tiny precision window around capture.
+  return st.ctimeMs - baseCapturedAtMs <= OFFLINE_SYNC_FAST_BASE_CTIME_TOLERANCE_MS;
 }
 
 async function canReuseFastBaseFileStateFromDisk(
   baseEntry: OfflineSyncFileState,
-  filePath: string,
   st: { size: number; mtimeMs: number; ctimeMs: number },
   baseCapturedAtMs: number | null,
 ): Promise<boolean> {
-  if (!canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs)) return false;
-  return !(await fileIsSecureStoreEncrypted(filePath).catch(() => true));
+  return canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs);
 }
 
 async function readOfflineSyncFileRecord(
   options: OfflineSyncFileRecordOptions,
 ): Promise<OfflineSyncFileRecord> {
+  throwIfOfflineSyncAborted(options.signal);
   const relPath = validateArchiveRelativePath(options.relPath, "offlineSyncFile.path");
   let content: Buffer | null = null;
   let digest: OfflineSyncFileDigest;
@@ -531,16 +540,20 @@ async function readOfflineSyncFileRecord(
     content = options.readFile
       ? await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath })
       : await readFile(options.filePath);
+    throwIfOfflineSyncAborted(options.signal);
     digest = sha256Buffer(content);
   } else if (options.readFileDigest) {
     digest = await options.readFileDigest({ root: options.root.abs, path: relPath, filePath: options.filePath });
+    throwIfOfflineSyncAborted(options.signal);
   } else if (options.readFile) {
     content = await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath });
+    throwIfOfflineSyncAborted(options.signal);
     digest = sha256Buffer(content);
     content = null;
   } else {
-    digest = await sha256File(options.filePath);
+    digest = await sha256File(options.filePath, options.signal);
   }
+  throwIfOfflineSyncAborted(options.signal);
   const st = await stat(options.filePath);
   return {
     path: relPath,
@@ -551,14 +564,16 @@ async function readOfflineSyncFileRecord(
   };
 }
 
-async function sha256File(filePath: string): Promise<OfflineSyncFileDigest> {
+async function sha256File(filePath: string, signal?: AbortSignal): Promise<OfflineSyncFileDigest> {
   const hash = createHash("sha256");
   let bytes = 0;
   for await (const chunk of createReadStream(filePath)) {
+    throwIfOfflineSyncAborted(signal);
     const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
     hash.update(buffer);
     bytes += buffer.length;
   }
+  throwIfOfflineSyncAborted(signal);
   return {
     sha256: hash.digest("hex"),
     bytes,
@@ -600,15 +615,19 @@ export async function* iterateOfflineSyncSnapshotFileRecords(options: {
   includeTranscripts?: boolean;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): AsyncIterable<OfflineSyncFileRecord> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "iterateOfflineSyncSnapshotFileRecords", "root");
   const includeTranscripts = options.includeTranscripts !== false;
 
   async function* walk(dirAbs: string): AsyncIterable<OfflineSyncFileRecord> {
+    throwIfOfflineSyncAborted(options.signal);
     let entries = await readdir(dirAbs, { withFileTypes: true });
     entries = entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
+      throwIfOfflineSyncAborted(options.signal);
       const abs = path.join(dirAbs, entry.name);
       const relPosix = path.relative(root.abs, abs).split(path.sep).join("/");
       if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
@@ -625,6 +644,7 @@ export async function* iterateOfflineSyncSnapshotFileRecords(options: {
         includeContent: options.includeContent === true,
         readFile: options.readFile,
         readFileDigest: options.readFileDigest,
+        signal: options.signal,
       });
     }
   }
@@ -640,10 +660,13 @@ export async function buildOfflineSyncSnapshot(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const includeTranscripts = options.includeTranscripts !== false;
   const files: OfflineSyncFileRecord[] = [];
   for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -665,7 +688,9 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshotFromBase", "root");
   const includeTranscripts = options.includeTranscripts !== false;
@@ -680,9 +705,11 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   const files: OfflineSyncFileRecord[] = [];
 
   async function walk(dirAbs: string): Promise<void> {
+    throwIfOfflineSyncAborted(options.signal);
     let entries = await readdir(dirAbs, { withFileTypes: true });
     entries = entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
+      throwIfOfflineSyncAborted(options.signal);
       const abs = path.join(dirAbs, entry.name);
       const relPosix = path.relative(root.abs, abs).split(path.sep).join("/");
       if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
@@ -698,7 +725,7 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
         options.includeContent !== true &&
         baseEntry &&
         baseCapturedAtMs !== null &&
-        await canReuseFastBaseFileStateFromDisk(baseEntry, abs, st, baseCapturedAtMs)
+        await canReuseFastBaseFileStateFromDisk(baseEntry, st, baseCapturedAtMs)
       ) {
         files.push(baseEntry);
         continue;
@@ -710,11 +737,13 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
         includeContent: options.includeContent === true,
         readFile: options.readFile,
         readFileDigest: options.readFileDigest,
+        signal: options.signal,
       }));
     }
   }
 
   await walk(root.abs);
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -735,7 +764,9 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshotForPaths", "root");
   const includeTranscripts = options.includeTranscripts !== false;
@@ -743,6 +774,7 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   const seen = new Set<string>();
 
   for (const rawPath of options.paths) {
+    throwIfOfflineSyncAborted(options.signal);
     const relPath = normalizeRelativePath(rawPath, "paths[]");
     if (seen.has(relPath)) continue;
     seen.add(relPath);
@@ -762,8 +794,10 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
       includeContent: options.includeContent === true,
       readFile: options.readFile,
       readFileDigest: options.readFileDigest,
+      signal: options.signal,
     }));
   }
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,

package/src/onboarding/index.test.ts

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { onboard } from "./index.js";
+
+test("onboard normalizes trailing separators before root-level shape detection", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-library-"));
+  try {
+    await writeFile(
+      path.join(projectDir, "package.json"),
+      JSON.stringify({ name: "library", exports: "./index.js" }),
+      "utf8",
+    );
+    await writeFile(path.join(projectDir, "README.md"), "# Library\n", "utf8");
+
+    const result = onboard({ directory: `${projectDir}${path.sep}` });
+
+    assert.equal(result.directory, projectDir);
+    assert.equal(result.shape, "library");
+    assert.deepEqual(result.shapeEvidence, ["package.json has exports/main"]);
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("onboard resolves relative directory input before returning docs", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-relative-"));
+  try {
+    await writeFile(path.join(projectDir, "README.md"), "# Relative\n", "utf8");
+    const relativeDir = path.relative(process.cwd(), projectDir);
+
+    const result = onboard({ directory: relativeDir });
+
+    assert.equal(result.directory, path.resolve(relativeDir));
+    assert.equal(result.docs.length, 1);
+    assert.equal(path.isAbsolute(result.docs[0]!.path), true);
+    assert.equal(result.docs[0]!.path, path.join(projectDir, "README.md"));
+    assert.equal(result.docs[0]!.relativePath, "README.md");
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("onboard does not treat package.json alone as TypeScript or JavaScript", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-package-only-"));
+  try {
+    await writeFile(path.join(projectDir, "package.json"), JSON.stringify({ name: "pkg" }), "utf8");
+
+    const result = onboard({ directory: projectDir });
+
+    assert.deepEqual(result.languages.map((entry) => entry.language), []);
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("onboard detects JavaScript from source files without adding TypeScript from package.json", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-js-"));
+  try {
+    await writeFile(path.join(projectDir, "package.json"), JSON.stringify({ name: "pkg" }), "utf8");
+    await writeFile(path.join(projectDir, "index.js"), "export const value = 1;\n", "utf8");
+
+    const result = onboard({ directory: projectDir });
+
+    assert.deepEqual(result.languages.map((entry) => entry.language), ["JavaScript"]);
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("onboard detects TypeScript from TypeScript-specific evidence", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-ts-"));
+  try {
+    await writeFile(path.join(projectDir, "package.json"), JSON.stringify({ name: "pkg" }), "utf8");
+    await writeFile(path.join(projectDir, "index.ts"), "export const value: number = 1;\n", "utf8");
+
+    const result = onboard({ directory: projectDir });
+
+    assert.deepEqual(result.languages.map((entry) => entry.language), ["TypeScript"]);
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});
+
+test("onboard rejects missing and file-backed scan roots", async () => {
+  const projectDir = await mkdtemp(path.join(os.tmpdir(), "remnic-onboard-invalid-root-"));
+  try {
+    assert.throws(
+      () => onboard({ directory: path.join(projectDir, "missing") }),
+      /Cannot scan onboarding directory/,
+    );
+
+    const filePath = path.join(projectDir, "README.md");
+    await writeFile(filePath, "# Not a directory\n", "utf8");
+    assert.throws(
+      () => onboard({ directory: filePath }),
+      /not a directory/,
+    );
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+});

package/src/onboarding/index.ts

@@ -12,7 +12,7 @@ import path from "node:path";
 
 export interface OnboardOptions {
   /** Directory to scan (defaults to cwd) */
-  directory: string;
+  directory?: string;
   /** Max depth to walk (default: 6) */
   maxDepth?: number;
   /** Directories to skip */
@@ -84,13 +84,13 @@ const LANGUAGE_RULES: LanguageRule[] = [
   {
     language: "TypeScript",
     extensions: [".ts", ".tsx"],
-    manifests: ["package.json"],
+    manifests: [],
     configFiles: ["tsconfig.json", "tsup.config.ts"],
   },
   {
     language: "JavaScript",
     extensions: [".js", ".jsx", ".mjs", ".cjs"],
-    manifests: ["package.json"],
+    manifests: [],
     configFiles: [".eslintrc", ".prettierrc"],
   },
   {
@@ -182,10 +182,19 @@ const DEFAULT_EXCLUDE = new Set([
 export function onboard(options: OnboardOptions): OnboardResult {
   const startTime = Date.now();
   const {
-    directory,
     maxDepth = 6,
     excludeDirs = [],
   } = options;
+  const directory = path.resolve(options.directory ?? process.cwd());
+  let rootStat: fs.Stats;
+  try {
+    rootStat = fs.statSync(directory);
+  } catch (err) {
+    throw new Error(`Cannot scan onboarding directory ${directory}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!rootStat.isDirectory()) {
+    throw new Error(`Cannot scan onboarding directory ${directory}: not a directory`);
+  }
 
   const exclude = new Set([...DEFAULT_EXCLUDE, ...excludeDirs]);
 
@@ -230,7 +239,10 @@ function walkDir(
     let entries: fs.Dirent[];
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (depth === 0) {
+        throw new Error(`Cannot scan onboarding directory ${root}: ${err instanceof Error ? err.message : String(err)}`);
+      }
       return;
     }
 

package/src/operator-toolkit.ts

@@ -4,7 +4,7 @@ import { access, mkdir, readFile, readdir, stat, unlink, writeFile } from "node:
 import { lintWorkspaceFiles } from "./hygiene.js";
 import { parseConfig } from "./config.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
-import { resolveRemnicPluginEntry } from "./plugin-id.js";
+import { resolvePluginEntry } from "./plugin-entry-resolver.js";
 import {
   resolveCuratedIncludeFilesStatePath,
   resolveNativeKnowledgeStatePath,
@@ -49,10 +49,48 @@ import type {
 import { reportBufferSurpriseDistribution } from "./buffer-surprise-report.js";
 import { readJudgeVerdictStats } from "./extraction-judge-telemetry.js";
 
+const OPENCLAW_REMNIC_PLUGIN_IDS = ["openclaw-remnic", "openclaw-engram"] as const;
+
+function getOpenClawPluginEntries(raw: Record<string, unknown>): Record<string, unknown> | undefined {
+  const plugins =
+    raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"])
+      ? (raw["plugins"] as Record<string, unknown>)
+      : undefined;
+  const entries =
+    plugins && plugins["entries"] && typeof plugins["entries"] === "object" && !Array.isArray(plugins["entries"])
+      ? (plugins["entries"] as Record<string, unknown>)
+      : undefined;
+  return entries;
+}
+
+function getOpenClawMemorySlotId(raw: Record<string, unknown>): string | undefined {
+  const plugins =
+    raw["plugins"] && typeof raw["plugins"] === "object" && !Array.isArray(raw["plugins"])
+      ? (raw["plugins"] as Record<string, unknown>)
+      : undefined;
+  const slots =
+    plugins && plugins["slots"] && typeof plugins["slots"] === "object" && !Array.isArray(plugins["slots"])
+      ? (plugins["slots"] as Record<string, unknown>)
+      : undefined;
+  const slotId = slots?.["memory"];
+  return typeof slotId === "string" ? slotId : undefined;
+}
+
+function resolveOpenClawRemnicPluginEntry(raw: unknown): Record<string, unknown> | undefined {
+  return resolvePluginEntry(raw, {
+    candidateIds: OPENCLAW_REMNIC_PLUGIN_IDS,
+    getEntries: getOpenClawPluginEntries,
+    getSlotId: getOpenClawMemorySlotId,
+  });
+}
+
 interface QmdRuntimeLike {
   probe(): Promise<boolean>;
   isAvailable(): boolean;
-  ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+  ensureCollection(
+    memoryDir: string,
+    execution?: { signal?: AbortSignal },
+  ): Promise<"present" | "missing" | "unknown" | "skipped">;
   debugStatus(): string;
 }
 
@@ -394,9 +432,9 @@ async function loadCliPluginConfig(configPath?: string): Promise<OperatorConfigL
   const resolvedPath = resolveConfigPath(configPath);
   try {
     const raw = JSON.parse(await readFile(resolvedPath, "utf-8")) as Record<string, unknown>;
-    // Delegate slot → PLUGIN_ID → LEGACY_PLUGIN_ID resolution to the shared
-    // helper so all config loaders stay in sync (#403).
-    const entry = resolveRemnicPluginEntry(raw);
+    // Delegate slot → canonical → legacy resolution to the generic helper so
+    // all config loaders stay in sync (#403).
+    const entry = resolveOpenClawRemnicPluginEntry(raw);
     const parsedConfig = parseConfig(
       entry && typeof entry === "object"
         ? ((entry["config"] as Record<string, unknown> | undefined) ?? {})