@remnic/core 9.45.3 → 9.45.4

package/dist/verified-recall.js

@@ -1,43 +1,33 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-OQ5PRDDS.js";
+} from "./chunk-NTOIP2E6.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-ZBJMUXZH.js";
-import "./chunk-E6PNLPGJ.js";
+import "./chunk-FZP32336.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-ENTCVTQR.js";
-import "./chunk-WIPEXG6R.js";
+import "./chunk-SXIMQLGV.js";
+import "./chunk-S2V7RUCL.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-J7VGGECD.js";
-import "./chunk-WUNIWKY4.js";
-import "./chunk-EGGE52UU.js";
-import "./chunk-ZA53AZND.js";
+import "./chunk-DZPFMQZ7.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-WRJVB3C2.js";
-import "./chunk-GCASGYIO.js";
-import "./chunk-7RJUVTVF.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-JYIJNNN3.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-RVLJEII5.js";
-import "./chunk-S5SLVSVY.js";
+import "./chunk-SYUBB3WM.js";
 import "./chunk-CGASUJVP.js";
 import "./chunk-R3DJVOSM.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-3CSX3ETE.js";
-import "./chunk-RL6NEVXT.js";
 import "./chunk-YXZG5TVN.js";
-import "./chunk-W5H6ZRPT.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-DLVPUX7U.js";
+import "./chunk-7YKVM5H3.js";
 import "./chunk-IJ7HK452.js";
 import "./chunk-PDJTHRAW.js";
-import "./chunk-4J7G5SY4.js";
+import "./chunk-NZBZ7IS2.js";
 import "./chunk-DNHVPZOD.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-FFAZ2XFU.js";
 import "./chunk-XMMESCPD.js";
 import "./chunk-42JKGUFJ.js";
 import "./chunk-C23BYTJV.js";
@@ -46,21 +36,32 @@ import "./chunk-L2EXJQJP.js";
 import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
-import "./chunk-5I4M26Q7.js";
-import "./chunk-ZIKENA2C.js";
+import "./chunk-QBSFOKY6.js";
 import "./chunk-5GKPFL3S.js";
+import "./chunk-ZIKENA2C.js";
 import "./chunk-PQVCH2AE.js";
-import "./chunk-EYIEWJNI.js";
-import "./chunk-JUC24CTX.js";
 import "./chunk-6MKAMLQL.js";
 import "./chunk-JAKIDQB2.js";
+import "./chunk-ZBJMUXZH.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
+import "./chunk-ELIL2A37.js";
+import "./chunk-EGGE52UU.js";
+import "./chunk-ZA53AZND.js";
+import "./chunk-7RJUVTVF.js";
+import "./chunk-GCASGYIO.js";
+import "./chunk-BQIFZ2MP.js";
+import "./chunk-3CSX3ETE.js";
+import "./chunk-RL6NEVXT.js";
+import "./chunk-FFAZ2XFU.js";
+import "./chunk-W5H6ZRPT.js";
 import "./chunk-P7FMDTKL.js";
 import "./chunk-2XRE6FLM.js";
+import "./chunk-EYIEWJNI.js";
+import "./chunk-JUC24CTX.js";
 import "./chunk-FF4KLI5W.js";
-import "./chunk-5TFP4CUL.js";
+import "./chunk-XQ3HXAQH.js";
 import "./chunk-A6XUJE5D.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-VS2IYZRU.js";

package/dist/write-envelope.d.ts

@@ -1,7 +1,8 @@
-import { v as MemoryCategory } from './types-rEwubvim.js';
+import { w as MemoryCategory } from './types-yX_FwERf.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
+import './external-wiki-config.js';
 import './types-continuity.js';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.45.3",
+  "version": "9.45.4",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3106,7 +3106,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.45.3"
+    "@remnic/coding-graph": "^9.45.4"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/abort-error.ts

@@ -44,3 +44,20 @@ export function throwIfAborted(
     throw abortError(message);
   }
 }
+
+export function raceAbort<T>(
+  promise: Promise<T>,
+  signal?: AbortSignal,
+  message = "operation aborted",
+): Promise<T> {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(abortError(message));
+  let onAbort: (() => void) | undefined;
+  const aborted = new Promise<never>((_resolve, reject) => {
+    onAbort = () => reject(abortError(message));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return Promise.race([promise, aborted]).finally(() => {
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  });
+}

package/src/access-admin-ops-surface.ts

@@ -850,6 +850,7 @@ export class AccessAdminOpsSurface {
           lineage: memory.lineage,
           sourceMemoryId: memory.sourceMemoryId,
           actor: memory.actor,
+          ...(memory.toolScoped ? { toolScoped: true as const } : {}),
         });
         // #1645: a tombstone-blocked promotion lands pending_review (no active
         // copy in the target). Report it as a failed promotion so the admin

package/src/access-boundary.ts

@@ -37,6 +37,7 @@ import { expandTildePath } from "./utils/path.js";
 export const OPERATION_NAMES = [
   "memory_get",
   "memory_search",
+  "external_wiki_search",
   "memory_store",
   "coding_decision",
   "coding_architecture",

package/src/access-coding-context-resolution.ts

@@ -0,0 +1,42 @@
+import { projectTagProjectId } from "./coding/coding-namespace.js";
+import { resolveGitContext } from "./coding/git-context.js";
+import type { CodingContext } from "./types.js";
+
+export interface InterruptibleCodingScopeInput {
+  cwd?: string;
+  projectTag?: string;
+  abortSignal?: AbortSignal;
+  deadlineMs?: number;
+}
+
+export async function resolveCodingContextFromOptions(
+  options: InterruptibleCodingScopeInput,
+): Promise<CodingContext | null> {
+  if (typeof options.projectTag === "string" && options.projectTag.trim().length > 0) {
+    const projectId = projectTagProjectId(options.projectTag);
+    return { projectId, branch: null, rootPath: projectId, defaultBranch: null };
+  }
+  if (typeof options.cwd !== "string" || options.cwd.trim().length === 0) return null;
+
+  try {
+    const gitContext = await resolveGitContext(options.cwd, {
+      abortSignal: options.abortSignal,
+      deadlineMs: options.deadlineMs,
+    });
+    if (!gitContext) return null;
+    return {
+      projectId: gitContext.projectId,
+      branch: gitContext.branch,
+      rootPath: gitContext.rootPath,
+      defaultBranch: gitContext.defaultBranch,
+    };
+  } catch (error) {
+    if (
+      options.abortSignal?.aborted ||
+      (options.deadlineMs !== undefined && Date.now() >= options.deadlineMs)
+    ) {
+      throw error;
+    }
+    return null;
+  }
+}

package/src/access-extraction-force-flush.ts

@@ -5,6 +5,7 @@ import {
   type EngramAccessExtractionForceFlushRequest,
   type EngramAccessExtractionForceFlushResponse,
   EngramAccessInputError,
+  type MemoryScopePlan,
 } from "./access-service.js";
 import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { log } from "./logger.js";
@@ -58,9 +59,44 @@ export async function extractionForceFlush(
   };
   let abortHandler: (() => void) | undefined;
 
+  const reservationScopeHint = pendingObserveScopeHint(request);
+  const cancelBeforeScopeResolution = (): void => {
+    const explicitNamespace = request.namespace?.trim();
+    if (explicitNamespace) {
+      deps.cancelPendingObserveExtractions?.(
+        request.sessionKey,
+        authenticatedPrincipal ?? sessionPrincipal,
+        explicitNamespace,
+        reservationScopeHint,
+      );
+      return;
+    }
+    if (reservationScopeHint !== undefined) {
+      deps.cancelPendingObservePreparations?.(request.sessionKey, reservationScopeHint);
+      return;
+    }
+    if (!namespacesEnabled) {
+      deps.cancelPendingObserveExtractions?.(request.sessionKey);
+    }
+  };
+
   try {
-    const scope = await deps.resolveMemoryScopePlan(request);
-    const reservationScopeHint = pendingObserveScopeHint(request);
+    let scope: MemoryScopePlan;
+    try {
+      scope = await awaitSessionFlushPhase(
+        () => deps.resolveMemoryScopePlan(request),
+        {
+          abortSignal: request.abortSignal,
+          extractionDeadlineMs: request.deadlineMs,
+          reason: "access_force_flush",
+          deadlineStage: "scope_resolution",
+          onDeadline: cancelBeforeScopeResolution,
+        },
+      );
+    } catch (error) {
+      if (request.abortSignal?.aborted) cancelBeforeScopeResolution();
+      throw error;
+    }
     const cancelScopedPendingObserveExtractions = (): void => {
       deps.cancelPendingObserveExtractions?.(
         request.sessionKey,

package/src/access-http-lcm-compaction.ts

@@ -22,10 +22,13 @@ export interface LcmCompactionFlushHttpOptions {
   respondJson: JsonResponder;
 }
 
-export function respondLcmCompactionCapabilitiesHttp(response: ServerResponse): void {
+export function respondAccessCapabilitiesHttp(response: ServerResponse): void {
   response.statusCode = 200;
   response.setHeader("content-type", "application/json; charset=utf-8");
-  response.end(JSON.stringify({ lcmCompactionFlushBatch: true }, null, 2));
+  response.end(JSON.stringify({
+    lcmCompactionFlushBatch: true,
+    offlineSyncConvergenceComplete: true,
+  }, null, 2));
 }
 
 export interface LcmCompactionFlushRunnerOptions {

package/src/access-http-offline-stream.ts

@@ -0,0 +1,79 @@
+import type { ServerResponse } from "node:http";
+import type { OfflineSyncManifestStreamResponse } from "./access-offline-manifest.js";
+import type { EngramAccessOfflineSyncSnapshotStreamResponse } from "./access-service.js";
+
+async function respondOfflineNdjsonStream(
+  response: ServerResponse,
+  header: unknown,
+  files: AsyncIterable<unknown>,
+  requestId?: string,
+): Promise<void> {
+  response.statusCode = 200;
+  response.setHeader("content-type", "application/x-ndjson; charset=utf-8");
+  response.setHeader("cache-control", "no-store");
+  if (requestId) response.setHeader("x-request-id", requestId);
+  const waitForDrainOrClose = async (): Promise<boolean> => {
+    const { promise, resolve, reject } = Promise.withResolvers<boolean>();
+    const cleanup = () => {
+      response.off("drain", onDrain);
+      response.off("close", onClose);
+      response.off("error", onError);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve(true);
+    };
+    const onClose = () => {
+      cleanup();
+      resolve(false);
+    };
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+    response.once("drain", onDrain);
+    response.once("close", onClose);
+    response.once("error", onError);
+    return promise;
+  };
+  const writeLine = async (payload: unknown): Promise<boolean> => {
+    if (response.destroyed || response.writableEnded) return false;
+    if (response.write(`${JSON.stringify(payload)}\n`)) return true;
+    if (response.destroyed || response.writableEnded) return false;
+    return waitForDrainOrClose();
+  };
+  if (!await writeLine(header)) return;
+  for await (const file of files) {
+    if (!await writeLine({ type: "file", file })) return;
+  }
+  if (!response.destroyed && !response.writableEnded) response.end();
+}
+
+export async function respondOfflineSnapshotStream(
+  response: ServerResponse,
+  snapshot: EngramAccessOfflineSyncSnapshotStreamResponse,
+  requestId?: string,
+): Promise<void> {
+  await respondOfflineNdjsonStream(response, {
+    type: "snapshot",
+    namespace: snapshot.namespace,
+    format: snapshot.format,
+    schemaVersion: snapshot.schemaVersion,
+    createdAt: snapshot.createdAt,
+    sourceId: snapshot.sourceId,
+    includeTranscripts: snapshot.includeTranscripts,
+  }, snapshot.files, requestId);
+}
+
+export async function respondOfflineManifestStream(
+  response: ServerResponse,
+  manifest: OfflineSyncManifestStreamResponse,
+  requestId?: string,
+): Promise<void> {
+  await respondOfflineNdjsonStream(response, {
+    type: "manifest",
+    namespace: manifest.namespace,
+    format: manifest.format,
+    schemaVersion: manifest.schemaVersion,
+  }, manifest.files, requestId);
+}