@snarkipus/opencode-beads 0.9.1 → 0.9.2

package/README.md

@@ -20,7 +20,7 @@ Add the version-pinned plugin to your OpenCode config (`~/.config/opencode/openc
 
 ```json
 {
-  "plugin": ["@snarkipus/opencode-beads@0.9.1"]
+  "plugin": ["@snarkipus/opencode-beads@0.9.2"]
 }
 ```
 
@@ -37,13 +37,13 @@ Skip `git init` when the project is already a Git worktree. `bd init` performs t
 
 ### Upgrading from 0.8.0
 
-Version 0.8.0 installed a fork-managed skill under `.opencode/skills/beads`. Remove that old managed skill with the version-pinned 0.8.0 CLI before changing the plugin pin to 0.9.1:
+Version 0.8.0 installed a fork-managed skill under `.opencode/skills/beads`. Remove that old managed skill with the version-pinned 0.8.0 CLI before changing the plugin pin to 0.9.2:
 
 ```bash
 bunx @snarkipus/opencode-beads@0.8.0 remove
 ```
 
-If the old skill was installed globally, append `--global` to that exact command. Do not substitute 0.9.1 in the removal command: the companion CLI no longer exists in 0.9.1.
+If the old skill was installed globally, append `--global` to that exact command. Do not substitute 0.9.2 in the removal command: the companion CLI no longer exists in 0.9.2.
 
 For a repository that has not been initialized with Beads, run `bd init`; it creates the canonical shared skill as part of normal initialization. For an already-initialized repository that is missing the skill, upstream currently has no skill-only setup command. Do not run `bd setup codex` as a substitute because it also installs Codex hooks and generated instructions. Instead, initialize a temporary Git repository with the same `bd` version and copy only its canonical skill directory into the target repository:
 
@@ -92,11 +92,11 @@ The compatibility ranges and validated baselines for this release are:
 
 | Component | Expected range | Validated baseline |
 | --- | --- | --- |
-| OpenCode | 1.18.3 through 1.x | 1.18.4 |
-| `bd` CLI | 1.0.5 through 1.x | 1.1.0 |
+| OpenCode | 1.18.3 through 1.x | 1.18.15 |
+| `bd` CLI | 1.0.5 through 1.x | 1.1.2 |
 | Bun | >=1.3.14 | 1.3.14 |
 
-The OpenCode adapter builds against the exact paired `@opencode-ai/plugin` and `@opencode-ai/sdk` `1.18.4` releases and declares compatible optional peers from `1.18.3` through the stable `1.x` line. Both imports are type-only; the package does not install a second OpenCode runtime. Command and agent provenance is currently synced from Beads v1.1.0. Newer compatible releases may work but are not guaranteed until validated; when diagnosing a regression, reproduce it with the baselines above.
+The OpenCode adapter builds against the exact paired `@opencode-ai/plugin` and `@opencode-ai/sdk` `1.18.15` releases and declares compatible optional peers from `1.18.3` through the stable `1.x` line. Both imports are type-only; the package does not install a second OpenCode runtime. Command and agent provenance is currently synced from Beads v1.1.2. Newer compatible releases may work but are not guaranteed until validated; when diagnosing a regression, reproduce it with the baselines above.
 
 ## Vendored Content
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snarkipus/opencode-beads",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "type": "module",
   "description": "A maintained OpenCode integration for the Beads issue tracker, including context injection, vendored workflows, and a task agent.",
   "author": "Matt Jackson",
@@ -65,8 +65,8 @@
     }
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "1.18.4",
-    "@opencode-ai/sdk": "1.18.4",
+    "@opencode-ai/plugin": "1.18.15",
+    "@opencode-ai/sdk": "1.18.15",
     "@types/bun": "1.3.4",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"

package/src/opencode-runtime.ts

@@ -0,0 +1,156 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { Agent, SessionMessagesResponse } from "@opencode-ai/sdk";
+import type { PluginRuntime } from "./plugin-core";
+import { runBdPrime } from "./prime";
+
+export const DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS = 5_000;
+export const DEFAULT_OPENCODE_DIAGNOSTIC_TIMEOUT_MS = 1_000;
+
+export class OpenCodeTimeoutError extends Error {
+  constructor(readonly operation: string, readonly timeoutMs: number) {
+    super(`OpenCode ${operation} timed out after ${timeoutMs}ms`);
+    this.name = "OpenCodeTimeoutError";
+  }
+}
+
+export interface OpenCodeRuntimeOptions {
+  requestTimeoutMs?: number;
+  diagnosticTimeoutMs?: number;
+  prime?: PluginRuntime["prime"];
+}
+
+async function withDeadline<T>(
+  operation: string,
+  timeoutMs: number,
+  execute: (signal: AbortSignal) => Promise<T>
+): Promise<T> {
+  const controller = new AbortController();
+  let rejectTimeout: (error: OpenCodeTimeoutError) => void = () => {};
+  const timeout = new Promise<never>((_resolve, reject) => {
+    rejectTimeout = reject;
+  });
+  const timer = setTimeout(() => {
+    const error = new OpenCodeTimeoutError(operation, timeoutMs);
+    controller.abort(error);
+    rejectTimeout(error);
+  }, timeoutMs);
+
+  try {
+    return await Promise.race([execute(controller.signal), timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isSessionMessage(value: unknown): boolean {
+  if (
+    !isRecord(value) ||
+    !isRecord(value.info) ||
+    (value.info.role !== "user" && value.info.role !== "assistant") ||
+    (value.info.agent !== undefined && typeof value.info.agent !== "string") ||
+    (value.info.system !== undefined && typeof value.info.system !== "string") ||
+    (value.info.model !== undefined &&
+      (!isRecord(value.info.model) ||
+        typeof value.info.model.providerID !== "string" ||
+        typeof value.info.model.modelID !== "string"))
+  ) {
+    return false;
+  }
+  if (!Array.isArray(value.parts)) return false;
+
+  return value.parts.every(
+    (part) =>
+      isRecord(part) &&
+      typeof part.type === "string" &&
+      (part.text === undefined || typeof part.text === "string") &&
+      (part.synthetic === undefined || typeof part.synthetic === "boolean")
+  );
+}
+
+function isAgent(value: unknown): boolean {
+  return (
+    isRecord(value) &&
+    typeof value.name === "string" &&
+    (value.mode === "subagent" || value.mode === "primary" || value.mode === "all")
+  );
+}
+
+/** Adapt the official OpenCode client to the controller's small deterministic boundary. */
+export function createOpenCodeRuntime(
+  client: PluginInput["client"],
+  options: OpenCodeRuntimeOptions = {}
+): PluginRuntime {
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_OPENCODE_REQUEST_TIMEOUT_MS;
+  const diagnosticTimeoutMs =
+    options.diagnosticTimeoutMs ?? DEFAULT_OPENCODE_DIAGNOSTIC_TIMEOUT_MS;
+
+  return {
+    async getMessages(projectDirectory, sessionID, limit) {
+      const response = await withDeadline("session.messages", requestTimeoutMs, (signal) =>
+        client.session.messages({
+          path: { id: sessionID },
+          query: { directory: projectDirectory, limit },
+          signal,
+        })
+      );
+      if (response.error !== undefined) throw response.error;
+      if (!Array.isArray(response.data) || !response.data.every(isSessionMessage)) {
+        throw new Error("OpenCode returned malformed session messages");
+      }
+      return response.data satisfies SessionMessagesResponse;
+    },
+
+    async getAgents(projectDirectory) {
+      const response = await withDeadline("app.agents", requestTimeoutMs, (signal) =>
+        client.app.agents({ query: { directory: projectDirectory }, signal })
+      );
+      if (response.error !== undefined) throw response.error;
+      if (!Array.isArray(response.data) || !response.data.every(isAgent)) {
+        throw new Error("OpenCode returned malformed agents");
+      }
+      return response.data satisfies Agent[];
+    },
+
+    async prompt(projectDirectory, sessionID, body) {
+      const response = await withDeadline("session.prompt", requestTimeoutMs, (signal) =>
+        client.session.prompt({
+          path: { id: sessionID },
+          query: { directory: projectDirectory },
+          body,
+          signal,
+        })
+      );
+      if (response.error !== undefined) throw response.error;
+      if (response.data === undefined) throw new Error("OpenCode returned no prompt result");
+    },
+
+    async prime(projectDirectory) {
+      return (options.prime ?? runBdPrime)(projectDirectory);
+    },
+
+    async diagnose(diagnostic) {
+      const extra =
+        diagnostic.code === "config_collision"
+          ? { surface: diagnostic.surface, names: diagnostic.names }
+          : { sessionID: diagnostic.sessionID };
+      const response = await withDeadline("app.log", diagnosticTimeoutMs, (signal) =>
+        client.app.log({
+          query: { directory: diagnostic.directory },
+          body: {
+            service: "opencode-beads",
+            level: "warn",
+            message: diagnostic.code,
+            extra,
+          },
+          signal,
+        })
+      );
+      if (response.error !== undefined) throw response.error;
+      if (response.data === undefined) throw new Error("OpenCode returned no log result");
+    },
+  };
+}

package/src/plugin-core.ts

@@ -25,7 +25,8 @@ export type SessionMessage = {
   info: Pick<SessionMessageResponse["info"], "role"> &
     Partial<Pick<UserMessage, "agent" | "model" | "system">>;
   parts?: ReadonlyArray<
-    Pick<SessionMessageResponse["parts"][number], "type"> & Partial<Pick<TextPart, "text">>
+    Pick<SessionMessageResponse["parts"][number], "type"> &
+      Partial<Pick<TextPart, "text" | "synthetic">>
   >;
 };
 
@@ -79,9 +80,28 @@ export type MutablePluginConfig = Parameters<NonNullable<Hooks["config"]>>[0];
 export interface BeadsController {
   onMessage(message: MessageContext, sink: ContextSink): Promise<void>;
   onCompacted(sessionID: string): Promise<void>;
+  onSessionDeleted(sessionID: string): void;
   configure(config: MutablePluginConfig): Promise<void>;
 }
 
+type InjectionAudience = "primary" | "task-agent";
+const BEADS_CONTEXT_HEADER = /^<beads-context(?: audience="(primary|task-agent)")?>\n/;
+
+/** Recognize only the complete envelope emitted by this plugin. */
+export function isBeadsContextEnvelope(text: string): boolean {
+  const trimmed = text.trim();
+  return BEADS_CONTEXT_HEADER.test(trimmed) && trimmed.includes("\n</beads-context>");
+}
+
+function beadsContextAudience(text: string): InjectionAudience | undefined {
+  const audience = text.trim().match(BEADS_CONTEXT_HEADER)?.[1];
+  return audience === "primary" || audience === "task-agent" ? audience : undefined;
+}
+
+function injectionAudience(agentName: string | undefined): InjectionAudience {
+  return agentName === BEADS_TASK_AGENT ? "task-agent" : "primary";
+}
+
 /** Resolve OpenCode project scope without falling back to the process directory. */
 export function resolveProjectDirectory(directory: string, worktree: string): string {
   if (directory.trim()) return directory;
@@ -112,8 +132,8 @@ export async function createBeadsController(
   const [loadedCommands, loadedAgents] = await Promise.all([loadCommands(), loadAgent()]);
   const commands = loadedCommands ?? {};
   const agents = loadedAgents ?? {};
-  const injectedSessions = new Set<string>();
-  const injectionAttempts = new Map<string, Promise<void>>();
+  const injectedAudiences = new Map<string, Set<InjectionAudience>>();
+  const injectionAttempts = new Map<string, { promise: Promise<void>; cancelled: boolean }>();
   const diagnosticTimes = new Map<string, number>();
   const diagnosticIntervalMs = options.diagnosticIntervalMs ?? 60_000;
   const now = options.now ?? Date.now;
@@ -124,7 +144,9 @@ export async function createBeadsController(
     if (previousTime !== undefined && currentTime - previousTime < diagnosticIntervalMs) return;
 
     diagnosticTimes.set(key, currentTime);
-    await runtime.diagnose(diagnostic).catch(() => undefined);
+    void Promise.resolve()
+      .then(() => runtime.diagnose(diagnostic))
+      .catch(() => undefined);
   }
 
   async function diagnoseSession(
@@ -162,8 +184,14 @@ export async function createBeadsController(
     }
     if (!output) return undefined;
 
-    const audience = context?.agent === BEADS_TASK_AGENT ? "task-agent" : "primary";
-    return `<beads-context>\n${output}\n</beads-context>\n\n${beadsGuidance(audience)}`;
+    const audience = injectionAudience(context?.agent);
+    return `<beads-context audience="${audience}">\n${output}\n</beads-context>\n\n${beadsGuidance(audience)}`;
+  }
+
+  function markInjected(sessionID: string, audience: InjectionAudience): void {
+    const audiences = injectedAudiences.get(sessionID) ?? new Set<InjectionAudience>();
+    audiences.add(audience);
+    injectedAudiences.set(sessionID, audiences);
   }
 
   async function injectPrompt(
@@ -193,28 +221,41 @@ export async function createBeadsController(
     }
   }
 
-  async function performInitialInjection(message: MessageContext, sink: ContextSink): Promise<void> {
-    if (!(await shouldInject(message.agent, message.sessionID))) {
-      injectedSessions.add(message.sessionID);
-      return;
-    }
+  async function performInitialInjection(
+    message: MessageContext,
+    sink: ContextSink,
+    isActive: () => boolean
+  ): Promise<void> {
+    if (!(await shouldInject(message.agent, message.sessionID))) return;
 
-    try {
-      const existing = await runtime.getMessages(directory, message.sessionID);
-      const hasBeadsContext = existing?.some(
-        (item) =>
-          item.info.system?.includes("<beads-context>") ||
-          item.parts?.some(
-            (part) => part.type === "text" && part.text?.includes("<beads-context>")
-          )
-      );
-      if (hasBeadsContext) {
-        injectedSessions.add(message.sessionID);
-        return;
+    const audience = injectionAudience(message.agent);
+    const knownAudiences = injectedAudiences.get(message.sessionID);
+    if (knownAudiences?.has(audience)) return;
+
+    // On plugin reload there is no local audience state, so consult persisted envelopes.
+    if (!knownAudiences) {
+      try {
+        const existing = await runtime.getMessages(directory, message.sessionID);
+        const hasBeadsContext = existing?.some(
+          (item) =>
+            (item.info.system !== undefined &&
+              beadsContextAudience(item.info.system) === audience) ||
+            item.parts?.some(
+              (part) =>
+                part.type === "text" &&
+                part.synthetic === true &&
+                part.text !== undefined &&
+                beadsContextAudience(part.text) === audience
+            )
+        );
+        if (hasBeadsContext) {
+          if (isActive()) markInjected(message.sessionID, audience);
+          return;
+        }
+      } catch {
+        await diagnoseSession("messages_lookup_failed", message.sessionID);
+        // Message lookup is advisory; injection remains the safe fallback.
       }
-    } catch {
-      await diagnoseSession("messages_lookup_failed", message.sessionID);
-      // Message lookup is advisory; injection remains the safe fallback.
     }
 
     const rendered = await renderContext(message.sessionID, message);
@@ -222,7 +263,7 @@ export async function createBeadsController(
 
     try {
       await sink(rendered);
-      injectedSessions.add(message.sessionID);
+      if (isActive()) markInjected(message.sessionID, audience);
     } catch {
       await diagnoseSession("prompt_failed", message.sessionID);
     }
@@ -230,18 +271,21 @@ export async function createBeadsController(
 
   return {
     async onMessage(message, sink) {
-      if (injectedSessions.has(message.sessionID)) return;
+      const audience = injectionAudience(message.agent);
+      if (injectedAudiences.get(message.sessionID)?.has(audience)) return;
 
-      const pending = injectionAttempts.get(message.sessionID);
-      if (pending) return pending;
+      const attemptKey = `${message.sessionID}\0${audience}`;
+      const pending = injectionAttempts.get(attemptKey);
+      if (pending) return pending.promise;
 
-      const attempt = performInitialInjection(message, sink);
-      injectionAttempts.set(message.sessionID, attempt);
+      const attempt = { promise: Promise.resolve(), cancelled: false };
+      attempt.promise = performInitialInjection(message, sink, () => !attempt.cancelled);
+      injectionAttempts.set(attemptKey, attempt);
       try {
-        await attempt;
+        await attempt.promise;
       } finally {
-        if (injectionAttempts.get(message.sessionID) === attempt) {
-          injectionAttempts.delete(message.sessionID);
+        if (injectionAttempts.get(attemptKey) === attempt) {
+          injectionAttempts.delete(attemptKey);
         }
       }
     },
@@ -257,6 +301,19 @@ export async function createBeadsController(
       }
     },
 
+    onSessionDeleted(sessionID) {
+      injectedAudiences.delete(sessionID);
+      for (const [key, attempt] of injectionAttempts) {
+        if (key.startsWith(`${sessionID}\0`)) {
+          attempt.cancelled = true;
+          injectionAttempts.delete(key);
+        }
+      }
+      for (const key of diagnosticTimes.keys()) {
+        if (key.endsWith(`:${sessionID}`)) diagnosticTimes.delete(key);
+      }
+    },
+
     async configure(config) {
       const commandCollisions = Object.keys(config.command ?? {})
         .filter(

package/src/plugin-hooks.ts

@@ -0,0 +1,56 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { Part } from "@opencode-ai/sdk";
+import {
+  createBeadsController,
+  isBeadsContextEnvelope,
+  type PluginRuntime,
+} from "./plugin-core";
+
+/** Prevent the synthetic no-reply prompt from recursively triggering its own injection. */
+function isBeadsContextInjection(parts: ReadonlyArray<Part>): boolean {
+  return parts.some(
+    (part) =>
+      part.type === "text" &&
+      part.synthetic === true &&
+      isBeadsContextEnvelope(part.text)
+  );
+}
+
+/** Build OpenCode hooks around an explicit runtime boundary. */
+export async function createBeadsHooks(
+  runtime: PluginRuntime,
+  projectDirectory: string
+): Promise<Hooks> {
+  const controller = await createBeadsController(runtime, projectDirectory);
+
+  return {
+    "chat.message": async (input, output) => {
+      if (isBeadsContextInjection(output.parts)) return;
+
+      await controller.onMessage(
+        {
+          sessionID: input.sessionID,
+          model: input.model,
+          agent: input.agent,
+        },
+        (context) => {
+          output.message.system = output.message.system
+            ? `${output.message.system}\n\n${context}`
+            : context;
+        }
+      );
+    },
+
+    event: async ({ event }) => {
+      if (event.type === "session.compacted") {
+        await controller.onCompacted(event.properties.sessionID);
+      } else if (event.type === "session.deleted") {
+        controller.onSessionDeleted(event.properties.info.id);
+      }
+    },
+
+    config: async (config) => {
+      await controller.configure(config);
+    },
+  };
+}

package/src/plugin.ts

@@ -1,150 +1,12 @@
 /** OpenCode adapter for the Beads issue tracker. */
 
-import type { Plugin, PluginInput } from "@opencode-ai/plugin";
-import type { Agent, Part, SessionMessagesResponse } from "@opencode-ai/sdk";
-import {
-  createBeadsController,
-  resolveProjectDirectory,
-  type PluginRuntime,
-} from "./plugin-core";
-import { runBdPrime } from "./prime";
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isSessionMessage(value: unknown): boolean {
-  if (
-    !isRecord(value) ||
-    !isRecord(value.info) ||
-    (value.info.role !== "user" && value.info.role !== "assistant") ||
-    (value.info.agent !== undefined && typeof value.info.agent !== "string") ||
-    (value.info.system !== undefined && typeof value.info.system !== "string") ||
-    (value.info.model !== undefined &&
-      (!isRecord(value.info.model) ||
-        typeof value.info.model.providerID !== "string" ||
-        typeof value.info.model.modelID !== "string"))
-  ) {
-    return false;
-  }
-  if (!Array.isArray(value.parts)) return false;
-
-  return value.parts.every(
-    (part) =>
-      isRecord(part) &&
-      typeof part.type === "string" &&
-      (part.text === undefined || typeof part.text === "string")
-  );
-}
-
-function isAgent(value: unknown): boolean {
-  return (
-    isRecord(value) &&
-    typeof value.name === "string" &&
-    (value.mode === "subagent" || value.mode === "primary" || value.mode === "all")
-  );
-}
-
-/** Prevent the synthetic no-reply prompt from recursively triggering its own injection. */
-function isBeadsContextInjection(parts: ReadonlyArray<Part>): boolean {
-  return parts.some(
-    (part) =>
-      part.type === "text" &&
-      part.synthetic === true &&
-      part.text.includes("<beads-context>")
-  );
-}
-
-/** Adapt the official OpenCode client to the controller's small deterministic boundary. */
-export function createOpenCodeRuntime(client: PluginInput["client"]): PluginRuntime {
-  return {
-    async getMessages(projectDirectory, sessionID, limit) {
-      const response = await client.session.messages({
-        path: { id: sessionID },
-        query: { directory: projectDirectory, limit },
-      });
-      if (response.error !== undefined) throw response.error;
-      if (!Array.isArray(response.data) || !response.data.every(isSessionMessage)) {
-        throw new Error("OpenCode returned malformed session messages");
-      }
-      return response.data satisfies SessionMessagesResponse;
-    },
-
-    async getAgents(projectDirectory) {
-      const response = await client.app.agents({ query: { directory: projectDirectory } });
-      if (response.error !== undefined) throw response.error;
-      if (!Array.isArray(response.data) || !response.data.every(isAgent)) {
-        throw new Error("OpenCode returned malformed agents");
-      }
-      return response.data satisfies Agent[];
-    },
-
-    async prompt(projectDirectory, sessionID, body) {
-      const response = await client.session.prompt({
-        path: { id: sessionID },
-        query: { directory: projectDirectory },
-        body,
-      });
-      if (response.error !== undefined) throw response.error;
-      if (response.data === undefined) throw new Error("OpenCode returned no prompt result");
-    },
-
-    async prime(projectDirectory) {
-      return runBdPrime(projectDirectory);
-    },
-
-    async diagnose(diagnostic) {
-      const extra =
-        diagnostic.code === "config_collision"
-          ? { surface: diagnostic.surface, names: diagnostic.names }
-          : { sessionID: diagnostic.sessionID };
-      const response = await client.app.log({
-        query: { directory: diagnostic.directory },
-        body: {
-          service: "opencode-beads",
-          level: "warn",
-          message: diagnostic.code,
-          extra,
-        },
-      });
-      if (response.error !== undefined) throw response.error;
-      if (response.data === undefined) throw new Error("OpenCode returned no log result");
-    },
-  };
-}
+import type { Plugin } from "@opencode-ai/plugin";
+import { resolveProjectDirectory } from "./plugin-core";
+import { createBeadsHooks } from "./plugin-hooks";
+import { createOpenCodeRuntime } from "./opencode-runtime";
 
 export const BeadsPlugin: Plugin = async ({ client, directory, worktree }) => {
   const projectDirectory = resolveProjectDirectory(directory, worktree);
   const runtime = createOpenCodeRuntime(client);
-
-  const controller = await createBeadsController(runtime, projectDirectory);
-
-  return {
-    "chat.message": async (input, output) => {
-      if (isBeadsContextInjection(output.parts)) return;
-
-      await controller.onMessage(
-        {
-          sessionID: input.sessionID,
-          model: input.model,
-          agent: input.agent,
-        },
-        (context) => {
-          output.message.system = output.message.system
-            ? `${output.message.system}\n\n${context}`
-            : context;
-        }
-      );
-    },
-
-    event: async ({ event }) => {
-      if (event.type === "session.compacted") {
-        await controller.onCompacted(event.properties.sessionID);
-      }
-    },
-
-    config: async (config) => {
-      await controller.configure(config);
-    },
-  };
+  return createBeadsHooks(runtime, projectDirectory);
 };

package/src/prime.ts

@@ -1,4 +1,7 @@
+import { kill as killProcess } from "node:process";
+
 export const DEFAULT_PRIME_TIMEOUT_MS = 10_000;
+export const DEFAULT_PRIME_DRAIN_TIMEOUT_MS = 1_000;
 
 export class PrimeTimeoutError extends Error {
   constructor(timeoutMs: number) {
@@ -15,25 +18,55 @@ export class PrimeProcessError extends Error {
 }
 
 export interface PrimeProcess {
+  pid: number;
   stdout: ReadableStream<Uint8Array>;
   stderr: ReadableStream<Uint8Array>;
   exited: Promise<number>;
   kill(signal?: NodeJS.Signals): void;
+  killTree?(signal?: NodeJS.Signals): void;
 }
 
 export interface PrimeExecutionOptions {
   timeoutMs?: number;
+  drainTimeoutMs?: number;
   spawn?: (directory: string, args: readonly string[]) => PrimeProcess;
   scheduleTimeout?: (callback: () => void, delayMs: number) => () => void;
+  scheduleDrainTimeout?: (callback: () => void, delayMs: number) => () => void;
 }
 
 function spawnPrime(directory: string, args: readonly string[]): PrimeProcess {
-  return Bun.spawn(["bd", "prime", ...args], {
+  const child = Bun.spawn(["bd", "prime", ...args], {
     cwd: directory,
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
+    detached: true,
   });
+  let processGroupID: number | undefined;
+  if (process.platform !== "win32") {
+    const group = Bun.spawnSync(["ps", "-o", "pgid=", "-p", String(child.pid)], {
+      stdout: "pipe",
+      stderr: "ignore",
+      timeout: 100,
+    });
+    const parsed = Number.parseInt(new TextDecoder().decode(group.stdout).trim(), 10);
+    if (group.exitCode === 0 && parsed === child.pid && parsed > 1) processGroupID = parsed;
+  }
+
+  return {
+    pid: child.pid,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    exited: child.exited,
+    kill: (signal) => child.kill(signal),
+    killTree: (signal) => {
+      if (processGroupID !== undefined) {
+        killProcess(-processGroupID, signal);
+      } else {
+        child.kill(signal);
+      }
+    },
+  };
 }
 
 function scheduleTimeout(callback: () => void, delayMs: number): () => void {
@@ -41,15 +74,42 @@ function scheduleTimeout(callback: () => void, delayMs: number): () => void {
   return () => clearTimeout(timer);
 }
 
+function terminateProcessTree(child: PrimeProcess): void {
+  try {
+    (child.killTree ?? child.kill)("SIGKILL");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+      // Timeout remains authoritative if the process exited concurrently.
+    }
+  }
+}
+
+async function drainAfterKill(
+  completion: Promise<unknown>,
+  timeoutMs: number,
+  scheduler: (callback: () => void, delayMs: number) => () => void
+): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const cancelTimeout = scheduler(resolve, timeoutMs);
+    void completion.finally(() => {
+      cancelTimeout();
+      resolve();
+    });
+  });
+}
+
 async function runPrimeAttempt(
   directory: string,
   args: readonly string[],
   options: PrimeExecutionOptions = {}
 ): Promise<string> {
   const timeoutMs = options.timeoutMs ?? DEFAULT_PRIME_TIMEOUT_MS;
-  const process = (options.spawn ?? spawnPrime)(directory, args);
-  const stdout = new Response(process.stdout).text();
-  const stderr = new Response(process.stderr).text();
+  const drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_PRIME_DRAIN_TIMEOUT_MS;
+  const child = (options.spawn ?? spawnPrime)(directory, args);
+  const stdout = new Response(child.stdout).text();
+  const stderr = new Response(child.stderr).text();
 
   let timedOut = false;
   let rejectTimeout: (error: PrimeTimeoutError) => void = () => {};
@@ -58,11 +118,11 @@ async function runPrimeAttempt(
   });
   const cancelTimeout = (options.scheduleTimeout ?? scheduleTimeout)(() => {
     timedOut = true;
-    process.kill("SIGKILL");
+    terminateProcessTree(child);
     rejectTimeout(new PrimeTimeoutError(timeoutMs));
   }, timeoutMs);
 
-  const completion = Promise.all([process.exited, stdout, stderr]).then(
+  const completion = Promise.all([child.exited, stdout, stderr]).then(
     ([exitCode, output, errorOutput]) => {
       if (exitCode !== 0) throw new PrimeProcessError(exitCode, errorOutput);
       return output;
@@ -74,7 +134,11 @@ async function runPrimeAttempt(
   } finally {
     cancelTimeout();
     if (timedOut) {
-      await completion.catch(() => undefined);
+      await drainAfterKill(
+        completion.catch(() => undefined),
+        drainTimeoutMs,
+        options.scheduleDrainTimeout ?? scheduleTimeout
+      );
     }
   }
 }

package/vendor/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "repository": "https://github.com/gastownhall/beads.git",
-  "tag": "v1.1.0",
-  "commit": "8e4e59d39f3459a43cf21a3236a13eca4dd874f7",
+  "tag": "v1.1.2",
+  "commit": "20e493e569c922d1253bdeff068c5e56c94957fb",
   "sources": [
     {
       "source": "plugins/beads/agents/task-agent.md",