@remnic/core 9.30.1 → 9.31.0

package/src/correction/correction-planner.test.ts

@@ -12,7 +12,7 @@
  */
 
 import { strict as assert } from "node:assert";
-import { readFile } from "node:fs/promises";
+import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { test } from "node:test";
 
@@ -157,6 +157,40 @@ test("search-located plan: no targetIds → search runs and top hits become cand
   });
 });
 
+test("aborted planning does not persist a pending plan", async () => {
+  await withTempDir(async (dir) => {
+    const abortController = new AbortController();
+    const state: StubState = {
+      candidatesById: new Map([
+        ["mem-a", makeCandidate({ memoryId: "mem-a", content: "PostgreSQL" })],
+      ]),
+      llmResult: () => {
+        abortController.abort();
+        return {
+          classification: "outdated",
+          confidence: 0.9,
+          actions: [{ kind: "retract", memoryId: "mem-a" }],
+          relevance: [{ memoryId: "mem-a", why: "directly contradicted" }],
+          warnings: [],
+        };
+      },
+      writeReplacementCalls: 0,
+      propagateCalls: 0,
+      retireCalls: 0,
+    };
+    const planner = new CorrectionPlanner(makeDeps(dir, state));
+
+    await assert.rejects(
+      planner.plan({ text: "PostgreSQL" }, ["default"], { abortSignal: abortController.signal }),
+      /correction planning aborted/,
+    );
+    await assert.rejects(
+      readdir(path.join(dir, "state", "corrections", "pending")),
+      /ENOENT/,
+    );
+  });
+});
+
 test("not-found target → explicit error (rule 34)", async () => {
   await withTempDir(async (dir) => {
     const state: StubState = {

package/src/correction/correction-planner.ts

@@ -20,6 +20,7 @@
  * only thing it persists is the plan document itself.
  */
 
+import { throwIfAborted } from "../abort-error.js";
 import { mkdir, readFile, rename, unlink, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { serializeMutations } from "../utils/serialize-mutations.js";
@@ -150,7 +151,10 @@ export class CorrectionPlanner {
   async plan(
     request: CorrectionRequest,
     readableNamespaces: readonly string[],
+    opts?: { abortSignal?: AbortSignal },
   ): Promise<CorrectionPlan> {
+    const abortSignal = opts?.abortSignal;
+    throwIfAborted(abortSignal, "correction planning aborted");
     const cleaned = validateCorrectionRequest(request);
     if (cleaned.text.length > CORRECTION_TEXT_MAX) {
       // Defensive double-check; validateCorrectionRequest already throws.
@@ -171,13 +175,15 @@ export class CorrectionPlanner {
     }
 
     // 1. LOCATE
-    const located = await this.locateCandidates(cleaned, namespaces);
+    const located = await this.locateCandidates(cleaned, namespaces, abortSignal);
+    throwIfAborted(abortSignal, "correction planning aborted");
     if (located.candidates.length === 0) {
       // No candidates AND no explicit targets → empty plan is valid (the user
       // can still discard). But explicit-target-not-found was already raised
       // inside locateCandidates (rule 34).
       return this.persist(
         this.emptyPlan(cleaned, namespaces[0], "no matching memories found for the correction text"),
+        abortSignal,
       );
     }
 
@@ -186,6 +192,7 @@ export class CorrectionPlanner {
       text: cleaned.text,
       candidates: located.candidates,
     });
+    throwIfAborted(abortSignal, "correction planning aborted");
 
     // Validate every action shape before persisting — the adapter is trusted
     // to validate, but a malformed action must never reach the executor
@@ -245,6 +252,7 @@ export class CorrectionPlanner {
     const diff = llm.fallback
       ? ""
       : await this.deps.renderDiff({ candidates: located.candidates, actions: llm.actions });
+    throwIfAborted(abortSignal, "correction planning aborted");
 
     const createdAt = this.deps.now().toISOString();
     const expiresAt = new Date(
@@ -275,18 +283,21 @@ export class CorrectionPlanner {
           status: "pending",
         };
 
-    return this.persist(plan);
+    throwIfAborted(abortSignal, "correction planning aborted");
+    return this.persist(plan, abortSignal);
   }
 
   private async locateCandidates(
     request: CorrectionRequest,
     namespaces: readonly string[],
+    abortSignal?: AbortSignal,
   ): Promise<{ candidates: PlannerCandidate[] }> {
     if (request.targetIds && request.targetIds.length > 0) {
       const targets = await this.deps.resolveTargets({
         targetIds: request.targetIds,
         namespaces,
       });
+      throwIfAborted(abortSignal, "correction planning aborted");
       // Expand 1-hop neighbors and merge (dedup by memoryId, keep highest score).
       const seedIds = targets.map((c) => c.memoryId);
       const neighbors = await this.deps.expandNeighbors({
@@ -294,6 +305,7 @@ export class CorrectionPlanner {
         namespaces,
         limit: this.deps.maxAffected,
       });
+      throwIfAborted(abortSignal, "correction planning aborted");
       return { candidates: mergeCandidates(targets, neighbors).slice(0, this.deps.maxAffected) };
     }
 
@@ -302,6 +314,7 @@ export class CorrectionPlanner {
       namespaces,
       limit: this.deps.maxAffected,
     });
+    throwIfAborted(abortSignal, "correction planning aborted");
     if (searched.length === 0) return { candidates: [] };
     const seedIds = searched.slice(0, Math.min(5, searched.length)).map((c) => c.memoryId);
     const neighbors = await this.deps.expandNeighbors({
@@ -309,6 +322,7 @@ export class CorrectionPlanner {
       namespaces,
       limit: this.deps.maxAffected,
     });
+    throwIfAborted(abortSignal, "correction planning aborted");
     return { candidates: mergeCandidates(searched, neighbors).slice(0, this.deps.maxAffected) };
   }
 
@@ -386,8 +400,13 @@ export class CorrectionPlanner {
     return path.join(await this.deps.storageDir(namespace), "state", "corrections", "pending");
   }
 
-  private async persist(plan: CorrectionPlan): Promise<CorrectionPlan> {
+  private async persist(
+    plan: CorrectionPlan,
+    abortSignal?: AbortSignal,
+  ): Promise<CorrectionPlan> {
+    throwIfAborted(abortSignal, "correction planning aborted");
     const dir = await this.pendingDir(plan.namespace);
+    throwIfAborted(abortSignal, "correction planning aborted");
     const target = path.join(dir, `${plan.planId}.json`);
     // #1678 (thread Oid8t): never-store/redaction corrections carry the very
     // secret/pattern the user asked Remnic NOT to retain. The durable audit
@@ -411,9 +430,12 @@ export class CorrectionPlanner {
       ? { ...plan, request: { ...plan.request, text: REDACTED_REQUEST_TEXT } }
       : plan;
     await serializeMutations(`correction-plan:${target}`, async () => {
+      throwIfAborted(abortSignal, "correction planning aborted");
       await mkdir(dir, { recursive: true });
       const tmp = `${target}.${process.pid}.${Date.now().toString(36)}.tmp`;
+      throwIfAborted(abortSignal, "correction planning aborted");
       await writeFile(tmp, `${JSON.stringify(persistedPlan)}\n`, "utf-8");
+      throwIfAborted(abortSignal, "correction planning aborted");
       // rename() is atomic on POSIX for same-filesystem renames (rule 54).
       await rename(tmp, target);
     });
@@ -503,6 +525,31 @@ export class CorrectionPlanner {
       await rename(tmp, file);
     });
   }
+  /**
+   * Return an applying plan to the pending queue when cancellation arrives
+   * before its first correction mutation.
+   */
+  async resetApplying(namespace: string, planId: string): Promise<void> {
+    assertSafePlanId(planId);
+    const file = path.join(await this.pendingDir(namespace), `${planId}.json`);
+    await serializeMutations(`correction-plan:${file}`, async () => {
+      let raw: string;
+      try {
+        raw = await readFile(file, "utf-8");
+      } catch (err) {
+        const code = (err as NodeJS.ErrnoException)?.code;
+        if (code === "ENOENT") return;
+        throw err;
+      }
+      const plan = parsePlan(raw);
+      if (!plan || plan.status !== "applying") return;
+      plan.status = "pending";
+      delete plan.applyingAt;
+      const tmp = `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
+      await writeFile(tmp, `${JSON.stringify(plan)}\n`, "utf-8");
+      await rename(tmp, file);
+    });
+  }
 
   async deletePlan(namespace: string, planId: string): Promise<void> {
     assertSafePlanId(planId);

package/src/correction/correction-service.ts

@@ -13,6 +13,7 @@
  * WRITE — both resolved through the injected namespace policy.
  */
 
+import { throwIfAborted } from "../abort-error.js";
 import {
   CorrectionContractError,
   type CorrectionOutcome,
@@ -105,16 +106,16 @@ export class CorrectionService {
    * the principal can write, so reading from a non-writable namespace to
    * draft a correction that can never be applied would be misleading.
    */
-  async plan(request: CorrectionRequest): Promise<CorrectionPlan> {
+  async plan(
+    request: CorrectionRequest,
+    opts?: { abortSignal?: AbortSignal },
+  ): Promise<CorrectionPlan> {
     this.requireEnabled();
+    throwIfAborted(opts?.abortSignal, "correction planning aborted");
     const authorized = await this.deps.policy.resolveAuthorizedNamespace(request);
-    return this.planner.plan(request, [authorized]);
+    throwIfAborted(opts?.abortSignal, "correction planning aborted");
+    return this.planner.plan(request, [authorized], opts);
   }
-
-  /**
-   * Apply a persisted plan by id. Requires `confirm: true` (or interactive
-   * yes at the CLI) when `applyRequiresConfirm` is on (default).
-   */
   async apply(
     planId: string,
     opts: {
@@ -122,9 +123,11 @@ export class CorrectionService {
       namespace?: string;
       sessionKey?: string;
       principal?: string;
+      abortSignal?: AbortSignal;
     },
   ): Promise<CorrectionOutcome> {
     this.requireEnabled();
+    throwIfAborted(opts.abortSignal, "correction apply aborted");
     if (this.deps.applyRequiresConfirm() && opts.confirm !== true) {
       throw new CorrectionContractError(
         "Correction apply requires explicit confirmation (pass `confirm: true`).",
@@ -135,8 +138,10 @@ export class CorrectionService {
       ...(opts.sessionKey ? { sessionKey: opts.sessionKey } : {}),
       ...(opts.principal ? { principal: opts.principal } : {}),
     });
+    throwIfAborted(opts.abortSignal, "correction apply aborted");
     return this.executor.apply(namespace, planId, {
       confirm: true,
+      abortSignal: opts.abortSignal,
       // Authorize rescope destinations through the namespace policy bound to
       // THIS caller's principal (review thread: authorize-rescope-destination).
       canWriteDestination: (dest) =>

package/src/correction/correction-storage-integration.test.ts

@@ -12,6 +12,7 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import type { MemoryFile } from "../types.js";
 
 import { StorageManager, ContentHashIndex } from "../storage.js";
 import { sanitizeMemoryContent } from "../sanitize.js";
@@ -19,8 +20,10 @@ import {
   isEligibleCorrectionCandidate,
   applyEditMemory,
   appendTombstoneFn,
+  retireMemoryFn,
+  rescopeMemoryFn,
+  writeReplacementMemory,
 } from "./correction-access-wiring.js";
-import type { MemoryFile } from "../types.js";
 
 async function makeStorage(prefix = "remnic-corr-wiring-") {
   StorageManager.clearAllStaticCaches();
@@ -121,6 +124,174 @@ test("#1672 item 3: applyEditMemory leaves non-fact contentHash untouched (only
   }
 });
 
+test("#2128 edit returns its committed id after cancellation", async () => {
+  const { storage, cleanup } = await makeStorage("remnic-corr-edit-abort-");
+  try {
+    const { id } = await storage.writeMemory("fact", "the database is MySQL", { source: "test" });
+    const originalWriteFrontmatter = storage.writeMemoryFrontmatter.bind(storage);
+    const abortController = new AbortController();
+    let committed = false;
+    (storage as any).writeMemoryFrontmatter = async (...args: any[]) => {
+      const result = await (originalWriteFrontmatter as (...inner: any[]) => Promise<unknown>)(...args);
+      committed = true;
+      abortController.abort(new Error("caller disconnected"));
+      return result;
+    };
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+
+    const editedId = await applyEditMemory(
+      wiring,
+      "default",
+      id,
+      "the database is PostgreSQL",
+      abortController.signal,
+    );
+
+    assert.equal(committed, true);
+    assert.equal(editedId, id);
+    assert.equal((await storage.getMemoryById(id))?.content, "the database is PostgreSQL");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#2128 retirement completes after cancellation during the durable write", async () => {
+  const { storage, cleanup } = await makeStorage("remnic-corr-retire-abort-");
+  try {
+    const { id } = await storage.writeMemory("fact", "the database is MySQL", { source: "test" });
+    const originalWriteFrontmatter = storage.writeMemoryFrontmatter.bind(storage);
+    const abortController = new AbortController();
+    let committed = false;
+    (storage as any).writeMemoryFrontmatter = async (...args: any[]) => {
+      const result = await (originalWriteFrontmatter as (...inner: any[]) => Promise<unknown>)(...args);
+      committed = true;
+      abortController.abort(new Error("caller disconnected"));
+      return result;
+    };
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+
+    await retireMemoryFn(
+      wiring,
+      "default",
+      id,
+      { status: "retracted" },
+      abortController.signal,
+    );
+
+    assert.equal(committed, true);
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.status, "forgotten");
+  } finally {
+    await cleanup();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Rescope cancellation transaction
+// ---------------------------------------------------------------------------
+
+test("#2128 rescope retires the source when cancellation lands after destination write", async () => {
+  const source = await makeStorage("remnic-corr-rescope-source-");
+  const destination = await makeStorage("remnic-corr-rescope-dest-");
+  try {
+    const { id: sourceId } = await source.storage.writeMemory("fact", "the database is MySQL", {
+      source: "test",
+    });
+    const abortController = new AbortController();
+    const originalWriteSealedMemory = destination.storage.writeSealedMemory.bind(destination.storage);
+    let destinationWriteCompleted = false;
+    (destination.storage as any).writeSealedMemory = async (...args: any[]) => {
+      const result = await (originalWriteSealedMemory as (...args: any[]) => Promise<unknown>)(...args);
+      destinationWriteCompleted = true;
+      abortController.abort(new Error("caller disconnected"));
+      return result;
+    };
+    const wiring = {
+      orchestrator: {
+        getStorage: async (namespace: string) =>
+          namespace === "source" ? source.storage : destination.storage,
+      },
+    } as any;
+
+    const destinationId = await rescopeMemoryFn(
+      wiring,
+      "source",
+      sourceId,
+      "destination",
+      abortController.signal,
+    );
+
+    assert.equal(destinationWriteCompleted, true);
+    const archivedSource = await source.storage.getMemoryById(sourceId);
+    const activeDestination = await destination.storage.getMemoryById(destinationId);
+    assert.equal(archivedSource?.frontmatter.status, "archived");
+    assert.equal(activeDestination?.frontmatter.status, "active");
+  } finally {
+    await source.cleanup();
+    await destination.cleanup();
+  }
+});
+
+test("#2128 replacement write returns its committed id after cancellation", async () => {
+  const { storage, cleanup } = await makeStorage("remnic-corr-replacement-");
+  try {
+    const originalWriteSealedMemory = storage.writeSealedMemory.bind(storage);
+    const abortController = new AbortController();
+    let committed = false;
+    (storage as any).writeSealedMemory = async (...args: any[]) => {
+      const result = await (originalWriteSealedMemory as (...inner: any[]) => Promise<unknown>)(...args);
+      committed = true;
+      abortController.abort(new Error("caller disconnected"));
+      return result;
+    };
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+
+    const id = await writeReplacementMemory(
+      wiring,
+      "default",
+      { content: "the database is PostgreSQL", supersedes: "source-id" },
+      abortController.signal,
+    );
+
+    assert.equal(committed, true);
+    assert.equal(typeof id, "string");
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.status, "active");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("#2128 tombstone append returns its committed id after cancellation", async () => {
+  const { storage, cleanup } = await makeStorage("remnic-corr-tombstone-abort-");
+  try {
+    const originalAppendTombstone = storage.appendTombstone.bind(storage);
+    const abortController = new AbortController();
+    let committed = false;
+    (storage as any).appendTombstone = async (...args: any[]) => {
+      const result = await (originalAppendTombstone as (...inner: any[]) => Promise<string | null>)(...args);
+      committed = true;
+      abortController.abort(new Error("caller disconnected"));
+      return result;
+    };
+    const wiring = { orchestrator: { getStorage: async () => storage } } as any;
+
+    const id = await appendTombstoneFn(
+      wiring,
+      "default",
+      {
+        reason: "retraction",
+        sourceMemoryId: "source-id",
+        rawContent: "the database is PostgreSQL",
+      },
+      abortController.signal,
+    );
+
+    assert.equal(committed, true);
+    assert.equal(typeof id, "string");
+  } finally {
+    await cleanup();
+  }
+});
+
 // ---------------------------------------------------------------------------
 // item 4: per-key tombstone emission
 // ---------------------------------------------------------------------------

package/src/correction/passive-capture.test.ts

@@ -181,6 +181,41 @@ test("auto mode: applies when all guards pass", async () => {
   assert.deepStrictEqual(appliedPlans, ["corr-test-001"]);
 });
 
+test("passive capture forwards its cancellation signal to plan and apply", async () => {
+  const abortController = new AbortController();
+  const plan = makePlan({ confidence: 0.9, classification: "outdated" });
+  let plannedSignal: AbortSignal | undefined;
+  let appliedSignal: AbortSignal | undefined;
+  const deps: PassiveCaptureDeps = {
+    planCorrection: async (_request, opts) => {
+      plannedSignal = opts?.abortSignal;
+      return plan;
+    },
+    applyCorrection: async (_planId, opts) => {
+      appliedSignal = opts.abortSignal;
+      return {
+        planId: plan.planId,
+        status: "applied",
+        results: [{ action: plan.actions[0]!, status: "applied" }],
+        auditMemoryId: "audit-001",
+        appliedAt: new Date().toISOString(),
+      };
+    },
+    storageDir: async () => "/tmp/test-passive-capture",
+  };
+
+  await capturePassiveCorrections(
+    [makeCorrection()],
+    { ...LIVE_CTX, abortSignal: abortController.signal },
+    AUTO_CONFIG,
+    deps,
+    new Set<string>(),
+  );
+
+  assert.equal(plannedSignal, abortController.signal);
+  assert.equal(appliedSignal, abortController.signal);
+});
+
 test("auto mode: suppressed — confidence below floor → queued", async () => {
   const appliedPlans: string[] = [];
   const plan = makePlan({ confidence: 0.5 });

package/src/correction/passive-capture.ts

@@ -64,6 +64,8 @@ export interface PassiveCaptureContext {
   principal?: string;
   /** Authorized namespace the extraction wrote to. */
   namespace: string;
+  /** Shared extraction deadline/cancellation signal. */
+  abortSignal?: AbortSignal;
 }
 
 // ---------------------------------------------------------------------------
@@ -72,11 +74,20 @@ export interface PassiveCaptureContext {
 
 export interface PassiveCaptureDeps {
   /** Plan a correction through the Correction Contract. */
-  planCorrection(request: CorrectionRequest): Promise<CorrectionPlan>;
+  planCorrection(
+    request: CorrectionRequest,
+    opts?: { abortSignal?: AbortSignal },
+  ): Promise<CorrectionPlan>;
   /** Apply a planned correction (auto mode only). */
   applyCorrection(
     planId: string,
-    opts: { confirm: true; namespace?: string; sessionKey?: string; principal?: string },
+    opts: {
+      confirm: true;
+      namespace?: string;
+      sessionKey?: string;
+      principal?: string;
+      abortSignal?: AbortSignal;
+    },
   ): Promise<CorrectionOutcome>;
   /** Resolve the storage dir for notification enqueue (per namespace). */
   storageDir(namespace: string): Promise<string>;
@@ -207,6 +218,7 @@ export async function capturePassiveCorrections(
   telemetry.detected = corrections.length;
 
   for (const correction of corrections) {
+    if (ctx.abortSignal?.aborted) return { telemetry, plans };
     // 1. Dedup — checked before planning, but the fingerprint is only
     //    recorded AFTER a successful plan so a transient planning failure
     //    can be retried on a later flush (review: "dedup blocks retry
@@ -243,13 +255,14 @@ export async function capturePassiveCorrections(
 
     let plan: CorrectionPlan;
     try {
-      plan = await deps.planCorrection(request);
+      plan = await deps.planCorrection(request, { abortSignal: ctx.abortSignal });
     } catch (err) {
       log.warn(
         `passive-correction: planning failed for "${correction.targetHint.slice(0, 60)}": ${err instanceof Error ? err.message : String(err)}`,
       );
       continue;
     }
+    if (ctx.abortSignal?.aborted) return { telemetry, plans };
     plans.push(plan);
     // Record the fingerprint only after a successful plan.
     dedupState.add(fp);
@@ -276,6 +289,7 @@ export async function capturePassiveCorrections(
         namespace: ctx.namespace,
         ...(ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {}),
         ...(ctx.principal ? { principal: ctx.principal } : {}),
+        abortSignal: ctx.abortSignal,
       });
       // A partial outcome means some actions failed (per-action races or
       // storage failures). Don't count it as auto-applied or notify — queue

package/src/extraction-source-grounding.ts

@@ -1,4 +1,5 @@
-import type { ExtractionResult } from "./types.js";
+import type { ExtractionResult, ProvenanceConfig } from "./types.js";
+import { buildFactProvenance, type ProvenanceTurnInput } from "./provenance.js";
 import { delinearize } from "./delinearize.js";
 import {
   applyExtractionSourceGrounding as applyGroundingRules,
@@ -39,6 +40,59 @@ export function applyExtractionSourceGrounding(
   );
 }
 
+/**
+ * Attach claim-level provenance spans to each fact after extraction has
+ * completed. The validator never throws or drops a fact: an unverifiable
+ * quote remains a tagged state. When provenance is disabled, transient
+ * model-provided quotes are stripped before the result leaves extraction.
+ */
+export function attachExtractionProvenance(
+  result: ExtractionResult,
+  turns: ReadonlyArray<{
+    content: string;
+    sessionKey?: string;
+    logicalSessionKey?: string;
+    timestamp: string;
+    turnFingerprint?: string;
+  }>,
+  provenanceConfig: ProvenanceConfig,
+): ExtractionResult {
+  if (!provenanceConfig.enabled) {
+    if (result.facts.length === 0) return result;
+    return {
+      ...result,
+      facts: result.facts.map((fact) => {
+        if (fact.quote === undefined) return fact;
+        const { quote: _stripped, ...rest } = fact;
+        return rest;
+      }),
+    };
+  }
+  if (result.facts.length === 0) return result;
+  const provenanceTurns: ProvenanceTurnInput[] = turns.map((turn) => ({
+    content: turn.content,
+    sessionKey: turn.sessionKey,
+    logicalSessionKey: turn.logicalSessionKey,
+    timestamp: turn.timestamp,
+    turnId: turn.turnFingerprint,
+  }));
+  const facts = result.facts.map((fact) => {
+    const built = buildFactProvenance(
+      fact.quote,
+      provenanceTurns,
+      provenanceConfig,
+    );
+    const { quote: _stripped, ...factWithoutQuote } = fact;
+    return {
+      ...factWithoutQuote,
+      ...(built.sources && built.sources.length > 0 ? { sources: built.sources } : {}),
+      ...(built.provenance !== "none" ? { provenance: built.provenance } : {}),
+      ...(built.requireSpansPending ? { requireSpansPending: true } : {}),
+    };
+  });
+  return { ...result, facts };
+}
+
 export function filterExtractionResultBySource(
   result: ExtractionResult,
   source: string,

package/src/extraction-timeout.test.ts

@@ -268,3 +268,54 @@ test("extraction keeps action transcripts with durable memory cues", async () =>
 
   assert.equal(fallbackCalls, 1);
 });
+
+test("gateway extraction forwards caller cancellation to the provider", async () => {
+  const config = parseConfig({
+    modelSource: "gateway",
+    gatewayConfig: {
+      agents: {
+        defaults: { model: { primary: "bench-internal/gpt-5.5" } },
+        list: [],
+      },
+      models: {
+        providers: {
+          "bench-internal": {
+            api: "codex-cli",
+            baseUrl: "codex-cli://local",
+            models: [{ id: "gpt-5.5", name: "gpt-5.5" }],
+          },
+        },
+      },
+    },
+  });
+  const engine = new ExtractionEngine(config);
+  const controller = new AbortController();
+  let capturedSignal: AbortSignal | undefined;
+  (engine as unknown as {
+    fallbackLlm: {
+      parseWithSchemaDetailed(
+        messages: unknown,
+        schema: unknown,
+        options: { signal?: AbortSignal },
+      ): Promise<unknown>;
+    };
+  }).fallbackLlm = {
+    async parseWithSchemaDetailed(_messages, _schema, options) {
+      capturedSignal = options.signal;
+      await new Promise<never>((_resolve, reject) => {
+        options.signal?.addEventListener("abort", () => reject(options.signal?.reason), { once: true });
+      });
+      return null;
+    },
+  };
+
+  const extraction = engine.extract(
+    [{ role: "user", content: "Remember this cancellation test.", timestamp: "2026-05-08T00:00:00.000Z" }],
+    undefined,
+    controller.signal,
+  );
+  await new Promise<void>((resolve) => queueMicrotask(resolve));
+  assert.equal(capturedSignal, controller.signal);
+  controller.abort(new Error("deadline"));
+  await assert.rejects(extraction, /deadline/);
+});