@ferris1225/pi-subagents 4.1.24 → 4.2.1

package/src/monitor.ts

@@ -20,7 +20,6 @@ import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
 export type RunStatus = "queued" | "running" | "interrupting" | "parked" | "done" | "failed";
 export type ContinuationKind = "resume-retained" | "resume-appended";
-export type WorkflowStageStatus = "done" | "active" | "pending" | "changes" | "failed";
 
 /** Why a queued run has produced no output yet. Three genuinely different
  * situations used to be reported as one "queued": waiting for a free process
@@ -32,19 +31,6 @@ export type WorkflowStageStatus = "done" | "active" | "pending" | "changes" | "f
  * "queued"; cleared on every transition out of it. */
 export type RunWaitReason = "process-slot" | "repository-lane" | "starting";
 
-/** Ephemeral projection of one real or currently planned managed stage. It is
- * live monitor state only; durable results remain the per-run chain records. */
-export interface WorkflowStage {
-	agent: string;
-	relation: string;
-	status: WorkflowStageStatus;
-	/** Telemetry snapshot frozen when the stage settled (the live child row
-	 * leaves the monitor at that moment); the active stage reads its live child. */
-	model?: string;
-	usage?: UsageStats;
-	elapsedMs?: number;
-}
-
 export function isRunActiveStatus(status: RunStatus): boolean {
 	return status === "queued" || status === "running" || status === "interrupting";
 }
@@ -88,45 +74,19 @@ export interface RunView {
 	endedAt?: number;
 	/** Why this generation reused retained context, shown in the widget/status. */
 	continuationKind?: ContinuationKind;
-	/** When set, this is an internal managed-workflow step. */
-	groupId?: string;
-	/** Human-readable role within a workflow, e.g. "final review" or "final documentation sync". */
-	relationLabel?: string;
-	/** Stable owning run whose row represents the whole managed workflow. */
-	parentRunId?: number;
-	/** This stable top-level row currently owns a multi-stage managed workflow.
-	 * Its elapsed time is workflow-wide; active child rows own stage telemetry. */
-	managedWorkflow?: boolean;
-	/** Live-only stage timeline retained on the parent while completed internal
-	 * child rows leave the monitor. */
-	workflowStages?: WorkflowStage[];
 }
 
-/** Optional metadata for documenter/reviewer/fix children of a stable parent run. */
+/** Extra metadata for a run whose row must carry isolation or resume context. */
 export interface RunChainMeta {
-	groupId?: string;
-	relationLabel?: string;
-	parentRunId?: number;
 	isolation?: IsolationMode;
 	worktreeId?: string;
 	continuationKind?: ContinuationKind;
 	/** Initial wait reason; defaults to "process-slot" (a fresh dispatch enters
-	 * the process queue). Workflow-internal children pass "starting" because
-	 * they spawn immediately and never wait for a slot. */
+	 * the process queue). Children spawned outside the queue pass "starting"
+	 * because they never wait for a slot. */
 	waitReason?: RunWaitReason;
 }
 
-/** Ephemeral activity of the parent pi model while its agent loop runs: the
- * live model/thinking ref and a one-line "what is it doing now". Not a run —
- * no id, usage, or chain machinery; the view disappears when the loop settles. */
-export interface MainActivity {
-	model?: string;
-	thinking?: string;
-	activity?: string;
-	/** Epoch ms when the current agent loop started. */
-	activeSince: number;
-}
-
 // ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
@@ -494,71 +454,6 @@ export class MonitorStore {
 	private runs: RunView[] = [];
 	private nextId = 1;
 	private subscribers = new Set<() => void>();
-	private mainModel?: string;
-	private mainThinking?: string;
-	private mainActivity?: string;
-	private mainActiveSince?: number;
-
-	// --- parent pi model activity ------------------------------------------
-	// Fed by the parent session's extension events (agent loop, streaming,
-	// tool executions); rendered as the widget's first line. Change-guarded so
-	// per-token streaming deltas do not flood subscribers.
-
-	setMainModel(model?: string): void {
-		if (!model || this.mainModel === model) return;
-		this.mainModel = model;
-		this.notify();
-	}
-
-	setMainThinking(thinking?: string): void {
-		if (!thinking || this.mainThinking === thinking) return;
-		this.mainThinking = thinking;
-		this.notify();
-	}
-
-	setMainActivity(text: string): void {
-		const activity = sanitizeActivityText(text) || undefined;
-		if (!activity || this.mainActivity === activity) return;
-		this.mainActivity = activity;
-		this.notify();
-	}
-
-	/** Record the main model starting a tool; the activity shows the tool's
-	 * most telling argument, same vocabulary as subagent rows. */
-	recordMainToolStart(toolName: string, activity: string): void {
-		const safeToolName = sanitizeActivityText(toolName) || "tool";
-		this.setMainActivity(activity || safeToolName);
-	}
-
-	/** Record a failed main-model tool; successful completions keep their last
-	 * activity until the next model event supplies a better description. */
-	recordMainToolEnd(toolName: string, isError: boolean): void {
-		if (isError) this.setMainActivity(`✗ ${sanitizeActivityText(toolName) || "tool"} failed`);
-	}
-
-	/** Track the parent agent loop: started at agent_start, cleared when the
-	 * loop settles (agent_end / agent_settled). */
-	setMainAgentActive(active: boolean): void {
-		if ((this.mainActiveSince !== undefined) === active) return;
-		this.mainActiveSince = active ? Date.now() : undefined;
-		this.mainActivity = undefined;
-		this.notify();
-	}
-
-	/** Live view of the parent model while its agent loop runs; undefined when idle. */
-	getMainActivity(): MainActivity | undefined {
-		if (this.mainActiveSince === undefined) return undefined;
-		return {
-			...(this.mainModel ? { model: this.mainModel } : {}),
-			...(this.mainThinking ? { thinking: this.mainThinking } : {}),
-			...(this.mainActivity ? { activity: this.mainActivity } : {}),
-			activeSince: this.mainActiveSince,
-		};
-	}
-
-	isMainAgentActive(): boolean {
-		return this.mainActiveSince !== undefined;
-	}
 
 	beginTurn(): void {
 		// Clear finished runs from a previous turn, but keep active and parked
@@ -608,9 +503,6 @@ export class MonitorStore {
 			waitReason: meta?.waitReason ?? "process-slot",
 			usage: emptyUsage(),
 			elapsedMs: 0,
-			...(meta?.groupId ? { groupId: meta.groupId } : {}),
-			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
-			...(meta?.parentRunId !== undefined ? { parentRunId: meta.parentRunId } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined, ...(meta.worktreeId ? { worktreeId: meta.worktreeId } : {}) } : {}),
 			...(meta?.continuationKind ? { continuationKind: meta.continuationKind } : {}),
 		});
@@ -649,27 +541,6 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	/** Switch a stable top-level row from one model run to workflow ownership.
-	 * The original role remains for identity; child rows show stage telemetry. */
-	setManagedWorkflow(id: number, active: boolean): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.managedWorkflow = active || undefined;
-		if (!active) run.workflowStages = undefined;
-		this.notify();
-	}
-
-	/** Replace the live workflow projection atomically so renderers never observe
-	 * a half-updated fix/re-review plan. */
-	setWorkflowStages(id: number, stages: readonly WorkflowStage[]): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.workflowStages = stages.length > 0
-			? stages.map((stage) => ({ ...stage }))
-			: undefined;
-		this.notify();
-	}
-
 	setUsage(id: number, usage: UsageStats, model?: string): void {
 		const run = this.find(id);
 		if (!run) return;
@@ -806,8 +677,6 @@ export class MonitorStore {
 		run.waitReason = "process-slot";
 		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.managedWorkflow = undefined;
-		run.workflowStages = undefined;
 		run.activeSince = undefined;
 		run.endedAt = undefined;
 		run.elapsedMs = Math.max(run.elapsedMs, meta?.elapsedMs ?? 0);
@@ -825,10 +694,6 @@ export class MonitorStore {
 	 * finishRun calls from the old session remain safe no-ops. */
 	clear(): void {
 		this.runs = [];
-		this.mainModel = undefined;
-		this.mainThinking = undefined;
-		this.mainActivity = undefined;
-		this.mainActiveSince = undefined;
 		this.notify();
 	}
 
@@ -854,14 +719,13 @@ export class MonitorStore {
 
 	summarize(run: RunView): string {
 		const usage = formatUsageCompact(run.usage);
-		const parts = [run.managedWorkflow ? `${run.agent} workflow` : run.agent];
+		const parts = [run.agent];
 		const continuation = continuationLabel(run.continuationKind);
 		if (continuation) parts.push(continuation);
-		if (run.relationLabel) parts.push(run.relationLabel);
-		if (!run.managedWorkflow && run.model) parts.push(run.model);
-		if (!run.managedWorkflow && run.thinking) parts.push(`thinking ${run.thinking}`);
+		if (run.model) parts.push(run.model);
+		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);
-		if (!run.managedWorkflow && usage) parts.push(usage);
+		if (usage) parts.push(usage);
 		const elapsed = formatElapsed(run);
 		if (elapsed) parts.push(elapsed);
 		return parts.join(" · ");

package/src/prompt.ts

@@ -20,38 +20,21 @@ export function buildDelegationDirective(
 
 	const catalog = agents.map(formatCatalogEntry).join("\n");
 	const hasExplorer = agents.some((agent) => agent.name === "explorer");
-	const hasWorker = agents.some((agent) => agent.name === "worker");
-	const hasCleaner = agents.some((agent) => agent.name === "cleaner");
-	const hasDocumenter = agents.some((agent) => agent.name === "documenter");
-	const hasReviewer = agents.some((agent) => agent.name === "reviewer");
-	const hasSynthesizer = agents.some((agent) => agent.name === "synthesizer");
-	const codeWriterNames = [
-		...(hasWorker ? ["worker"] : []),
-		...(hasCleaner ? ["cleaner"] : []),
-	];
+	const hasExecutor = agents.some((agent) => agent.name === "executor");
 
 	const dispatchRules = [
-		`Delegate aggressively: child contexts are cheap, yours is scarce. Inline only trivial work — a lookup, a single focused edit, an answer already in context${hasWorker ? "; default every non-trivial implementation, fix, refactor, or test task to `worker`" : ""}.`,
+		`Delegate aggressively: child contexts are cheap, yours is scarce. Inline only trivial work — a lookup, a single focused edit, an answer already in context${hasExecutor ? "; default every non-trivial delegated task (implementation, fix, refactor, test, cleanup, docs sync, result merging) to `executor`" : ""}.`,
 		...(hasExplorer
 			? [
 				"`explorer`: split a broad question into parallel explorers with disjoint scopes. Its findings are leads, never proof — re-read load-bearing files before acting yourself (a child you brief re-verifies).",
 			]
 			: []),
-		...(hasCleaner
-			? ["`cleaner`: dispatch for requested cleanup AND proactively when finished work leaves dead code or duplication. Your brief is its edit authorization — every safe proven cut applies without per-item approval; never a gate. Scope: the uncommitted diff, or whatever your brief names (Git range, directory)."]
-			: []),
-		...(hasDocumenter
-			? ["`documenter`: standalone docs/comment work; dispatch it proactively when a change — yours or a child's — leaves README/docs/comment drift no writer already synced; cheap and may make zero edits."]
-			: []),
-		...(hasReviewer
+		...(hasExecutor
 			? [
-				`\`reviewer\`: read-only assessments and gates${codeWriterNames.length > 0 ? `; successful ${codeWriterNames.join("/")} runs get one fresh gate, and failing gates are fixed by the reviewer itself in bounded fix/re-review rounds (a still-failing gate returns to you). Pass \`review: "none"\` for mechanical, low-risk edits you verify yourself; keep the default gate whenever behavior can change` : ""}. Advisory output has no VERDICT and cannot authorize edits.`,
+				"`executor`: brief it as the edit authorization. For cleanup, name the scope (uncommitted diff, Git range, directory) — every safe proven cut applies without per-item approval; finding no safe cut is a valid result. After a wide fan-out, pass the result-artifact paths to one executor and read its merged brief instead of every result yourself.",
 			]
 			: []),
-		...(hasSynthesizer
-			? ["`synthesizer`: after a wide fan-out, pass the result-artifact paths to one synthesizer and read its brief instead of every result yourself."]
-			: []),
-		`Parallelize by default: map the todo list onto ONE \`tasks\` dispatch. One child owns one deliverable and its files; only genuinely dependent work waits for its prerequisite.`,
+		"Parallelize by default: map the todo list onto ONE `tasks` dispatch. One child owns one deliverable and its files; only genuinely dependent work waits for its prerequisite.",
 		"Brief each child completely — goal, exact paths, constraints, expected output; it has no conversation memory and cannot delegate. Resume parked threads with `subagent_control resume`.",
 	];
 
@@ -63,13 +46,7 @@ export function buildDelegationDirective(
 
 	const verificationRules = [
 		"Never report an unrun check as passed; surface unavailable checks and pre-existing failures, and inspect actual changes before reporting completion.",
-		...(hasReviewer
-			? [
-				"A REVIEW_FAIL from a gate you dispatched directly returns its findings to you: fix them inline or via a briefed worker without waiting for the user, then re-verify ONCE. If the gate still fails, report the remaining findings and move on — never loop gate dispatches.",
-				"Multi-model cross-review only when explicitly requested or for high-risk security, FFI, migration, or concurrency changes.",
-			]
-			: []),
-		"Commit or push only when explicitly requested, applicable checks pass, and no review finding remains unresolved.",
+		"Commit or push only when explicitly requested and applicable checks pass.",
 	];
 
 	return `
@@ -86,6 +63,6 @@ ${bullets(dispatchRules)}
 Result handoff:
 ${bullets(handoffRules)}
 
-Review and verification:
+Verification:
 ${bullets(verificationRules)}`;
 }