@remnic/core 9.63.0 → 9.63.2

package/src/event-order-query.ts

@@ -0,0 +1,78 @@
+import { EVENT_ORDER_CUES, containsRecallCue } from "./recall-planner-i18n.js";
+
+function isTimelineSummaryQuery(normalized: string): boolean {
+  return (
+    /\b(?:summarize|summary|major progress|what happened|develop(?:ed|ment)?|approached)\b/.test(
+      normalized,
+    ) &&
+    (/\b(?:over time|throughout|between|project|progress|timeline|journey|sessions?|along the way)\b/.test(
+      normalized,
+    ) ||
+      /\bfrom\b.+\bthrough\b/.test(normalized))
+  );
+}
+
+export function shouldRecallEventOrderEvidence(query: string): boolean {
+  const normalized = query.toLowerCase();
+
+  if (containsRecallCue(normalized, EVENT_ORDER_CUES)) {
+    return true;
+  }
+
+  if (
+    /\border in which\b/.test(normalized) ||
+    /\bsequence in which\b/.test(normalized) ||
+    /\breconstruct\b.*\btimeline\b/.test(normalized) ||
+    /\btimeline\b.*\bin order\b/.test(normalized) ||
+    /\bsequence\b.*\bin order\b/.test(normalized) ||
+    /\bintroduced\b.*\bin order\b/.test(normalized) ||
+    (/\bwalk me through\b/.test(normalized) && /\bin order\b/.test(normalized)) ||
+    (/\bin order\b/.test(normalized) &&
+      /\b(?:develop(?:ed|ment)?|evolv(?:e|ed|ing)?|progress|throughout|conversations?|sessions?)\b/.test(
+        normalized,
+      )) ||
+    /\bprogress\b.*\bin order\b/.test(normalized) ||
+    /\bchronological(?:ly| order)?\b/.test(normalized) ||
+    isTimelineSummaryQuery(normalized)
+  ) {
+    return true;
+  }
+
+  if (/\bwhich\b.*\bfirst\b/.test(normalized) || /\bwhat was the first\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhappened first\b/.test(normalized) || /\bwhich\b.*\bhappened\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhow many days\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bwhen did\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bwhich\b.*\blast\b/.test(normalized) || /\bthe last\b.*\bi\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bwho\b.*\bfirst\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bmost recent(?:ly)?\b/.test(normalized)) {
+    return true;
+  }
+  if (/\border of\b/.test(normalized) || /\bfrom earliest to latest\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhow long\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhow many (months|weeks|years)\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhow many\b.*\bbefore\b/.test(normalized)) {
+    return true;
+  }
+  if (/\bhow old\b.*\bwhen\b/.test(normalized)) {
+    return true;
+  }
+  return false;
+}

package/src/event-order-recall.ts

@@ -7,6 +7,10 @@ import {
   type RankedEvidenceItem,
 } from "./recall-pipeline-stages.js";
 
+import { shouldRecallEventOrderEvidence } from "./event-order-query.js";
+export { shouldRecallEventOrderEvidence };
+
+
 export interface EventOrderRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
   // event-order reads a SINGLE LCM session key. Unlike the relevance-ranked
@@ -28,87 +32,6 @@ const DEFAULT_SCAN_WINDOW_TURNS = 12;
 const DEFAULT_SCAN_WINDOW_TOKENS = 24_000;
 const DEFAULT_MAX_ITEMS = 24;
 
-export function shouldRecallEventOrderEvidence(query: string): boolean {
-  const normalized = query.toLowerCase();
-
-  // --- Existing event-order patterns (LongMemEval order-reconstruction phrasing) ---
-  if (
-    /\border in which\b/.test(normalized) ||
-    /\bsequence in which\b/.test(normalized) ||
-    /\breconstruct\b.*\btimeline\b/.test(normalized) ||
-    /\btimeline\b.*\bin order\b/.test(normalized) ||
-    /\bsequence\b.*\bin order\b/.test(normalized) ||
-    /\bintroduced\b.*\bin order\b/.test(normalized) ||
-    (/\bwalk me through\b/.test(normalized) && /\bin order\b/.test(normalized)) ||
-    (/\bin order\b/.test(normalized) &&
-      /\b(?:develop(?:ed|ment)?|evolv(?:e|ed|ing)?|progress|throughout|conversations?|sessions?)\b/.test(normalized)) ||
-    /\bprogress\b.*\bin order\b/.test(normalized) ||
-    /\bchronological(?:ly| order)?\b/.test(normalized) ||
-    isTimelineSummaryQuery(normalized)
-  ) {
-    return true;
-  }
-
-  // --- Temporal-reasoning patterns (LongMemEval temporal-reasoning question type) ---
-  // These question shapes need chronological evidence to answer correctly:
-  // ordering ("which happened first"), relative time ("how many days
-  // between"), and recency ("which did I [verb] last"). The event-order tier
-  // surfaces a chronologically sorted evidence pack so the responder can
-  // reconstruct the answer from an ordered timeline rather than fragments.
-  // Verified against the LongMemEval-oracle dataset: 0% of the 133
-  // temporal-reasoning questions matched the original heuristic above.
-
-  // "Which X did I Y first, A or B?" / "What was the first X ...?"
-  if (/\bwhich\b.*\bfirst\b/.test(normalized) || /\bwhat was the first\b/.test(normalized)) {
-    return true;
-  }
-  // "Which event happened first, A or B?" / "Which happened first"
-  if (/\bhappened first\b/.test(normalized) || /\bwhich\b.*\bhappened\b/.test(normalized)) {
-    return true;
-  }
-  // "How many days before/between/after/did it take"
-  if (/\bhow many days\b/.test(normalized)) {
-    return true;
-  }
-  // "When did I ..." (date-shaped)
-  if (/\bwhen did\b/.test(normalized)) {
-    return true;
-  }
-  // "Which X did I Y last?" / "the last X I ..."
-  if (/\bwhich\b.*\blast\b/.test(normalized) || /\bthe last\b.*\bi\b/.test(normalized)) {
-    return true;
-  }
-  // "Who did I meet/become first, X or Y?" (person ordering)
-  if (/\bwho\b.*\bfirst\b/.test(normalized)) {
-    return true;
-  }
-  // "most recently" / "most recent" (recency)
-  if (/\bmost recent(?:ly)?\b/.test(normalized)) {
-    return true;
-  }
-  // "What is the order of..." / "...from earliest to latest"
-  if (/\border of\b/.test(normalized) || /\bfrom earliest to latest\b/.test(normalized)) {
-    return true;
-  }
-
-  // "How long have/did/had I been..." (duration)
-  if (/\bhow long\b/.test(normalized)) {
-    return true;
-  }
-  // "How many months/weeks/years ago/before" (relative time)
-  if (/\bhow many (months|weeks|years)\b/.test(normalized)) {
-    return true;
-  }
-  // "How many X did I [verb] before Y" (temporal comparison)
-  if (/\bhow many\b.*\bbefore\b/.test(normalized)) {
-    return true;
-  }
-  // "How old was I when..." (age-at-time)
-  if (/\bhow old\b.*\bwhen\b/.test(normalized)) {
-    return true;
-  }
-  return false;
-}
 
 export async function buildEventOrderRecallSection(
   options: EventOrderRecallOptions,
@@ -1693,15 +1616,6 @@ function deriveChronologicalCueLabels(content: string, query: string): string[]
   return [...labels].slice(0, 5);
 }
 
-function isTimelineSummaryQuery(normalized: string): boolean {
-  return /\b(?:summarize|summary|major progress|what happened|develop(?:ed|ment)?|approached)\b/.test(
-    normalized,
-  ) &&
-    (/\b(?:over time|throughout|between|project|progress|timeline|journey|sessions?|along the way)\b/.test(
-      normalized,
-    ) ||
-      /\bfrom\b.+\bthrough\b/.test(normalized));
-}
 
 function addLabelIf(
   labels: Set<string>,

package/src/intent.ts

@@ -1,3 +1,11 @@
+import {
+  CAUSAL_CHAIN_CUES,
+  GRAPH_MODE_CUES,
+  containsRecallCue,
+  endsWithQuestionMark,
+  isMultilingualAck,
+  stripTrailingRecallNoise,
+} from "./recall-planner-i18n.js";
 import type { MemoryIntent, RecallPlanMode } from "./types.js";
 
 const GOAL_PATTERNS: Array<{ re: RegExp; goal: string }> = [
@@ -100,35 +108,26 @@ export function intentCompatibilityScore(queryIntent: MemoryIntent, memoryIntent
 
 export function planRecallMode(prompt: string): RecallPlanMode {
   const p = normalizeTextInput(prompt).trim();
-  let ackCandidate = p;
-  while (ackCandidate.length > 0) {
-    const ch = ackCandidate.charCodeAt(ackCandidate.length - 1);
-    const isDigit = ch >= 48 && ch <= 57;
-    const isUpper = ch >= 65 && ch <= 90;
-    const isLower = ch >= 97 && ch <= 122;
-    // Strip any trailing non-alphanumeric noise (punctuation/emojis/symbols).
-    if (isDigit || isUpper || isLower) break;
-    ackCandidate = ackCandidate.slice(0, -1);
-  }
-  ackCandidate = ackCandidate.trim();
   if (p.length === 0) return "no_recall";
 
-  if (/\b(timeline|sequence|history|what happened|chain of events|root cause)\b/i.test(p)) {
+  if (
+    /\b(timeline|sequence|history|what happened|chain of events|root cause)\b/i.test(p) ||
+    containsRecallCue(p, GRAPH_MODE_CUES)
+  ) {
     return "graph_mode";
   }
 
   // Reserve no_recall for low-information acknowledgements; avoid broad regressions.
-  if (
-    p.length <= 18 &&
-    /^(ok|okay|kk|thanks|thx|got it|sounds good|yep|yes|nope|no|done|cool|works)$/i.test(ackCandidate)
-  ) {
+  // Multilingual table (issue #2191): Japanese/Chinese/Korean/Russian/etc acks
+  // route the same way; the exact-match set cannot match longer English prompts.
+  if (p.length <= 18 && isMultilingualAck(stripTrailingRecallNoise(p))) {
     return "no_recall";
   }
 
   // Full recall for prompts that are explicitly memory-seeking or analytical questions.
   if (
     /\b(previous|earlier|remember|last time|did we|what did we decide|context|summarize|summary|recap|key points|decision)\b/i.test(p) ||
-    /\?$/.test(p) ||
+    endsWithQuestionMark(p) ||
     /^(what|why|how|when|where|who|which)\b/i.test(p.toLowerCase())
   ) {
     return "full";
@@ -148,7 +147,8 @@ export function planRecallMode(prompt: string): RecallPlanMode {
 export function hasBroadGraphIntent(prompt: string): boolean {
   const p = normalizeTextInput(prompt).trim().toLowerCase();
   if (!p) return false;
-  return /\b(what changed|how did we get here|why did this happen|what led to|cause chain|dependency chain|regression chain|failure chain)\b/i.test(
-    p,
+  return (
+    /\b(what changed|how did we get here|why did this happen|what led to|cause chain|dependency chain|regression chain|failure chain)\b/i.test(p) ||
+    containsRecallCue(p, CAUSAL_CHAIN_CUES)
   );
 }

package/src/orchestration/turn-ingestion.ts

@@ -123,6 +123,25 @@ export interface TurnIngestionOptions extends SourceConnectorProvenance {
   turnFingerprint?: string;
 }
 
+/**
+ * Flush-plan recovery imports are compacted material the host already
+ * summarized before appending it to the flush-plan file. Feeding those
+ * turns through LCM observation again re-summarizes the same content
+ * (issue #2457). The producer stamps both a dedicated `sourceLabel` and a
+ * `:flush-plan[:chunk]`-shaped `sourceId`, so either marker identifies a
+ * recovery turn; ordinary bulk-import turns never carry either.
+ */
+function isFlushPlanRecoveryTurn(
+  turn: Pick<BufferTurn, "importProvenance">,
+): boolean {
+  const provenance = turn.importProvenance;
+  if (provenance?.sourceLabel === "OpenClaw flush plan") return true;
+  return (
+    typeof provenance?.sourceId === "string" &&
+    /:flush-plan(:\d+\/\d+)?$/.test(provenance.sourceId)
+  );
+}
+
 export class TurnIngestionCoordinator {
   constructor(
     private readonly deps: TurnIngestionDeps,
@@ -456,7 +475,11 @@ export class TurnIngestionCoordinator {
       };
     }
 
-    if (this.deps.lcmEngine?.enabled) {
+    // Skip LCM only when every turn is flush-plan recovery material; a mixed
+    // batch keeps the ordinary observe path (issue #2457). Extraction and
+    // persistence below are unaffected either way.
+    const skipLcmObservation = sessionTurns.every(isFlushPlanRecoveryTurn);
+    if (!skipLcmObservation && this.deps.lcmEngine?.enabled) {
       await this.deps.lcmEngine.observeMessages(
         sessionKey,
         sessionTurns.map((turn) => ({

package/src/orchestrator-flush.test.ts

@@ -12,8 +12,10 @@ import { TurnIngestionCoordinator } from "./orchestration/turn-ingestion.js";
 import { SmartBuffer } from "./buffer.js";
 import { parseConfig } from "./config.js";
 import { stableHash } from "./coding/git-context.js";
-import type { BufferState, BufferTurn } from "./types.js";
+import type { BufferState, BufferTurn, PluginConfig } from "./types.js";
 import type { ImportTurn } from "./bulk-import/types.js";
+import type { LcmEngine } from "./lcm/index.js";
+import type { ExtractionRunResult } from "./orchestration/extraction-run.js";
 import { namespaceIdentityToken } from "./namespaces/identity.js";
 import { readNamespaceMaintenanceStatuses } from "./maintenance/namespace-planner.js";
 import { stubPersistExtraction } from "./testing/orchestrator-lite.js";
@@ -28,6 +30,22 @@ function makeTurn(sessionKey: string, content: string, sessionOwnerPrincipal?: s
   };
 }
 
+/**
+ * Writable orchestrator double for `ingestBulkImportBatch` slice tests: the
+ * real prototype methods run, but the per-test stub surface must stay
+ * assignable (the real class marks these fields readonly).
+ */
+interface BulkImportTestDouble {
+  config: PluginConfig;
+  extractionQueueCoordinator: ExtractionQueueCoordinator;
+  lcmEngine: LcmEngine | null;
+  runExtraction: (
+    turns: BufferTurn[],
+    options?: Record<string, unknown>,
+  ) => Promise<ExtractionRunResult>;
+  ingestBulkImportBatch: Orchestrator["ingestBulkImportBatch"];
+}
+
 interface ScopedFlushTestDouble {
   buffer: {
     getTurns(bufferKey: string): BufferTurn[];
@@ -804,6 +822,129 @@ test("ingestBulkImportBatch can disable source-valid-at replay context", async (
   );
 });
 
+test("ingestBulkImportBatch skips LCM observation for flush-plan recovery batches (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observedSessionKeys: string[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (sessionKey: string) => {
+      observedSessionKeys.push(sessionKey);
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  const extractedSlices: BufferTurn[][] = [];
+  orchestrator.runExtraction = async (turns: BufferTurn[]) => {
+    extractedSlices.push(turns);
+    return { status: "completed", persistedCount: 1, durableOutputCount: 1 };
+  };
+
+  const result = await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Recovery material the host already compacted once.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan",
+      },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Chunked recovery material.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan:2/3",
+      },
+    },
+  ]);
+
+  assert.deepEqual(observedSessionKeys, []);
+  assert.equal(extractedSlices.length, 2);
+  assert.equal(result.extractionCount, 2);
+  assert.equal(result.persistedCount, 2);
+});
+
+test("ingestBulkImportBatch still observes ordinary bulk imports through LCM (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observed: { sessionKey: string; turnCount: number }[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (sessionKey: string, messages: unknown[]) => {
+      observed.push({ sessionKey, turnCount: messages.length });
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  orchestrator.runExtraction = async () => ({
+    status: "completed",
+    persistedCount: 1,
+    durableOutputCount: 1,
+  });
+
+  await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Ordinary chatgpt import turn.",
+      importProvenance: { sourceLabel: "chatgpt", sourceId: "cg-1" },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Ordinary turn without provenance.",
+    },
+  ]);
+
+  assert.deepEqual(
+    observed.map((entry) => entry.turnCount),
+    [2],
+  );
+  assert.ok(observed[0]?.sessionKey.startsWith("bulk-import:batch:"));
+});
+
+test("ingestBulkImportBatch observes mixed batches that contain flush-plan turns (issue #2457)", async () => {
+  const orchestrator = Object.create(Orchestrator.prototype) as unknown as BulkImportTestDouble;
+  orchestrator.config = parseConfig({});
+  orchestrator.extractionQueueCoordinator = new ExtractionQueueCoordinator();
+  const observed: number[] = [];
+  orchestrator.lcmEngine = {
+    enabled: true,
+    observeMessages: async (_sessionKey: string, messages: unknown[]) => {
+      observed.push(messages.length);
+    },
+    // Partial engine double for the observe seam.
+  } as unknown as LcmEngine;
+  orchestrator.runExtraction = async () => ({
+    status: "completed",
+    persistedCount: 1,
+    durableOutputCount: 1,
+  });
+
+  await orchestrator.ingestBulkImportBatch([
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:00.000Z",
+      content: "Recovery material mixed into an ordinary batch.",
+      importProvenance: {
+        sourceLabel: "OpenClaw flush plan",
+        sourceId: "openclaw-remnic:flush-plan",
+      },
+    },
+    {
+      role: "user",
+      timestamp: "2026-06-24T12:00:01.000Z",
+      content: "Ordinary chatgpt import turn.",
+      importProvenance: { sourceLabel: "chatgpt", sourceId: "cg-2" },
+    },
+  ]);
+
+  assert.deepEqual(observed, [2]);
+});
+
 test("ingestBulkImportBatch preserves partial metadata failure before a later slice rejects", async () => {
   const orchestrator = Object.create(Orchestrator.prototype) as any;
   orchestrator.config = parseConfig({});

package/src/qmd-process-group.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { runCommandWithTimeoutForTest } from "./qmd.js";
+
+// Regression for issue #2456: on timeout/abort the bounded qmd subprocess
+// launcher must be killed together with its descendants. The launcher runs
+// detached (own process group) so a negative-pid signal reaches grandchildren
+// the old child.kill("SIGKILL") left behind. POSIX only — Windows falls back
+// to a direct child kill by design.
+//
+// Real timers by design: this suite kills real OS processes, so the timeout
+// trigger and the exit polls run against the platform clock. Fake timers
+// cannot deliver signals to a spawned `sleep`. Every poll awaits a condition
+// (pid file exists, process gone), never a fixed sleep.
+const isPosix = process.platform !== "win32";
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+async function waitForExit(pid: number, deadlineMs = 10_000): Promise<boolean> {
+  const deadline = Date.now() + deadlineMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return !isAlive(pid);
+}
+
+async function setupFakeLauncher(): Promise<{ script: string; pidFile: string; dir: string }> {
+  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "remnic-qmd-kill-"));
+  const script = path.join(dir, "fake-qmd");
+  const pidFile = path.join(dir, "grandchild.pid");
+  // Launcher spawns a grandchild that outlives it, then hangs until killed.
+  await fs.promises.writeFile(
+    script,
+    `#!/bin/sh\nsleep 30 &\necho $! > "${pidFile}"\nsleep 30\n`,
+    { mode: 0o755 },
+  );
+  return { script, pidFile, dir };
+}
+
+async function readPidFile(pidFile: string, deadlineMs = 5_000): Promise<number> {
+  const deadline = Date.now() + deadlineMs;
+  for (;;) {
+    try {
+      const text = await fs.promises.readFile(pidFile, "utf8");
+      const pid = Number.parseInt(text.trim(), 10);
+      assert.ok(Number.isInteger(pid) && pid > 0, `bad grandchild pid: ${text}`);
+      return pid;
+    } catch (err) {
+      if (Date.now() >= deadline) throw err;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  }
+}
+
+async function cleanupSurvivors(pids: Array<number | undefined>, dir?: string): Promise<void> {
+  for (const pid of pids) {
+    if (pid === undefined || !isAlive(pid)) continue;
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      // Already gone.
+    }
+  }
+  if (dir) await fs.promises.rm(dir, { recursive: true, force: true });
+}
+
+test(
+  "timeout kills qmd launcher process group including grandchildren",
+  { skip: isPosix ? false : "POSIX process groups do not exist on Windows" },
+  async () => {
+    const { script, pidFile, dir } = await setupFakeLauncher();
+    let grandchildPid: number | undefined;
+    try {
+      await assert.rejects(
+        runCommandWithTimeoutForTest(script, [], { timeoutMs: 500, label: "qmd fake" }),
+        (err: Error & { timedOut?: boolean }) => err.timedOut === true,
+      );
+      grandchildPid = await readPidFile(pidFile);
+      assert.ok(
+        await waitForExit(grandchildPid),
+        `grandchild ${grandchildPid} survived the group kill`,
+      );
+    } finally {
+      await cleanupSurvivors([grandchildPid], dir);
+    }
+  },
+);
+
+test(
+  "abort kills qmd launcher process group including grandchildren",
+  { skip: isPosix ? false : "POSIX process groups do not exist on Windows" },
+  async () => {
+    const { script, pidFile, dir } = await setupFakeLauncher();
+    let grandchildPid: number | undefined;
+    const controller = new AbortController();
+    try {
+      const run = runCommandWithTimeoutForTest(script, [], {
+        timeoutMs: 60_000,
+        signal: controller.signal,
+        label: "qmd fake",
+      });
+      setTimeout(() => controller.abort(), 300);
+      await assert.rejects(run, /aborted/);
+      grandchildPid = await readPidFile(pidFile);
+      assert.ok(
+        await waitForExit(grandchildPid),
+        `grandchild ${grandchildPid} survived the group kill`,
+      );
+    } finally {
+      await cleanupSurvivors([grandchildPid], dir);
+    }
+  },
+);

package/src/qmd.ts

@@ -562,6 +562,11 @@ function runCommandWithTimeout(
     const child = launchProcess(command, args, {
       env: mergeEnv({ NO_COLOR: "1", ...options.env }),
       stdio: ["ignore", "pipe", "pipe"],
+      // POSIX: own process group so a timeout/abort kill can take down qmd's
+      // grandchildren too (launcher scripts spawn workers that outlive the
+      // launcher itself). Issue #2456. Windows ignores this option here —
+      // kill falls back to a direct child.kill.
+      detached: process.platform !== "win32",
     });
     if (!child.stdout || !child.stderr) {
       reject(new Error(`${label} failed to open stdio pipes`));
@@ -575,7 +580,7 @@ function runCommandWithTimeout(
     const timer = setTimeout(() => {
       settled = true;
       cleanup();
-      child.kill("SIGKILL");
+      killBoundedChild(child);
       // Flag the deadline breach so classifyProbeFailure can tell a genuine
       // timeout from a non-zero-exit error whose message merely embeds stderr.
       reject(
@@ -589,7 +594,7 @@ function runCommandWithTimeout(
       settled = true;
       clearTimeout(timer);
       cleanup();
-      child.kill("SIGKILL");
+      killBoundedChild(child);
       reject(abortError(`${label} aborted`));
     };
     const cleanup = () => {
@@ -636,6 +641,29 @@ function runProcessCommand(
   });
 }
 
+// Kill a bounded subprocess and its descendants. On POSIX the child runs
+// detached (own process group), so a negative-pid signal reaches the whole
+// tree. Fall back to a direct kill on Windows, missing pid, or when the
+// group is already gone. Never throws — callers use it on best-effort paths.
+function killBoundedChild(child: CommandChildProcess): void {
+  const pid = child.pid;
+  if (pid !== undefined && process.platform !== "win32") {
+    try {
+      process.kill(-pid, "SIGKILL");
+      return;
+    } catch {
+      // Group already reaped or never became a leader — fall through.
+    }
+  }
+  try {
+    child.kill("SIGKILL");
+  } catch {
+    // Already exited between the check and the kill.
+  }
+}
+
+export { runCommandWithTimeout as runCommandWithTimeoutForTest };
+
 // ---------------------------------------------------------------------------
 // QMD Stdio Daemon Session (MCP over stdio child process)
 // ---------------------------------------------------------------------------