@remnic/core 9.45.3 → 9.45.5

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

@@ -39,8 +39,8 @@ function extractToolNames(response: unknown): Set<string> {
 }
 
 interface MockCalls {
-  planRequests: Array<{ text: string; targetIds?: string[]; principal?: string }>;
-  applyRequests: Array<{ planId: string; confirm: boolean; principal?: string }>;
+  planRequests: Array<{ text: string; targetIds?: string[]; principal?: string; abortSignal?: AbortSignal }>;
+  applyRequests: Array<{ planId: string; confirm: boolean; principal?: string; abortSignal?: AbortSignal }>;
 }
 
 function makeMockService(
@@ -50,22 +50,26 @@ function makeMockService(
   const calls: MockCalls = { planRequests: [], applyRequests: [] };
   const service = {
     briefingEnabled: true,
-    correctionPlan(req: {
-      text: string;
-      targetIds?: string[];
-      principal?: string;
-    }): Promise<CorrectionPlan> {
-      calls.planRequests.push(req);
+    correctionPlan(
+      req: {
+        text: string;
+        targetIds?: string[];
+        principal?: string;
+      },
+      opts?: { abortSignal?: AbortSignal },
+    ): Promise<CorrectionPlan> {
+      calls.planRequests.push({ ...req, ...(opts?.abortSignal ? { abortSignal: opts.abortSignal } : {}) });
       return Promise.resolve(planResponse);
     },
     correctionApply(
       planId: string,
-      opts: { confirm?: boolean; principal?: string },
+      opts: { confirm?: boolean; principal?: string; abortSignal?: AbortSignal },
     ): Promise<CorrectionOutcome> {
       calls.applyRequests.push({
         planId,
         confirm: opts.confirm === true,
         ...(opts.principal ? { principal: opts.principal } : {}),
+        ...(opts.abortSignal ? { abortSignal: opts.abortSignal } : {}),
       });
       return Promise.resolve(applyResponse);
     },
@@ -130,22 +134,26 @@ test("tools/list gate: correction tools present when correctionVisible on (defau
 // MCP dispatch: tools/call → boundary operation → service method
 // ---------------------------------------------------------------------------
 
-test("MCP surface: memory_correct_plan dispatches to service.correctionPlan", async () => {
+test("MCP surface: memory_correct_plan forwards the request abort signal", async () => {
   const { service, calls } = makeMockService(STUB_PLAN, STUB_OUTCOME);
   const server = new EngramMcpServer(service, { emitLegacyTools: true, correctionVisible: true });
-  const response = await server.handleRequest({
-    jsonrpc: "2.0",
-    id: 1,
-    method: "tools/call",
-    params: {
-      name: "engram.memory_correct_plan",
-      arguments: { text: "we migrated to MySQL in March", targetIds: ["mem-1"] },
+  const abortController = new AbortController();
+  const response = await server.handleRequest(
+    {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "tools/call",
+      params: {
+        name: "engram.memory_correct_plan",
+        arguments: { text: "we migrated to MySQL in March", targetIds: ["mem-1"] },
+      },
     },
-  });
+    { abortSignal: abortController.signal },
+  );
   assert.equal(calls.planRequests.length, 1, "service.correctionPlan called exactly once");
   assert.equal(calls.planRequests[0]?.text, "we migrated to MySQL in March");
   assert.deepEqual(calls.planRequests[0]?.targetIds, ["mem-1"]);
-  // The response result is the plan returned by the service.
+  assert.equal(calls.planRequests[0]?.abortSignal, abortController.signal);
   assert.equal(
     typeof response === "object" && response !== null && "result" in response,
     true,
@@ -153,21 +161,26 @@ test("MCP surface: memory_correct_plan dispatches to service.correctionPlan", as
   );
 });
 
-test("MCP surface: memory_correct_apply dispatches to service.correctionApply with confirm", async () => {
+test("MCP surface: memory_correct_apply forwards confirmation and the request abort signal", async () => {
   const { service, calls } = makeMockService(STUB_PLAN, STUB_OUTCOME);
   const server = new EngramMcpServer(service, { emitLegacyTools: true, correctionVisible: true });
-  await server.handleRequest({
-    jsonrpc: "2.0",
-    id: 2,
-    method: "tools/call",
-    params: {
-      name: "engram.memory_correct_apply",
-      arguments: { planId: "corr-test-1", confirm: true },
+  const abortController = new AbortController();
+  await server.handleRequest(
+    {
+      jsonrpc: "2.0",
+      id: 2,
+      method: "tools/call",
+      params: {
+        name: "engram.memory_correct_apply",
+        arguments: { planId: "corr-test-1", confirm: true },
+      },
     },
-  });
+    { abortSignal: abortController.signal },
+  );
   assert.equal(calls.applyRequests.length, 1, "service.correctionApply called exactly once");
   assert.equal(calls.applyRequests[0]?.planId, "corr-test-1");
   assert.equal(calls.applyRequests[0]?.confirm, true);
+  assert.equal(calls.applyRequests[0]?.abortSignal, abortController.signal);
 });
 
 test("MCP surface: remnic.memory_correct_plan alias dispatches identically", async () => {

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

@@ -165,6 +165,65 @@ test("dedup: different bufferKey → both processed", async () => {
   assert.strictEqual(dedup.size, 2);
 });
 
+test("#2206 dedup records a plan that commits as cancellation arrives", async () => {
+  const plan = makePlan();
+  const abortController = new AbortController();
+  let planningCalls = 0;
+  const deps = mockDeps(plan);
+  deps.planCorrection = async () => {
+    planningCalls += 1;
+    abortController.abort(new Error("extraction deadline exceeded"));
+    return plan;
+  };
+  const dedup = new Set<string>();
+  const correction = makeCorrection();
+
+  const first = await capturePassiveCorrections(
+    [correction],
+    { ...LIVE_CTX, abortSignal: abortController.signal },
+    QUEUE_CONFIG,
+    deps,
+    dedup,
+  );
+  const second = await capturePassiveCorrections(
+    [correction],
+    LIVE_CTX,
+    QUEUE_CONFIG,
+    deps,
+    dedup,
+  );
+
+  assert.deepEqual(first.plans.map((candidate) => candidate.planId), [plan.planId]);
+  assert.equal(first.telemetry.queued, 1, "the committed pending plan must count as queued");
+  assert.equal(dedup.size, 1);
+  assert.equal(second.telemetry.queued, 0);
+  assert.equal(planningCalls, 1);
+});
+
+test("#2206 auto mode counts a plan left pending when cancellation lands at commit", async () => {
+  const plan = makePlan({ confidence: 0.9, classification: "outdated" });
+  const abortController = new AbortController();
+  const appliedPlans: string[] = [];
+  const deps = mockDeps(plan, { appliedPlans });
+  deps.planCorrection = async () => {
+    abortController.abort(new Error("extraction deadline exceeded"));
+    return plan;
+  };
+
+  const result = await capturePassiveCorrections(
+    [makeCorrection()],
+    { ...LIVE_CTX, abortSignal: abortController.signal },
+    AUTO_CONFIG,
+    deps,
+    new Set<string>(),
+  );
+
+  assert.equal(abortController.signal.aborted, true, "cancellation must land as planning commits");
+  assert.deepEqual(result.plans.map((candidate) => candidate.planId), [plan.planId]);
+  assert.equal(result.telemetry.queued, 1);
+  assert.deepEqual(appliedPlans, []);
+});
+
 // ---------------------------------------------------------------------------
 // Auto mode + guards
 // ---------------------------------------------------------------------------

package/src/correction/passive-capture.ts

@@ -262,10 +262,13 @@ export async function capturePassiveCorrections(
       );
       continue;
     }
-    if (ctx.abortSignal?.aborted) return { telemetry, plans };
     plans.push(plan);
     // Record the fingerprint only after a successful plan.
     dedupState.add(fp);
+    if (ctx.abortSignal?.aborted) {
+      telemetry.queued += 1;
+      return { telemetry, plans };
+    }
 
     // 3. Dispatch by mode
     if (config.mode === "queue") {

package/src/entity-retrieval-boundaries.ts

@@ -64,6 +64,19 @@ function isIntlWordBoundary(source: string, index: number): boolean {
   return UNICODE_WORD_SEGMENTER?.segment(source).containing(index)?.index === index;
 }
 
+function isStandaloneJapaneseLeadingParticle(
+  particle: string,
+  source: string,
+  boundaryIndex: number,
+): boolean {
+  if (!JAPANESE_WORD_SEGMENTER || boundaryIndex <= 0 || !JAPANESE_PARTICLE_RE.test(particle)) {
+    return false;
+  }
+  const particleStart = boundaryIndex - particle.length;
+  const segment = JAPANESE_WORD_SEGMENTER.segment(source).containing(particleStart);
+  return segment?.index === particleStart
+    && segment.index + segment.segment.length === boundaryIndex;
+}
 function isKoreanUnspacedQuestionBoundary(suffix: string): boolean {
   return KOREAN_UNSPACED_QUESTION_PARTICLES.some((particle) =>
     suffix.startsWith(particle) &&
@@ -91,18 +104,15 @@ function isUnicodePhraseBoundary(
   source: string = "",
   boundaryIndex: number = -1,
   strictUnicode = false,
-  allowLeadingParticle = false,
 ): boolean {
   return (
     character.length === 0
     || !UNICODE_WORD_OR_NUMBER_RE.test(character)
-    || (allowLeadingParticle && isJapaneseParticleBoundary(character))
     || isJapaneseParticleBoundary(suffix)
     || (!strictUnicode &&
       boundaryIndex >= 0 &&
       !JAPANESE_KANA_RE.test(suffix) &&
       isIntlWordBoundary(source, boundaryIndex))
-    || (allowLeadingParticle && isKoreanParticleBoundary(character))
     || isKoreanParticleBoundary(suffix)
   );
 }
@@ -117,7 +127,10 @@ export function containsPhrase(haystack: string, needle: string): boolean {
     const before = lastUnicodeCharacter(searchHaystack.slice(0, offset));
     const after = searchHaystack.slice(offset + searchNeedle.length);
     if (
-      isUnicodePhraseBoundary(before, "", searchHaystack, offset, caseInsensitive, true)
+      (
+        isUnicodePhraseBoundary(before, "", searchHaystack, offset, caseInsensitive)
+        || isStandaloneJapaneseLeadingParticle(before, searchHaystack, offset)
+      )
       && isUnicodePhraseBoundary(
         firstUnicodeCharacter(after),
         after,

package/src/entity-retrieval.ts

@@ -403,23 +403,37 @@ async function readCurrentPersistedEntityIndex(
 const namespaceEntityIndexCache = new Map<string, EntityMentionIndex>();
 const MAX_NAMESPACE_ENTITY_INDEX_CACHE_ENTRIES = 32;
 
+function nativeEntityIndexRevision(chunks: NativeKnowledgeChunk[]): string {
+  const projection = chunks.map((chunk) => [
+    chunk.chunkId,
+    chunk.sourcePath,
+    chunk.title,
+    chunk.sourceKind,
+    uniqueStrings(chunk.aliases ?? []),
+    compactLine(chunk.content, 180),
+    chunk.derivedDate ?? null,
+  ]);
+  return createHash("sha256").update(JSON.stringify(projection)).digest("hex");
+}
+
 function namespaceEntityIndexCacheKey(
   storages: StorageManager[],
   recallNamespaces: string[],
+  nativeRevision: string,
 ): string {
-  const namespaceKey = uniqueStrings(recallNamespaces).sort().join("\u001f");
+  const namespaceKey = uniqueStrings(recallNamespaces).join("\u001f");
   const storageKey = storages
     .map((scopedStorage) => {
       const aliases = Object.entries(scopedStorage.entityAliases)
         .sort(([left], [right]) => left.localeCompare(right));
       return (
         `${path.resolve(scopedStorage.dir)}@${scopedStorage.getMemoryStatusVersion()}` +
-        `:${scopedStorage.getMemoryCorpusVersion()}:${scopedStorage.hotCacheKeyId()}:${JSON.stringify(aliases)}`
+        `:${scopedStorage.getMemoryCorpusVersion()}:${scopedStorage.getEntityMutationVersion()}` +
+        `:${scopedStorage.hotCacheKeyId()}:${JSON.stringify(aliases)}`
       );
     })
-    .sort()
     .join("\u001f");
-  return `${namespaceKey}\u001e${storageKey}`;
+  return `${namespaceKey}\u001e${storageKey}\u001e${nativeRevision}`;
 }
 
 function rememberNamespaceEntityIndex(key: string, index: EntityMentionIndex): void {
@@ -1030,6 +1044,9 @@ export async function buildEntityRecallSection(options: BuildEntityRecallSection
     resolveNamespaceCapabilities(options.config).namespaces &&
     options.namespaceStorage !== undefined &&
     (options.recallNamespaces?.length ?? 0) > 0;
+  if (namespaceScoped) {
+    nativeChunks = await readNativeChunks(options.config, options.recallNamespaces);
+  }
   const resolvedStorages = namespaceScoped
     ? await resolveEntityIndexStorages(
       options.storage,
@@ -1039,8 +1056,12 @@ export async function buildEntityRecallSection(options: BuildEntityRecallSection
     )
     : undefined;
   const namespaceCacheKey =
-    resolvedStorages && options.recallNamespaces
-      ? namespaceEntityIndexCacheKey(resolvedStorages, options.recallNamespaces)
+    resolvedStorages && options.recallNamespaces && nativeChunks
+      ? namespaceEntityIndexCacheKey(
+        resolvedStorages,
+        options.recallNamespaces,
+        nativeEntityIndexRevision(nativeChunks),
+      )
       : undefined;
   let index: EntityMentionIndex | undefined = namespaceCacheKey
     ? namespaceEntityIndexCache.get(namespaceCacheKey)

package/src/external-wiki-access.test.ts

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import type { EngramAccessService } from "./access-service.js";
+import { externalWikiSearchOperation } from "./external-wiki-access.js";
+import type { ExternalWikiRoot } from "./external-wiki.js";
+
+async function fixtureRoot(): Promise<ExternalWikiRoot> {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "remnic-external-wiki-access-"));
+  await mkdir(path.join(rootDir, "wiki"), { recursive: true });
+  await writeFile(
+    path.join(rootDir, "INDEX.md"),
+    "- [[wiki/planning|Planning Systems]] - deterministic planner fan-out\n",
+    "utf8"
+  );
+  await writeFile(
+    path.join(rootDir, "wiki", "planning.md"),
+    "# Planning Systems\n\nDeterministic planner fan-out keeps cited evidence.\n",
+    "utf8"
+  );
+  return {
+    id: "planning",
+    rootDir,
+    enabled: true,
+    pagesDir: "wiki",
+    indexFile: "INDEX.md",
+    indexInQmd: false,
+    includeInDefaultRecall: false,
+  };
+}
+
+test("external wiki operation searches roots from the service config", async () => {
+  const root = await fixtureRoot();
+  try {
+    const service = { configRef: { externalWikis: [root] } } as EngramAccessService;
+    const output = await externalWikiSearchOperation.run(
+      { query: "deterministic planner", limit: 2, maxCharsPerHit: 200 },
+      { service }
+    );
+    assert.equal(output.result.hits[0]?.wikiId, "planning");
+    assert.equal(output.result.hits[0]?.path, "wiki/planning.md");
+  } finally {
+    await rm(root.rootDir, { recursive: true, force: true });
+  }
+});
+
+test("external wiki operation rejects empty query and unknown fields", async () => {
+  let configRead = false;
+  const service = {
+    get configRef() {
+      configRead = true;
+      return { externalWikis: [] };
+    },
+  } as unknown as EngramAccessService;
+
+  await assert.rejects(externalWikiSearchOperation.run({ query: "  " }, { service }), /query is required/i);
+  await assert.rejects(
+    externalWikiSearchOperation.run({ query: "topic", unexpected: true }, { service }),
+    /unrecognized key/i
+  );
+  assert.equal(configRead, false);
+});

package/src/external-wiki-access.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+import { defineOperation } from "./access-boundary.js";
+import {
+  type ExternalWikiSearchInput,
+  type ExternalWikiSearchResult,
+  searchExternalWikis,
+} from "./external-wiki-search.js";
+
+const externalWikiSearchSchema = z
+  .object({
+    query: z.string().trim().min(1, "query is required").max(2_048),
+    limit: z.number().int().min(1).max(20).optional(),
+    wikiId: z.string().trim().min(1).max(256).optional(),
+    maxCharsPerHit: z.number().int().min(1).max(8_000).optional(),
+  })
+  .strict();
+
+export interface ExternalWikiSearchOutput {
+  readonly result: ExternalWikiSearchResult;
+}
+
+export const externalWikiSearchOperation = defineOperation<ExternalWikiSearchInput, ExternalWikiSearchOutput>({
+  name: "external_wiki_search",
+  description: "Search configured external compiled-wiki roots and return cited snippets.",
+  schema: externalWikiSearchSchema,
+  fleetWide: true,
+  handler: async (input, ctx) => ({
+    result: await searchExternalWikis(ctx.service.configRef.externalWikis, input),
+  }),
+});

package/src/external-wiki-cli.ts

@@ -0,0 +1,100 @@
+import { type ExternalWikiRoot, type ExternalWikiSearchResult, searchExternalWikis } from "./external-wiki-search.js";
+
+interface ExternalWikiCliIo {
+  readonly stdout: { write(chunk: string): unknown };
+  readonly stderr: { write(chunk: string): unknown };
+}
+
+const USAGE =
+  "Usage: remnic external-wiki search <query...> [--wiki-id <id>] [--limit <1-20>] [--max-chars-per-hit <100-8000>] [--json]\n";
+
+export async function runExternalWikiCliCommand(
+  roots: readonly ExternalWikiRoot[],
+  args: readonly string[],
+  io: ExternalWikiCliIo
+): Promise<number> {
+  if (args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+    io.stdout.write(USAGE);
+    return 0;
+  }
+  const searchArgs = args[0] === "search" ? args.slice(1) : args;
+
+  let limit: number | undefined;
+  let wikiId: string | undefined;
+  let maxCharsPerHit: number | undefined;
+  let json = false;
+  const queryParts: string[] = [];
+  for (let index = 0; index < searchArgs.length; index += 1) {
+    const argument = searchArgs[index];
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--limit" || argument === "--wiki-id" || argument === "--max-chars-per-hit") {
+      const value = searchArgs[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        io.stderr.write(`external-wiki: ${argument} requires a value\n`);
+        return 2;
+      }
+      index += 1;
+      if (argument === "--wiki-id") {
+        wikiId = value.trim();
+        if (wikiId.length === 0) {
+          io.stderr.write("external-wiki: --wiki-id must not be empty\n");
+          return 2;
+        }
+        continue;
+      }
+      const parsed = Number(value);
+      const maximum = argument === "--limit" ? 20 : 8_000;
+      const minimum = argument === "--limit" ? 1 : 100;
+      if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) {
+        io.stderr.write(`external-wiki: ${argument} must be an integer from ${minimum} to ${maximum}\n`);
+        return 2;
+      }
+      if (argument === "--limit") limit = parsed;
+      else maxCharsPerHit = parsed;
+      continue;
+    }
+    if (argument.startsWith("-")) {
+      io.stderr.write(`external-wiki: unknown option '${argument}'\n${USAGE}`);
+      return 2;
+    }
+    queryParts.push(argument);
+  }
+
+  const query = queryParts.join(" ").trim();
+  if (query.length === 0) {
+    io.stderr.write("external-wiki: provide a search query\n");
+    return 1;
+  }
+  const enabled = roots.filter((root) => root.enabled !== false);
+  if (enabled.length === 0) {
+    io.stderr.write("external-wiki: no enabled wiki roots configured\n");
+    return 1;
+  }
+
+  let result: ExternalWikiSearchResult;
+  try {
+    result = await searchExternalWikis(enabled, { query, limit, wikiId, maxCharsPerHit });
+  } catch (error) {
+    io.stderr.write(`external-wiki: ${error instanceof Error ? error.message : "search failed"}\n`);
+    return 1;
+  }
+  if (json) {
+    io.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  }
+
+  if (result.degradedWikiIds.length > 0) {
+    io.stderr.write(`Warning: degraded roots: ${result.degradedWikiIds.join(", ")}\n`);
+  }
+  if (result.hits.length === 0) {
+    io.stdout.write("No results.\n");
+    return 0;
+  }
+  for (const hit of result.hits) {
+    io.stdout.write(`[${hit.wikiId}] ${hit.path} (score ${hit.score})\n${hit.snippet}\n\n`);
+  }
+  return 0;
+}

package/src/external-wiki-collection-registration.test.ts

@@ -0,0 +1,163 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  type ExternalWikiCollectionRefreshTarget,
+  ExternalWikiCollectionRegistrar,
+} from "./external-wiki-collection-registration.js";
+import type { ExternalWikiCollectionRoot } from "./external-wiki-collection.js";
+
+interface TimerFixture {
+  schedule(callback: () => void, intervalMs: number): object;
+  cancel(handle: object): void;
+  callbacks: Array<() => void>;
+  intervals: number[];
+  cancelled: object[];
+}
+
+function makeTimerFixture(): TimerFixture {
+  const callbacks: Array<() => void> = [];
+  const intervals: number[] = [];
+  const cancelled: object[] = [];
+  return {
+    schedule(callback, intervalMs) {
+      callbacks.push(callback);
+      intervals.push(intervalMs);
+      return { callback };
+    },
+    cancel(handle) {
+      cancelled.push(handle);
+    },
+    callbacks,
+    intervals,
+    cancelled,
+  };
+}
+
+const roots: ExternalWikiCollectionRoot[] = [
+  {
+    id: "reading",
+    rootDir: "/tmp/wiki",
+    enabled: true,
+    pagesDir: "wiki",
+    indexInQmd: true,
+  },
+];
+
+test("registrar refreshes at startup and on its documented maintenance interval", async () => {
+  const timers = makeTimerFixture();
+  const calls: ExternalWikiCollectionRoot[][] = [];
+  const target: ExternalWikiCollectionRefreshTarget = {
+    refresh: async (configuredRoots) => {
+      calls.push([...configuredRoots]);
+      return [];
+    },
+  };
+  const registrar = new ExternalWikiCollectionRegistrar({
+    target,
+    getRoots: () => roots,
+    intervalMs: 15 * 60_000,
+    timers,
+  });
+
+  await registrar.register();
+  timers.callbacks[0]?.();
+  await registrar.waitForIdle();
+
+  assert.equal(calls.length, 2);
+  assert.deepEqual(timers.intervals, [15 * 60_000]);
+  await registrar.dispose();
+  assert.equal(timers.cancelled.length, 1);
+});
+
+test("registrar single-flights overlapping maintenance ticks", async () => {
+  const timers = makeTimerFixture();
+  let release!: () => void;
+  const blocked = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let callCount = 0;
+  const target: ExternalWikiCollectionRefreshTarget = {
+    refresh: async () => {
+      callCount += 1;
+      if (callCount > 1) await blocked;
+      return [];
+    },
+  };
+  const registrar = new ExternalWikiCollectionRegistrar({
+    target,
+    getRoots: () => roots,
+    intervalMs: 1000,
+    timers,
+  });
+  await registrar.register();
+
+  timers.callbacks[0]?.();
+  timers.callbacks[0]?.();
+  await Promise.resolve();
+  assert.equal(callCount, 2);
+
+  release();
+  await registrar.waitForIdle();
+  await registrar.dispose();
+});
+
+test("a failed maintenance tick clears singleflight state for the next tick", async () => {
+  const timers = makeTimerFixture();
+  let callCount = 0;
+  const target: ExternalWikiCollectionRefreshTarget = {
+    refresh: async () => {
+      callCount += 1;
+      if (callCount === 2) throw new Error("backend unavailable");
+      return [];
+    },
+  };
+  const registrar = new ExternalWikiCollectionRegistrar({
+    target,
+    getRoots: () => roots,
+    intervalMs: 1000,
+    timers,
+  });
+  await registrar.register();
+
+  timers.callbacks[0]?.();
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  timers.callbacks[0]?.();
+  await registrar.waitForIdle();
+
+  assert.equal(callCount, 3);
+  await registrar.dispose();
+});
+
+test("dispose aborts and drains an in-flight refresh", async () => {
+  const timers = makeTimerFixture();
+  let observedSignal: AbortSignal | undefined;
+  let release!: () => void;
+  const blocked = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  let callCount = 0;
+  const target: ExternalWikiCollectionRefreshTarget = {
+    refresh: async (_configuredRoots, execution) => {
+      callCount += 1;
+      observedSignal = execution?.signal;
+      if (callCount > 1) await blocked;
+      return [];
+    },
+  };
+  const registrar = new ExternalWikiCollectionRegistrar({
+    target,
+    getRoots: () => roots,
+    intervalMs: 1000,
+    timers,
+  });
+  await registrar.register();
+  timers.callbacks[0]?.();
+  await Promise.resolve();
+
+  const disposing = registrar.dispose();
+  assert.equal(observedSignal?.aborted, true);
+  release();
+  await disposing;
+
+  assert.equal(timers.cancelled.length, 1);
+});