@ferris1225/pi-subagents 4.1.20 → 4.1.21

package/README.md

@@ -184,13 +184,12 @@ that delivers without another gate.
   where they are in `~/.pi/agent/pi-subagents-recovery.json`. Every later session
   start repeats that notice until you remove the artifacts.
 
-## Threads: wait, resume, stop
+## Threads: resume, stop
 
 Every dispatch returns a stable `#id`, which is the handle for the thread tools:
 
 | Tool               | What it does                                                                                                                                                                  |
 | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `subagent_wait`    | Block in-turn until already-dispatched run(s) settle and return their results (`id` or prefix; omit for all active runs).                                                        |
 | `subagent_control` | `resume` a parked or settled thread with its full retained context, optionally appending a new `objective`.                                                                     |
 | `subagent_stop`    | Destructively cancel, deliver the partial output, and retire the thread. Steering and follow-up messages still queued in the child are dropped so nothing can revive it later.  |
 
@@ -198,14 +197,14 @@ Every dispatch returns a stable `#id`, which is the handle for the thread tools:
 subagent_control({ action: "resume", id: 7, objective: "Finish the tests." });
 ```
 
-There is deliberately no status or polling tool. Every result delivers itself,
-the TUI widget shows what is live, and blocking is event-driven only: `wait:
-true` on a dispatch holds the turn for that call's results — the escape hatch
-for one-shot `pi -p` parents, which exit at end of turn and would otherwise
-never see them — and `subagent_wait` does the same for a run that is already
-in flight when the turn cannot proceed without it. Neither wait runs on a
-timer or a timeout the model picks: a waiter resolves the instant its run
-settles, a parked run answers immediately with its resume handle, and
+There is deliberately no status, polling, or wait tool. Every result delivers
+itself as a completion that wakes the main model, so a turn never blocks on a
+running subagent — keep working or end the turn, and the completion continues
+it. The one in-turn block is `wait: true` on a dispatch, which holds that call
+until the runs it started settle: the escape hatch for one-shot `pi -p`
+parents, which exit at end of turn and would otherwise never see them. That
+wait runs on no timer and no timeout the model picks: it resolves the instant
+its run settles, a parked run answers immediately with its resume handle, and
 aborting the turn is the escape hatch. Control operations are all bounded, so
 they never hang on a generation that is still settling.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferris1225/pi-subagents",
-  "version": "4.1.20",
+  "version": "4.1.21",
   "description": "A managed sub-agent team for pi: specialized roles, pre-commit documentation sync, retained threads, auto-fix chains, model fallback, and Git worktree isolation.",
   "type": "module",
   "license": "MIT",

package/src/dispatch.ts

@@ -151,12 +151,14 @@ function withReviewerFixStageAgent(agent: AgentConfig): AgentConfig {
 	};
 }
 
-/** Event-driven in-turn wait shared by dispatch `wait: true` and
- * subagent_wait: hold the turn until every listed run settles, then hand back
- * their result blocks. No timer: a waiter resolves the moment its run's result
- * registers (children are bounded by the idle watchdog), an already-parked run
- * answers immediately with its resume handle, and the turn's abort signal
- * remains the escape hatch. */
+/** In-turn wait behind dispatch `wait: true` — the escape hatch for one-shot
+ * `pi -p` parents that exit at end of turn: hold the call until every run it
+ * started settles, then hand back their result blocks. Interactive sessions
+ * never take this path; their results arrive as completion wake-ups. No
+ * timer: a waiter resolves the moment its run's result registers (children
+ * are bounded by the idle watchdog), an already-parked run answers
+ * immediately with its resume handle, and the turn's abort signal remains the
+ * escape hatch. */
 export async function awaitRunResults(
 	runtime: SubagentRuntime,
 	runIds: number[],

package/src/tools.ts

@@ -1,10 +1,9 @@
 /**
- * Thread controls around the subagent runtime: subagent_control (resume),
- * subagent_wait (event-driven in-turn wait), and destructive subagent_stop.
- * There is no status/poll tool — completions carry each result (with an
- * on-disk artifact when truncated); `wait: true` on dispatch blocks for runs
- * it starts, and subagent_wait blocks for runs already dispatched. Both waits
- * resolve the moment a run settles, never on a timer.
+ * Thread controls around the subagent runtime: subagent_control (resume) and
+ * destructive subagent_stop. There is no status/poll tool — completions carry
+ * each result (with an on-disk artifact when truncated) and wake the main
+ * model, so waiting is never a tool call; the only in-turn block is `wait:
+ * true` on a dispatch, for one-shot parents that exit at end of turn.
  */
 
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -13,11 +12,10 @@ import { Text } from "@earendil-works/pi-tui";
 import { existsSync } from "node:fs";
 import { Type } from "typebox";
 import { DEFAULT_MAX_RESULT_LINES, loadConfig } from "./config.ts";
-import { awaitRunResults } from "./dispatch.ts";
 import { removeThreadRecord } from "./durable.ts";
 import { formatCompletionBlock, matchRunIds } from "./format.ts";
 import { emptyUsage } from "./rpc-run.ts";
-import { formatTaskSummary, isRunActiveStatus, monitor } from "./monitor.ts";
+import { formatTaskSummary, monitor } from "./monitor.ts";
 import { persistRecoveryRecords, recoveryRecordFromFinalization } from "./recovery.ts";
 import type { SubagentRuntime, SubagentThread } from "./runtime.ts";
 import { CONTROL_QUIESCE_TIMEOUT_MS, projectResultsRoot, quiesced } from "./thread-lifecycle.ts";
@@ -112,56 +110,6 @@ export function registerLookupTools(pi: ExtensionAPI, runtime: SubagentRuntime):
 		},
 	});
 
-	const SubagentWaitParams = Type.Object({
-		id: Type.Optional(
-			Type.String({ description: "Run id or prefix to wait for (see dispatch output). Omit to wait for every active run." }),
-		),
-	});
-
-	pi.registerTool({
-		name: "subagent_wait",
-		label: "Subagent Wait",
-		description:
-			"Block until dispatched background run(s) settle, then return their results — resolves the moment a run settles, never on a timer.",
-		promptSnippet: "Block until dispatched runs settle; returns results the moment they finish.",
-		parameters: SubagentWaitParams,
-
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-			await runtime.durableRestore;
-			const config = await loadConfig(runtime.configPath);
-			const active = monitor.getRuns()
-				.filter((run) => isRunActiveStatus(run.status) || run.status === "parked")
-				.map((run) => run.id);
-			const requested = params.id?.trim();
-			// Settled runs stay addressable: a wait issued just after completion
-			// returns that result immediately instead of missing the run.
-			const targets = requested
-				? matchRunIds([...new Set([...active, ...runtime.settledRuns.keys()])], requested)
-				: active;
-			if (targets.length === 0) {
-				const activeList = active.map((id) => `#${id}`).join(", ");
-				return {
-					content: [{
-						type: "text",
-						text: requested
-							? `No subagent run matches "${requested}".${activeList ? ` Active runs: ${activeList}.` : ""}`
-							: "No active subagent runs to wait for.",
-					}],
-					details: {},
-				};
-			}
-			const blocks = await awaitRunResults(runtime, targets, signal, config.maxResultLines, ctx.cwd);
-			return { content: [{ type: "text", text: blocks }], details: {} };
-		},
-
-		renderCall(args, theme) {
-			return new Text(`${theme.fg("toolTitle", theme.bold("subagent_wait "))}${theme.fg("accent", args.id ? `#${args.id}` : "all")}`, 0, 0);
-		},
-		renderResult(result, _options, theme) {
-			return renderFirstLine(result, "subagent_wait ", theme);
-		},
-	});
-
 	// Cancel one or more active runs: aborts the queue controller, which
 	// terminates the child and delivers an aborted result (with whatever partial
 	// output it produced) so the main agent always knows the run stopped.