@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/notify.js

@@ -1,25 +1,219 @@
-import { buildCompletionKey, getGlobalSeenMap, markSeenWithTtl } from "./completion-dedupe.js";
+import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.js";
 import {
   createCompletionBatcher,
   resolveCompletionBatchConfig
 } from "./completion-batcher.js";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.js";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT } from "../../shared/types.js";
+import { safeTerminalText } from "../../shared/display-text.js";
+import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
+import { isUnexplainedProcessSignal } from "../shared/process-signal.js";
+const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 4 * 1024;
+const CHILD_OUTPUT_PREVIEW_COUNT = 8;
+const PREVIEW_TRUNCATION_MARKER = "...[preview truncated]";
+function truncateUtf8Head(value, maxBytes) {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes)
+    return { text: value, truncated: false };
+  const markerBytes = Buffer.byteLength(PREVIEW_TRUNCATION_MARKER, "utf8");
+  const contentBytes = Math.max(0, maxBytes - markerBytes);
+  let end = contentBytes;
+  while (end > 0 && (bytes[end] & 192) === 128)
+    end -= 1;
+  return {
+    text: `${bytes.subarray(0, end).toString("utf8")}${PREVIEW_TRUNCATION_MARKER}`,
+    truncated: true
+  };
+}
+function boundedSafeText(value, maxBytes = 1024) {
+  return truncateUtf8Head(safeTerminalText(value).replace(/\n/g, "\\n"), maxBytes).text;
+}
+function outputPathFromReference(value) {
+  if (typeof value === "string" && value.trim())
+    return value.trim();
+  if (value && typeof value === "object" && typeof value.path === "string" && value.path.trim())
+    return value.path.trim();
+  return;
+}
+function childSavedOutputPath(child) {
+  return outputPathFromReference(child.outputReference);
+}
+function childStatus(child, workflowState) {
+  const knownStatus = child.status === "complete" ? "completed" : child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached" ? child.status : undefined;
+  if (knownStatus)
+    return knownStatus;
+  return resolveSubagentResultStatus({
+    success: child.success,
+    state: child.state ?? (child.success === undefined ? workflowState : undefined),
+    interrupted: child.interrupted,
+    detached: child.detached,
+    processSignal: child.processSignal,
+    timedOut: child.timedOut,
+    stopped: child.stopped,
+    turnBudgetExceeded: child.turnBudgetExceeded,
+    exitCode: typeof child.exitCode === "number" ? child.exitCode : undefined
+  });
+}
+function structuredOutputText(value) {
+  if (value === undefined)
+    return;
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    return typeof serialized === "string" ? serialized : undefined;
+  } catch {
+    return;
+  }
+}
+function childInlinePreview(child) {
+  const output = typeof child.output === "string" ? child.output : "";
+  const outputReference = childSavedOutputPath(child);
+  const referenceOnly = Boolean(outputReference && output.trim().startsWith("Output saved to:"));
+  const raw = child.outputState === "absent" || referenceOnly ? structuredOutputText(child.structuredOutput) : output || structuredOutputText(child.structuredOutput);
+  if (!raw?.trim()) {
+    return { unavailableReason: referenceOnly ? "saved output is file-only" : "no safe inline output" };
+  }
+  const safe = safeTerminalText(raw);
+  if (!safe.trim())
+    return { unavailableReason: "no safe inline output" };
+  const bounded = truncateUtf8Head(safe, CHILD_OUTPUT_PREVIEW_MAX_BYTES);
+  return { preview: bounded.text, ...bounded.truncated ? { truncated: true } : {} };
+}
+function formatChildOutputBlock(children) {
+  if (!children?.length)
+    return;
+  const lines = ["Child outputs:"];
+  for (let index = 0;index < children.length; index++) {
+    const child = children[index];
+    const key = child.workflowKey ? boundedSafeText(child.workflowKey) : "unavailable";
+    const runId = child.runId ? boundedSafeText(child.runId) : "unavailable";
+    const status = boundedSafeText(child.status) || "unavailable";
+    lines.push(`- key=${key} run=${runId} status=${status}`);
+    lines.push(`  Saved output: ${child.savedOutputPath ? boundedSafeText(child.savedOutputPath) : "unavailable"}`);
+    if (index >= CHILD_OUTPUT_PREVIEW_COUNT) {
+      lines.push("  Preview: unavailable (notice preview budget exceeded)");
+      continue;
+    }
+    if (!child.preview) {
+      lines.push(`  Preview: unavailable (${child.previewUnavailableReason ?? "no safe inline output"})`);
+      continue;
+    }
+    lines.push("  Preview:");
+    for (const line of child.preview.split(`
+`))
+      lines.push(`    | ${line}`);
+  }
+  if (children.length > CHILD_OUTPUT_PREVIEW_COUNT) {
+    lines.push(`- ${children.length - CHILD_OUTPUT_PREVIEW_COUNT} additional child preview(s) omitted by notice budget; child run metadata is retained below.`);
+  }
+  return lines.join(`
+`);
+}
+function formatResultPreview(details) {
+  const summary = details.resultPreview.trim() ? details.resultPreview : "(no output)";
+  const childOutputs = formatChildOutputBlock(details.childOutputs);
+  return childOutputs ? `${summary}
+
+${childOutputs}` : summary;
+}
 function formatSessionLine(details) {
   if (!details.sessionValue)
     return;
   return details.sessionLabel ? `${details.sessionLabel}: ${details.sessionValue}` : details.sessionValue;
 }
+function formatChildRun(child) {
+  const label = child.workflowKey ?? child.agent;
+  const status = child.status ? ` (${child.status})` : "";
+  return `${label ? `${label}=` : ""}${child.runId}${status}`;
+}
+function formatCorrelationLines(details) {
+  return [
+    details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : undefined,
+    details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : undefined,
+    details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : undefined
+  ].filter((line) => line !== undefined);
+}
 export function formatSingleCompletion(details) {
   const sessionLine = formatSessionLine(details);
+  const correlationLines = formatCorrelationLines(details);
+  const taskKind = details.source === "foreground" ? "Detached foreground task" : "Background task";
+  const scheduleLine = details.scheduleOrigin ? `Scheduled run from **${details.scheduleOrigin.name ?? details.scheduleOrigin.id}** (schedule ${details.scheduleOrigin.id}).` : undefined;
   return [
-    `Background task ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
+    `${taskKind} ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
     "",
-    details.resultPreview.trim() ? details.resultPreview : "(no output)",
+    scheduleLine,
+    scheduleLine ? "" : undefined,
+    formatResultPreview(details),
+    details.handoffPath ? "" : undefined,
+    details.handoffPath ? `Parallel handoff: ${details.handoffPath}` : undefined,
+    correlationLines.length && !details.handoffPath ? "" : undefined,
+    ...correlationLines,
     sessionLine ? "" : undefined,
     sessionLine
   ].filter((line) => line !== undefined).join(`
 `);
 }
+export function parseSubagentNotifyContent(content) {
+  const lines = content.split(`
+`);
+  const match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
+  if (!match)
+    return;
+  let body = lines.slice(2);
+  const scheduleMatch = (body[0] ?? "").match(/^Scheduled run from \*\*(.+?)\*\* \(schedule (.+?)\)\.$/);
+  let parsedScheduleOrigin;
+  if (scheduleMatch) {
+    const label = scheduleMatch[1];
+    const id = scheduleMatch[2];
+    parsedScheduleOrigin = { id, ...label === id ? {} : { name: label } };
+    body = body.slice(body[1]?.trim() === "" ? 2 : 1);
+  }
+  let sessionIndex = -1;
+  for (let i = body.length - 1;i >= 1; i--) {
+    if (body[i - 1]?.trim() === "" && /^(Session|Session file|Session share error):\s+/.test(body[i])) {
+      sessionIndex = i;
+      break;
+    }
+  }
+  const sessionLine = sessionIndex >= 0 ? body[sessionIndex] : undefined;
+  const handoffIndex = body.findIndex((line) => line.startsWith("Parallel handoff: "));
+  const workflowRunIndex = body.findIndex((line) => line.startsWith("Workflow run: "));
+  const childRunsIndex = body.findIndex((line) => line.startsWith("Child runs: "));
+  const reconciledIndex = body.findIndex((line) => line.startsWith("Reconciled detached child: "));
+  const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex].filter((index) => index >= 0);
+  const firstMetadataIndex = metadataIndexes.length ? Math.min(...metadataIndexes) : body.length;
+  const resultEnd = firstMetadataIndex > 0 && body[firstMetadataIndex - 1]?.trim() === "" ? firstMetadataIndex - 1 : firstMetadataIndex;
+  const resultPreview = body.slice(0, resultEnd).join(`
+`).trim() || "(no output)";
+  const handoffPath = handoffIndex >= 0 ? body[handoffIndex].slice("Parallel handoff: ".length).trim() : undefined;
+  const workflowRunId = workflowRunIndex >= 0 ? body[workflowRunIndex].slice("Workflow run: ".length).trim() : undefined;
+  const childRuns = childRunsIndex >= 0 ? body[childRunsIndex].slice("Child runs: ".length).split(", ").map((part) => {
+    const trimmed = part.trim();
+    const statusMatch = trimmed.match(/^(.*?)(?: \(([^)]*)\))?$/);
+    const raw = statusMatch?.[1] ?? trimmed;
+    const separator = raw.indexOf("=");
+    return separator >= 0 ? { workflowKey: raw.slice(0, separator), runId: raw.slice(separator + 1), ...statusMatch?.[2] ? { status: statusMatch[2] } : {} } : { runId: raw, ...statusMatch?.[2] ? { status: statusMatch[2] } : {} };
+  }).filter((child) => child.runId) : undefined;
+  const reconciledFromDetachedChild = reconciledIndex >= 0 ? body[reconciledIndex].slice("Reconciled detached child: ".length).trim() : undefined;
+  let sessionLabel;
+  let sessionValue;
+  if (sessionLine) {
+    const separator = sessionLine.indexOf(":");
+    sessionLabel = sessionLine.slice(0, separator).toLowerCase();
+    sessionValue = sessionLine.slice(separator + 1).trim();
+  }
+  return {
+    agent: match[3],
+    status: match[2],
+    ...match[1] === "Detached foreground task" ? { source: "foreground" } : {},
+    ...match[4] ? { taskInfo: match[4] } : {},
+    ...parsedScheduleOrigin ? { scheduleOrigin: parsedScheduleOrigin } : {},
+    resultPreview,
+    ...handoffPath ? { handoffPath } : {},
+    ...workflowRunId ? { workflowRunId } : {},
+    ...childRuns?.length ? { childRuns } : {},
+    ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
+    ...sessionLabel && sessionValue ? { sessionLabel, sessionValue } : {}
+  };
+}
 export function formatGroupedCompletion(details) {
   const header = `Background tasks completed (${details.length}): ${details.map((d) => `**${d.agent}**${d.taskInfo ?? ""}`).join(", ")}`;
   const blocks = [header, ""];
@@ -28,8 +222,11 @@ export function formatGroupedCompletion(details) {
     if (!detail)
       continue;
     const sessionLine = formatSessionLine(detail);
-    blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}`);
-    blocks.push(detail.resultPreview.trim() ? detail.resultPreview : "(no output)");
+    blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}${detail.scheduleOrigin ? ` — scheduled run from ${detail.scheduleOrigin.name ?? detail.scheduleOrigin.id} (schedule ${detail.scheduleOrigin.id})` : ""}`);
+    blocks.push(formatResultPreview(detail));
+    if (detail.handoffPath)
+      blocks.push(`Parallel handoff: ${detail.handoffPath}`);
+    blocks.push(...formatCorrelationLines(detail));
     if (sessionLine)
       blocks.push(sessionLine);
     blocks.push("");
@@ -37,15 +234,22 @@ export function formatGroupedCompletion(details) {
   return blocks.join(`
 `).trimEnd();
 }
-function sendCompletion(pi, details) {
-  if (details.length === 0)
-    return;
+function sendCompletion(dm, items) {
+  if (items.length === 0)
+    return true;
+  const details = items.map((item) => item.details);
   const content = details.length === 1 ? formatSingleCompletion(details[0]) : formatGroupedCompletion(details);
-  pi.sendMessage({
-    customType: "subagent-notify",
-    content,
-    display: true
-  }, { triggerTurn: true });
+  const display = details.some((detail) => detail.source === "foreground" || detail.status !== "completed" || detail.scheduleOrigin !== undefined);
+  try {
+    dm.sendMessage({
+      customType: "subagent-notify",
+      content,
+      display
+    }, { triggerTurn: items.some((item) => item.triggerTurn) });
+    return true;
+  } catch {
+    return false;
+  }
 }
 function completionBatchKey(result) {
   const sessionId = typeof result.sessionId === "string" ? result.sessionId.trim() : "";
@@ -57,73 +261,169 @@ function completionBatchKey(result) {
 export function buildCompletionDetails(result) {
   const agent = result.agent ?? "unknown";
   const summary = typeof result.summary === "string" ? result.summary : "";
-  const paused = !result.success && (result.exitCode === 0 || result.state === "paused" || summary.startsWith("Paused after interrupt."));
-  const status = paused ? "paused" : result.success ? "completed" : "failed";
+  const stopped = result.stopped === true || result.state === "stopped" || result.success !== true && result.exitCode !== 0 && isUnexplainedProcessSignal(result) || result.results?.some((child) => child.stopped === true || child.status === "stopped" || child.success !== true && child.exitCode !== 0 && isUnexplainedProcessSignal(child)) === true;
+  const paused = !stopped && !result.success && (result.exitCode === 0 || result.state === "paused" || result.interrupted === true || summary.startsWith("Paused after interrupt."));
+  const status = stopped ? "stopped" : paused ? "paused" : result.success ? "completed" : "failed";
   const taskInfo = result.taskIndex !== undefined && result.totalTasks !== undefined ? ` (${result.taskIndex + 1}/${result.totalTasks})` : undefined;
+  const parallelHandoff = result.parallelHandoff && typeof result.parallelHandoff === "object" ? result.parallelHandoff : undefined;
+  const handoffPath = typeof parallelHandoff?.path === "string" ? parallelHandoff.path : undefined;
+  const rawRunId = typeof result.runId === "string" ? result.runId : typeof result.id === "string" ? result.id : undefined;
+  const workflowRunId = (result.mode === "workflow" || agent === "workflow") && rawRunId ? rawRunId : undefined;
+  const childRuns = result.results?.flatMap((child) => {
+    const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
+    const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
+    if (!runId && (!workflowRunId || !workflowKey))
+      return [];
+    return [{
+      runId: runId ?? "unavailable",
+      ...workflowKey ? { workflowKey } : {},
+      ...typeof child.agent === "string" ? { agent: child.agent } : {},
+      status: childStatus(child, workflowRunId ? result.state : undefined)
+    }];
+  }) ?? [];
+  const childOutputs = workflowRunId && result.results?.length ? result.results.map((child) => {
+    const inline = childInlinePreview(child);
+    const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
+    const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
+    const savedOutputPath = childSavedOutputPath(child);
+    return {
+      ...workflowKey ? { workflowKey } : {},
+      ...runId ? { runId } : {},
+      ...typeof child.agent === "string" ? { agent: child.agent } : {},
+      status: childStatus(child, result.state),
+      ...savedOutputPath ? { savedOutputPath } : {},
+      ...inline.preview ? { preview: inline.preview } : { preview: "" },
+      ...inline.truncated ? { previewTruncated: true } : {},
+      ...inline.unavailableReason ? { previewUnavailableReason: inline.unavailableReason } : {}
+    };
+  }) : undefined;
+  const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
   const session = result.shareUrl ? { label: "Session", value: result.shareUrl } : result.shareError ? { label: "Session share error", value: result.shareError } : result.sessionFile ? { label: "Session file", value: result.sessionFile } : undefined;
+  const rawOrigin = result.scheduleOrigin;
+  const scheduleOrigin = rawOrigin && typeof rawOrigin.id === "string" ? { id: rawOrigin.id, ...typeof rawOrigin.name === "string" ? { name: rawOrigin.name } : {} } : undefined;
   return {
     agent,
     status,
+    ...scheduleOrigin ? { scheduleOrigin } : {},
+    ...result.source ? { source: result.source } : {},
     ...taskInfo ? { taskInfo } : {},
     resultPreview: summary,
     ...typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {},
+    ...handoffPath ? { handoffPath } : {},
+    ...workflowRunId ? { workflowRunId } : {},
+    ...childRuns.length ? { childRuns } : {},
+    ...childOutputs?.length ? { childOutputs } : {},
+    ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
     ...session ? { sessionLabel: session.label, sessionValue: session.value } : {}
   };
 }
-export default function registerSubagentNotify(pi, state, options = {}) {
-  const unsubscribeStoreKey = "__pi_subagents_notify_unsubscribe__";
-  const batcherStoreKey = "__pi_subagents_notify_batcher__";
-  const globalStore = globalThis;
-  const previousUnsubscribe = globalStore[unsubscribeStoreKey];
-  if (typeof previousUnsubscribe === "function") {
-    try {
-      previousUnsubscribe();
-    } catch {}
-  }
-  const previousBatcher = globalStore[batcherStoreKey];
-  if (previousBatcher && typeof previousBatcher.dispose === "function") {
-    try {
-      previousBatcher.dispose();
-    } catch {}
-  }
-  const seen = getGlobalSeenMap("__pi_subagents_notify_seen__");
+export default function registerSubagentNotify(dm, state, options = {}) {
+  const seen = new Map;
+  const pending = new Map;
   const ttlMs = 10 * 60 * 1000;
-  const nowFn = options.now ?? Date.now;
+  const now = options.now ?? Date.now;
   const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
   const batchers = new Map;
-  globalStore[batcherStoreKey] = {
-    dispose() {
-      for (const batcher of batchers.values())
-        batcher.dispose();
-      batchers.clear();
+  let disposed = false;
+  const ownsResult = options.ownership?.owns ?? ((sessionId, completionOwnerId) => sessionId === state.currentSessionId && typeof completionOwnerId === "string" && completionOwnerId === state.completionOwnerId);
+  const settle = (items, accepted) => {
+    for (const item of items) {
+      pending.delete(item.key);
+      if (accepted)
+        markSeenWithTtl(seen, item.key, now(), ttlMs);
+      item.resolve(accepted);
     }
   };
-  const handleComplete = (data) => {
-    const result = data;
-    if (typeof result.sessionId !== "string" || result.sessionId !== state.currentSessionId)
-      return;
-    const now = nowFn();
-    const key = buildCompletionKey(result, "notify");
-    if (markSeenWithTtl(seen, key, now, ttlMs))
-      return;
-    const details = buildCompletionDetails(result);
-    const batchKey = completionBatchKey(result);
-    let batcher = batchers.get(batchKey);
+  const emit = (items) => {
+    const accepted = [];
+    const rejected = [];
+    for (const item of items) {
+      const owned = item.details.source === "foreground" ? item.sessionId === state.currentSessionId : ownsResult(item.sessionId, item.completionOwnerId);
+      (owned ? accepted : rejected).push(item);
+    }
+    settle(rejected, false);
+    settle(accepted, sendCompletion(dm, accepted));
+  };
+  const getBatcher = (result) => {
+    const key = completionBatchKey(result);
+    let batcher = batchers.get(key);
     if (!batcher) {
       batcher = createCompletionBatcher({
         config: batchConfig,
-        emit: (items) => sendCompletion(pi, items),
+        emit,
         ...options.timers ? { timers: options.timers } : {},
-        now: nowFn
+        now
       });
-      batchers.set(batchKey, batcher);
+      batchers.set(key, batcher);
+    }
+    return batcher;
+  };
+  const deliver = (result) => {
+    if (disposed || typeof result.sessionId !== "string")
+      return Promise.resolve(false);
+    if (result.source === "foreground") {
+      if (result.sessionId !== state.currentSessionId)
+        return Promise.resolve(false);
+    } else if (!ownsResult(result.sessionId, result.completionOwnerId))
+      return Promise.resolve(false);
+    if (result.intercomDelivered === true)
+      return Promise.resolve(true);
+    const key = buildCompletionKey(result, "notify");
+    const seenAt = seen.get(key);
+    if (seenAt !== undefined && now() - seenAt <= ttlMs)
+      return Promise.resolve(true);
+    if (seenAt !== undefined)
+      seen.delete(key);
+    const inFlight = pending.get(key);
+    if (inFlight)
+      return inFlight;
+    const details = buildCompletionDetails(result);
+    let resolve;
+    const completion = new Promise((settleCompletion) => {
+      resolve = settleCompletion;
+    });
+    pending.set(key, completion);
+    const item = {
+      key,
+      details,
+      sessionId: result.sessionId,
+      completionOwnerId: result.completionOwnerId,
+      triggerTurn: result.triggerTurn !== false,
+      resolve
+    };
+    if (details.source === "foreground") {
+      emit([item]);
+      return completion;
     }
+    const batcher = getBatcher(result);
     if (details.status !== "completed") {
       batcher.flush();
-      sendCompletion(pi, [details]);
-      return;
+      emit([item]);
+      return completion;
+    }
+    batcher.push(item);
+    return completion;
+  };
+  const unsubscribeAsync = dm.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+    deliver(data);
+  });
+  const unsubscribeForeground = dm.events.on(SUBAGENT_FOREGROUND_COMPLETE_EVENT, (data) => {
+    deliver(data);
+  });
+  return {
+    deliver,
+    dispose() {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const batcher of batchers.values())
+        settle(batcher.dispose(), false);
+      batchers.clear();
+      for (const unsubscribe of [unsubscribeAsync, unsubscribeForeground]) {
+        try {
+          unsubscribe?.();
+        } catch {}
+      }
     }
-    batcher.push(details);
   };
-  globalStore[unsubscribeStoreKey] = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
 }

package/extensions/dm-subagents/src/runs/background/owned-process-tree.js

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+const DEFAULT_TERM_GRACE_MS = 3000;
+const DEFAULT_KILL_VERIFY_MS = 1000;
+const VERIFY_INTERVAL_MS = 25;
+function diagnostic(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function signalProcess(id, signal) {
+  try {
+    process.kill(id, signal);
+    return "sent";
+  } catch (error) {
+    if (error.code === "ESRCH")
+      return "absent";
+    return { diagnostic: diagnostic(error) };
+  }
+}
+function activeProcessGroupMembers(processGroupId) {
+  const result = spawnSync("ps", ["-axo", "pid=,pgid=,stat="], { encoding: "utf-8" });
+  if (result.error || result.status !== 0) {
+    return { diagnostic: result.error ? diagnostic(result.error) : result.stderr.trim() || `ps exited with ${result.status}` };
+  }
+  const members = [];
+  for (const line of result.stdout.split(`
+`)) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+    if (!match || Number(match[2]) !== processGroupId || match[3].startsWith("Z"))
+      continue;
+    members.push(Number(match[1]));
+  }
+  return members;
+}
+async function waitUntilGroupTerminal(processGroupId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const members = activeProcessGroupMembers(processGroupId);
+    if (Array.isArray(members) && members.length === 0)
+      return false;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      if (!Array.isArray(members))
+        return { state: "enumeration-failed", diagnostic: members.diagnostic };
+      return { state: "still-active", diagnostic: `Process group ${processGroupId} still has active members: ${members.join(", ")}.` };
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(VERIFY_INTERVAL_MS, remaining)));
+  }
+}
+function observed(processGroupId) {
+  return { state: "observed", mechanism: "posix-process-group", processGroupId, verifiedAt: Date.now() };
+}
+export function createOwnedProcessTreeController(pid, options = {}) {
+  let termination;
+  const posixGroupOwned = process.platform !== "win32";
+  const target = posixGroupOwned ? -pid : pid;
+  const terminate = () => {
+    if (termination)
+      return termination;
+    termination = (async () => {
+      if (!posixGroupOwned) {
+        signalProcess(target, "SIGTERM");
+        return { state: "unknown", reason: "unsupported-platform" };
+      }
+      const term = signalProcess(target, "SIGTERM");
+      if (term !== "sent" && term !== "absent") {
+        return { state: "unknown", reason: "signal-failed", diagnostic: term.diagnostic };
+      }
+      const termExit = await waitUntilGroupTerminal(pid, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS);
+      if (termExit === false)
+        return observed(pid);
+      const kill = signalProcess(target, "SIGKILL");
+      if (kill !== "sent" && kill !== "absent") {
+        const members = activeProcessGroupMembers(pid);
+        if (!Array.isArray(members) || members.length > 0) {
+          return { state: "unknown", reason: "signal-failed", diagnostic: kill.diagnostic };
+        }
+      }
+      const killExit = await waitUntilGroupTerminal(pid, options.killVerifyMs ?? DEFAULT_KILL_VERIFY_MS);
+      if (killExit !== false) {
+        return { state: "unknown", reason: "verification-failed", diagnostic: killExit.diagnostic };
+      }
+      return observed(pid);
+    })();
+    return termination;
+  };
+  return { terminate, finishAfterWriterClose: terminate };
+}