@remnic/core 9.69.39 → 9.69.41

package/src/orchestrator.ts

@@ -213,6 +213,7 @@ export {
   type RecallInvocationOptions,
   type RecallModeDecision,
 } from "./orchestration/orchestrator-helpers.js";
+export { qmdStartupCollectionChecksWithTimeout } from "./orchestration/startup-collection-checks.js";
 export { filterRecallCandidates } from "./orchestration/generic-recall-paths.js";
 
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
@@ -948,6 +949,11 @@ export class Orchestrator {
       this.deferredInitAbort = null;
     }
   }
+  async disposeSearchBackendIfNeeded(): Promise<void> {
+    await this.namespaceSearchRouter.disableSearchBackends();
+    await (this.qmd as { dispose?: () => void | Promise<void> }).dispose?.();
+  }
+
   /** Track a recall-side write so destroy() can wait for it before teardown. @internal */
   trackRecallBackgroundWrite(promise: Promise<void>, label: string): void {
     trackRecallWrite(this, promise, label);
@@ -958,6 +964,7 @@ export class Orchestrator {
    * commands should call it before returning to let Node exit naturally.
    */
   async destroy(): Promise<void> {
+    this._orchestratorInitCoordinator?.retireStartupEpoch();
     this.abortDeferredInit();
     this.extractionQueueCoordinator.stopAccepting();
     if (this.wearablesAutoSyncHandle) {

package/src/providers/codex-subscription.test.ts

@@ -14,6 +14,7 @@ import {
   CodexSubscriptionConfigError,
   CodexSubscriptionTimeoutError,
   type CodexSubscriptionExecRequest,
+  type CodexSubscriptionExecResult,
   __codexSubscriptionTestHooks,
   createCodexSubscriptionRunner,
   ensureCodexSubscriptionRunnerRegistered,
@@ -781,6 +782,63 @@ test("caller abort reaches the cold login check: no spawn when pre-aborted, wait
   await assert.rejects(fresh, (error: unknown) => error === freshReason);
 });
 
+test("last waiter out aborts the shared login subprocess; earlier leavers do not", async () => {
+  __codexSubscriptionTestHooks.resetLoginStatusCache();
+  let loginCalls = 0;
+  const loginSignals: AbortSignal[] = [];
+  let resolveSecondLogin:
+    | ((value: { status: number | null; stdout: string; stderr: string }) => void)
+    | undefined;
+  const runner = createCodexSubscriptionRunner({
+    env: { HOME: "/home/alice", PATH: "/usr/bin:/bin" },
+    now: () => 0,
+    runLoginStatus: (_executable, _env, _timeoutMs, signal) => {
+      loginCalls++;
+      loginSignals.push(signal!);
+      const pending = Promise.withResolvers<{ status: number | null; stdout: string; stderr: string }>();
+      if (loginCalls === 2) resolveSecondLogin = pending.resolve;
+      signal?.addEventListener("abort", () =>
+        pending.resolve({ status: 1, stdout: "", stderr: "terminated" })
+      );
+      return pending.promise;
+    },
+    runCodexExec: async () => ({ status: 0, stdout: "", stderr: "", outputText: "ok" }),
+  });
+  const call = (signal?: AbortSignal) =>
+    runner({
+      config: { executable: "codex-fake" },
+      modelId: "gpt-5.6-luna",
+      messages: [{ role: "user", content: "hi" }],
+      options: { timeoutMs: 60_000, ...(signal ? { signal } : {}) },
+    });
+
+  const a = new AbortController();
+  const b = new AbortController();
+  const aReason = new Error("A left first");
+  const bReason = new Error("B left last");
+  const first = call(a.signal);
+  await flushLoop();
+  assert.equal(loginCalls, 1);
+  const second = call(b.signal);
+  await flushLoop();
+  assert.equal(loginCalls, 1, "second caller shares the in-flight check");
+
+  a.abort(aReason);
+  await assert.rejects(first, (error: unknown) => error === aReason);
+  assert.equal(loginSignals[0].aborted, false, "one waiter leaving must not cancel the shared check");
+
+  b.abort(bReason);
+  await assert.rejects(second, (error: unknown) => error === bReason);
+  await flushLoop();
+  assert.ok(loginSignals[0].aborted, "the last waiter leaving aborts the login subprocess");
+
+  // The aborted entry is dropped: the next caller starts a fresh check.
+  const fresh = call();
+  await flushLoop();
+  assert.equal(loginCalls, 2);
+  resolveSecondLogin?.({ status: 0, stdout: "Logged in using ChatGPT\n", stderr: "" });
+  assert.equal((await fresh).content, "ok");
+});
 test("codex-subscription apiKey and SecretRef are rejected before secret resolution", { concurrency: false }, async () => {
   clearModelsJsonCache();
   clearSecretCache();
@@ -1184,6 +1242,75 @@ test(
   }
 );
 
+test(
+  "typed provider timeout still wins when the provider settles just past the outer deadline",
+  { concurrency: false },
+  async () => {
+    clearModelsJsonCache();
+    clearSecretCache();
+    __codexSubscriptionTestHooks.resetLoginStatusCache();
+    __codexSubscriptionTestHooks.resetCoreRunnerRegistered();
+    const runner = createCodexSubscriptionRunner({
+      env: { HOME: "/home/alice", PATH: "/usr/bin:/bin" },
+      now: () => 0,
+      runLoginStatus: async () => ({ status: 0, stdout: "Logged in using ChatGPT\n", stderr: "" }),
+      // Real timer by design: the deadline race is wall-clock behavior. The
+      // exec "child" ignores the abort signal (like one already mid-close)
+      // and settles 35ms after its own 475ms budget — past the caller's
+      // 500ms deadline but inside the 25ms settle grace (T=500 -> 25 headroom).
+      runCodexExec: (request) => {
+        const execTimeoutMs = request.timeoutMs;
+        if (execTimeoutMs === undefined) {
+          throw new Error("expected timeoutMs");
+        }
+        const { promise, resolve } = Promise.withResolvers<CodexSubscriptionExecResult>();
+        setTimeout(
+          () =>
+            resolve({
+              status: 124,
+              stdout: "",
+              stderr: `codex-subscription: exec timed out after ${execTimeoutMs}ms.\n`,
+              outputText: "",
+            }),
+          execTimeoutMs + 35,
+        );
+        return promise;
+      },
+    });
+    const restore = setCodexCliFallbackRunnerForProcess(runner);
+    try {
+      const llm = new FallbackLlmClient({
+        agents: { defaults: { model: { primary: `${CODEX_SUBSCRIPTION_PROVIDER_ID}/gpt-5.6-luna` } } },
+        models: {
+          providers: {
+            [CODEX_SUBSCRIPTION_PROVIDER_ID]: {
+              baseUrl: "codex-cli://subscription",
+              api: "codex-cli",
+              models: [],
+            },
+          },
+        },
+      });
+      const startedAt = Date.now();
+      await assert.rejects(
+        llm.chatCompletion([{ role: "user", content: "hi" }], { timeoutMs: 500 }),
+        (error: unknown) => {
+          assert.ok(error instanceof CodexSubscriptionTimeoutError, `expected timeout, got: ${error}`);
+          assert.equal(error.name, "TimeoutError");
+          return true;
+        }
+      );
+      assert.ok(
+        Date.now() - startedAt < 1_400,
+        "typed timeout must surface within the settle grace, not wait for the provider forever"
+      );
+    } finally {
+      restore();
+      clearModelsJsonCache();
+      clearSecretCache();
+    }
+  }
+);
 test("concurrent callers share one in-flight login when auth.json already exists", async () => {
   __codexSubscriptionTestHooks.resetLoginStatusCache();
   const home = await mkdtemp(path.join(os.tmpdir(), "remnic-codex-home-"));

package/src/providers/codex-subscription.ts

@@ -284,7 +284,6 @@ export function isDefaultRegisteredCodexSubscriptionRunner(): boolean {
   return defaultRegisteredRunner !== undefined
     && getCodexCliFallbackRunnerForProcess() === defaultRegisteredRunner;
 }
-
 /** Host shutdown hook: terminate this runtime's detached Codex children. Does not exit. */
 export function terminateActiveCodexSubscriptionChildren(
   signal: NodeJS.Signals = "SIGTERM",
@@ -491,6 +490,7 @@ async function assertSubscriptionLogin(
       await waitForLoginEntry(cached, cacheKey, ctx, now);
       return;
     }
+
   }
   loginStatusCache.delete(cacheKey);
   if (ctx.signal?.aborted) {

package/src/qmd.ts

@@ -1274,8 +1274,10 @@ export class QmdClient implements SearchBackend {
     return env;
   }
 
-  async probe(): Promise<boolean> {
-    const cliOk = await this.probeCli();
+  async probe(execution?: SearchExecutionOptions): Promise<boolean> {
+    if (execution?.signal?.aborted) return false;
+    const cliOk = await this.probeCli({ signal: execution?.signal });
+    if (execution?.signal?.aborted) return false;
     if (this.daemonEnabled) {
       await this.probeDaemon();
     }
@@ -1386,14 +1388,15 @@ export class QmdClient implements SearchBackend {
       qmdPath: string,
       source: typeof this.qmdPathSource
     ): Promise<void> => {
+      if (options.signal?.aborted) return;
       this.available = true;
       this.qmdPath = qmdPath;
       this.qmdPathSource = source;
       this.cliVersion = parseQmdVersionOutput(result.stdout, result.stderr);
       this.qmdCapabilities = resolveQmdCapabilities(this.cliVersion);
       this.lastCliProbeError = null;
-      if (options.allowAutoUpgrade !== false) {
-        await this.maybeAutoUpgradeQmd();
+      if (options.allowAutoUpgrade !== false && !options.signal?.aborted) {
+        await this.maybeAutoUpgradeQmd(options.signal);
       }
     };
 
@@ -1485,8 +1488,8 @@ export class QmdClient implements SearchBackend {
     }
   }
 
-  private async maybeAutoUpgradeQmd(): Promise<void> {
-    if (!this.qmdAutoUpgradeEnabled) return;
+  private async maybeAutoUpgradeQmd(signal?: AbortSignal): Promise<void> {
+    if (signal?.aborted || !this.qmdAutoUpgradeEnabled) return;
     const state = getGlobalQmdState();
     const targetKey = this.autoUpgradeTargetKey();
     const now = Date.now();
@@ -1522,13 +1525,16 @@ export class QmdClient implements SearchBackend {
       return;
     }
 
+    if (signal?.aborted) return;
     const packageSpec = `${QMD_PACKAGE_NAME}@${this.qmdSupportedVersion}`;
     try {
       log.warn(
         `QMD auto-upgrade: installed=${qmdVersionToString(installed)} supported=${qmdVersionToString(supported)}; running npm install -g ${packageSpec}`
       );
-      await runProcessCommand("npm", ["install", "-g", packageSpec], QMD_AUTO_UPGRADE_TIMEOUT_MS);
-      const postInstall = await this.probePostInstallQmdVersion(supported);
+      await runProcessCommand("npm", ["install", "-g", packageSpec], QMD_AUTO_UPGRADE_TIMEOUT_MS, signal);
+      if (signal?.aborted) return;
+      const postInstall = await this.probePostInstallQmdVersion(supported, signal);
+      if (signal?.aborted) return;
       this.qmdPath = postInstall.qmdPath;
       this.qmdPathSource = postInstall.source;
       this.cliVersion = postInstall.version;
@@ -1551,13 +1557,17 @@ export class QmdClient implements SearchBackend {
         `upgraded: installed=${this.cliVersion ?? "unknown"} target=${this.qmdSupportedVersion}`
       );
     } catch (err) {
+      if (signal?.aborted) return;
       const msg = err instanceof Error ? err.message : String(err);
       recordAutoUpgradeStatus(state, targetKey, `failed: ${msg}`);
       log.warn(`QMD auto-upgrade failed: ${msg}`);
     }
   }
 
-  private async probePostInstallQmdVersion(supported: QmdVersionTuple): Promise<{
+  private async probePostInstallQmdVersion(
+    supported: QmdVersionTuple,
+    signal?: AbortSignal,
+  ): Promise<{
     qmdPath: string;
     source: "auto-path" | "auto-fallback";
     version: string | null;
@@ -1565,12 +1575,13 @@ export class QmdClient implements SearchBackend {
     let lastErr: unknown;
     let lastResult: { qmdPath: string; source: "auto-path" | "auto-fallback"; version: string | null } | null = null;
     for (const candidate of getQmdPostInstallProbeTargets(this.qmdPath, this.qmdPathSource)) {
+      if (signal?.aborted) throw new Error("QMD auto-upgrade post-install probe aborted");
       try {
         const result = await runQmd(
           ["--version"],
           QMD_PROBE_TIMEOUT_MS,
           candidate.qmdPath,
-          undefined,
+          signal,
           this.qmdRuntimeEnv
         );
         const postInstall = {

package/src/recall-state-view-admission.ts

@@ -12,7 +12,17 @@ import { applyRecallStateViews } from "./recall-state-view-wire.js";
 import { shouldFilterSupersededFromRecall } from "./temporal-supersession.js";
 import type { MemoryFile } from "./types.js";
 
-/** Config flag OR per-call override, gated on change intent; computed once for all branches. */
+/**
+ * Config flag OR per-call override, gated on change intent; computed once
+ * for all branches.
+ *
+ * #2893: `query` MUST be the ORIGINAL prompt, not the cron-normalized
+ * retrievalQuery — buildRecallQueryPolicy truncates standard prompts at
+ * maxChars and strips stop-words ("when", "before", "after") from
+ * instruction-heavy ones, either of which can erase the change-intent
+ * signal before retrieval. Only the resulting boolean flows downstream;
+ * retrieval itself keeps using the normalized query.
+ */
 export function resolveRecallStateViewActive(
   options: { stateView?: boolean },
   config: { recallStateViews?: boolean },