one-code-extension 0.1.4 → 0.3.1

package/extensions/workflow/run-manager.ts

@@ -15,14 +15,19 @@ import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import { join } from "node:path";
+import type { PermissionBridge } from "../permissions/subagent-gate.ts";
+import type { HookBridge } from "../hooks/subagent-bridge.ts";
+import type { SubagentDefault } from "../subagents/default-model.ts";
 import { AgentRunner } from "./agent-session.ts";
-import { createScriptGlobals, MAX_CONCURRENCY, MAX_AGENTS_PER_RUN, type ScriptRunState } from "./globals.ts";
+import { createRunAdmission, createScriptGlobals, MAX_CONCURRENCY, type ScriptRunState } from "./globals.ts";
 import { appendJournal, readJournal, ReplayCursor } from "./journal.ts";
+import { AgentRecordStore, previewValue } from "./records.ts";
 import { findSavedWorkflow } from "./saved-workflows.ts";
 import { parseWorkflowScript } from "./script-source.ts";
 import { runWorkflowScript } from "./vm-runtime.ts";
 import type { RunProgressEvent, RunStatus, WorkflowMeta } from "./types.ts";
 import { WorkflowScriptError } from "./types.ts";
+import type { ViewerRunSnapshot } from "./viewer.ts";
 
 const WALL_CLOCK_CAP_MS = 30 * 60 * 1000;
 const RECENT_EVENTS_CAP = 200;
@@ -36,8 +41,18 @@ export interface StartRunOptions {
 	cwd: string;
 	sessionDir: string;
 	defaultModel: unknown;
-	configuredDefaultModel?: string;
+	configuredDefault?: SubagentDefault;
 	defaultEffort?: string;
+	/** Parent permission bridge, threaded into every agent's gate (see AgentRunnerOptions). */
+	getPermissionBridge?: () => PermissionBridge | undefined;
+	/** The parent hooks extension's bridge (hooks/subagent-bridge.ts), threaded into every workflow agent. */
+	getHookBridge?: () => HookBridge | undefined;
+	/** Each finished agent's dollar cost, for the footer's all-in total (review S13). */
+	onUsage?: (cost: number) => void;
+	/** Models this account cannot run, learned this session (lib/model-unusable.ts); the runner resolves around them. */
+	unusableModels?: () => ReadonlySet<string>;
+	/** An agent's provider refused its model: published so every picker skips it (lib/model-unusable.ts). */
+	onModelUnusable?: (model: string, reason: string) => void;
 }
 
 export class RunHandle extends EventEmitter {
@@ -47,6 +62,8 @@ export class RunHandle extends EventEmitter {
 	readonly startedAt = Date.now();
 	finishedAt?: number;
 	readonly recentEvents: string[] = [];
+	/** Per-agent records folded from the event stream (the viewer's data). */
+	readonly agents = new AgentRecordStore();
 	state?: ScriptRunState;
 	/** Settles when the run reaches a terminal status (never rejects). */
 	finished!: Promise<RunHandle>;
@@ -75,7 +92,13 @@ export class RunHandle extends EventEmitter {
 		return this.controller.signal;
 	}
 
+	/** The one place the run's signal is fired: every agent, child worker and script hangs off it. */
+	private stopWork(): void {
+		this.controller.abort();
+	}
+
 	record(event: RunProgressEvent): void {
+		this.agents.apply(event);
 		const line = formatEvent(event);
 		if (line) {
 			this.recentEvents.push(line);
@@ -89,7 +112,7 @@ export class RunHandle extends EventEmitter {
 		// First reason wins — a user stop shouldn't be masked by the script's
 		// consequent "aborted" error.
 		this.errorMessage ??= reason;
-		this.controller.abort();
+		this.stopWork();
 	}
 
 	finish(status: RunStatus, result?: unknown, errorMessage?: string): void {
@@ -98,6 +121,9 @@ export class RunHandle extends EventEmitter {
 		this.result = result;
 		this.errorMessage ??= errorMessage;
 		this.finishedAt = Date.now();
+		// A script can return without awaiting every agent()/workflow() promise.
+		// Terminal runs must not leave those agents or child workers running.
+		this.stopWork();
 		this.emit("done", this);
 		this.resolveFinished(this);
 	}
@@ -119,6 +145,21 @@ function formatEvent(event: RunProgressEvent): string | undefined {
 	}
 }
 
+/** Immutable view of a run for the pure renderers (viewer + status strip). */
+function snapshotRun(handle: RunHandle): ViewerRunSnapshot {
+	return {
+		runId: handle.runId,
+		name: handle.meta.name,
+		description: handle.meta.description,
+		status: handle.status,
+		startedAt: handle.startedAt,
+		finishedAt: handle.finishedAt,
+		errorMessage: handle.errorMessage,
+		agents: handle.agents.list(),
+		declaredPhases: handle.meta.phases?.map((phase) => phase.title),
+	};
+}
+
 export class WorkflowRunManager {
 	private runs = new Map<string, RunHandle>();
 
@@ -126,6 +167,16 @@ export class WorkflowRunManager {
 		return [...this.runs.values()];
 	}
 
+	/**
+	 * Runs as viewer snapshots, newest first (the display order). `limit`
+	 * keeps per-tick consumers (the status strip) from copying every run and
+	 * agent record of the session for a handful of display rows.
+	 */
+	snapshots(limit?: number): ViewerRunSnapshot[] {
+		const handles = limit !== undefined ? this.list().slice(-limit) : this.list();
+		return handles.map(snapshotRun).reverse();
+	}
+
 	get(runId: string): RunHandle | undefined {
 		return this.runs.get(runId);
 	}
@@ -195,16 +246,20 @@ export class WorkflowRunManager {
 			runner = await AgentRunner.create({
 				cwd: options.cwd,
 				defaultModel: options.defaultModel,
-				configuredDefaultModel: options.configuredDefaultModel,
+				configuredDefault: options.configuredDefault,
 				defaultEffort: options.defaultEffort as never,
 				onNotice: (message) => handle.record({ type: "log", text: `⚠ ${message}` }),
+				getPermissionBridge: options.getPermissionBridge,
+				getHookBridge: options.getHookBridge,
+				onUsage: options.onUsage,
+				unusableModels: options.unusableModels,
+				onModelUnusable: options.onModelUnusable,
 			});
 
 			const { globals, state } = createScriptGlobals({
-				agentCall: (prompt, opts) => runner!.run(prompt, opts, handle.signal),
+				agentCall: (prompt, opts, onUpdate) => runner!.run(prompt, opts, handle.signal, onUpdate),
 				args: options.args,
-				budgetTotal: options.tokenBudget,
-				concurrency: defaultConcurrency(),
+				admission: createRunAdmission({ budgetTotal: options.tokenBudget, concurrency: defaultConcurrency() }),
 				signal: handle.signal,
 				onEvent: (event) => handle.record(event),
 				onJournal: (entry) => appendJournal(journalPath, entry),
@@ -213,7 +268,7 @@ export class WorkflowRunManager {
 			});
 			handle.state = state;
 
-			const result = await runWorkflowScript(body, globals, `${handle.meta.name}.js`);
+			const result = await runWorkflowScript(body, globals, `${handle.meta.name}.js`, { signal: handle.signal });
 			handle.finish(handle.signal.aborted ? "aborted" : "completed", result);
 		} catch (error) {
 			const aborted = handle.signal.aborted;
@@ -253,26 +308,29 @@ export class WorkflowRunManager {
 
 		const { meta, body } = parseWorkflowScript(source);
 		const state = parentState();
-		const remainingAgents = Math.max(0, MAX_AGENTS_PER_RUN - state.agentCount());
-		const remainingBudget =
-			options.tokenBudget === null ? null : Math.max(0, options.tokenBudget - state.outputTokens());
 
 		// Child calls are not journaled in v1: resume replays the parent's own
 		// agent() prefix only. Progress is forwarded under a "▸ name" phase.
 		const { globals } = createScriptGlobals({
-			agentCall: (prompt, opts) => runner.run(prompt, opts, parent.signal),
+			agentCall: (prompt, opts, onUpdate) => runner.run(prompt, opts, parent.signal, onUpdate),
 			args: childArgs,
-			budgetTotal: remainingBudget,
-			concurrency: defaultConcurrency(),
-			maxAgents: remainingAgents,
+			// One budget, limiter and agent cap for the whole tree.
+			admission: state.admission,
 			signal: parent.signal,
-			onEvent: (event) => parent.record({ ...event, phase: `▸ ${meta.name}${event.phase ? ` · ${event.phase}` : ""}` }),
+			onEvent: (event) =>
+				parent.record({
+					...event,
+					// source keeps child records distinct (a child restarts callIndex at
+					// 0); the phase prefix is the visible grouping in widget and viewer.
+					source: meta.name,
+					phase: `▸ ${meta.name}${event.phase ? ` · ${event.phase}` : ""}`,
+				}),
 		});
-		return runWorkflowScript(body, globals, `${label}.js`);
+		return runWorkflowScript(body, globals, `${label}.js`, { signal: parent.signal });
 	}
 }
 
-export function defaultConcurrency(): number {
+function defaultConcurrency(): number {
 	return Math.min(MAX_CONCURRENCY, Math.max(1, os.cpus().length - 2));
 }
 
@@ -285,19 +343,10 @@ export function buildRunReport(handle: RunHandle): string {
 		: `${duration}s`;
 
 	if (handle.status === "completed") {
-		let resultText: string;
-		if (typeof handle.result === "string") {
-			resultText = handle.result;
-		} else if (handle.result === undefined) {
-			resultText = "(script returned no value)";
-		} else {
-			try {
-				resultText = JSON.stringify(handle.result, null, 2);
-			} catch {
-				resultText = String(handle.result);
-			}
-		}
-		if (resultText.length > RESULT_CAP) resultText = `${resultText.slice(0, RESULT_CAP)}\n… (truncated)`;
+		const resultText =
+			handle.result === undefined
+				? "(script returned no value)"
+				: previewValue(handle.result, RESULT_CAP, "\n… (truncated)");
 		return `Workflow **${handle.meta.name}** (${handle.runId}) completed — ${statsLine}.\n\nResult:\n${resultText}`;
 	}
 

package/extensions/workflow/saved-workflows.ts

@@ -10,6 +10,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { parseWorkflowScript } from "./script-source.ts";
 import type { SavedWorkflow } from "./types.ts";
+import { claudeUserDir } from "../lib/paths.ts";
 
 function scanDir(dir: string, source: SavedWorkflow["source"]): SavedWorkflow[] {
 	if (!existsSync(dir)) return [];
@@ -29,7 +30,7 @@ function scanDir(dir: string, source: SavedWorkflow["source"]): SavedWorkflow[]
 }
 
 export function workflowDirs(cwd: string, home: string): { project: string; user: string } {
-	return { project: join(cwd, ".claude", "workflows"), user: join(home, ".claude", "workflows") };
+	return { project: join(cwd, ".claude", "workflows"), user: join(claudeUserDir(home), "workflows") };
 }
 
 export function discoverSavedWorkflows(cwd: string, home: string): SavedWorkflow[] {

package/extensions/workflow/script-worker.mjs

@@ -0,0 +1,110 @@
+/** Plain JS so workers work in the packaged app without pi's TypeScript loader. */
+import vm from "node:vm";
+import { parentPort, workerData } from "node:worker_threads";
+
+class WorkflowScriptError extends Error {}
+const pending = new Map();
+let sequence = 0;
+let notices = 0;
+const send = (message) => parentPort.postMessage(message);
+// Shared with the host (vm-runtime.ts): [0] output tokens spent, [1] heartbeat.
+const shared = new BigInt64Array(workerData.shared);
+const SLOT_SPENT = 0;
+const SLOT_HEARTBEAT = 1;
+const budget = Object.freeze({
+	total: workerData.total,
+	spent: () => Number(Atomics.load(shared, SLOT_SPENT)),
+	remaining: () => workerData.total === null ? Infinity : Math.max(0, workerData.total - Number(Atomics.load(shared, SLOT_SPENT))),
+});
+
+function call(method, args) {
+	if (pending.size >= workerData.maxPending) {
+		return Promise.reject(new WorkflowScriptError(`Workflow agent limit reached (${workerData.maxPending} agent()/workflow() calls in flight per run)`));
+	}
+	const id = sequence++;
+	return new Promise((resolve, reject) => {
+		pending.set(id, { resolve, reject });
+		try { send({ type: "call", id, method, args }); }
+		catch (error) { pending.delete(id); reject(new WorkflowScriptError(error.message)); }
+	});
+}
+
+parentPort.on("message", ({ id, value, error }) => {
+	const request = pending.get(id);
+	if (!request) return;
+	pending.delete(id);
+	if (error) request.reject(error.fatal ? new WorkflowScriptError(error.message) : new Error(error.message));
+	else request.resolve(value);
+});
+
+// Callback combinators must stay in the script thread: functions cannot cross
+// the RPC boundary. Fatal admission errors retain their identity across RPC.
+async function parallel(thunks) {
+	if (!Array.isArray(thunks)) throw new WorkflowScriptError("parallel() takes an array of functions");
+	if (thunks.length > workerData.maxItems) throw new WorkflowScriptError(`parallel() accepts at most ${workerData.maxItems} items (got ${thunks.length})`);
+	const settled = await Promise.allSettled(thunks.map((thunk) => {
+		try {
+			if (typeof thunk !== "function") throw new WorkflowScriptError("parallel() items must be functions returning promises");
+			return Promise.resolve(thunk());
+		} catch (error) { return Promise.reject(error); }
+	}));
+	return settled.map((result) => {
+		if (result.status === "fulfilled") return result.value;
+		if (result.reason instanceof WorkflowScriptError) throw result.reason;
+		return null;
+	});
+}
+
+async function pipeline(items, ...stages) {
+	if (!Array.isArray(items)) throw new WorkflowScriptError("pipeline() takes an array of items");
+	if (items.length > workerData.maxItems) throw new WorkflowScriptError(`pipeline() accepts at most ${workerData.maxItems} items (got ${items.length})`);
+	if (stages.some((stage) => typeof stage !== "function")) throw new WorkflowScriptError("pipeline() stages must be functions");
+	return Promise.all(items.map(async (item, index) => {
+		let prev = item;
+		for (const stage of stages) {
+			try { prev = await stage(prev, item, index); }
+			catch (error) {
+				if (error instanceof WorkflowScriptError) throw error;
+				return null;
+			}
+		}
+		return prev;
+	}));
+}
+
+function notice(type, value) {
+	// Bound message traffic if a script loops around synchronous log/phase.
+	if (++notices > workerData.maxNotices) {
+		throw new WorkflowScriptError(`Too many workflow progress messages without yielding (${workerData.maxNotices} log()/phase() calls between two heartbeats)`);
+	}
+	send({ type, value: String(value) });
+}
+const log = (value) => notice("log", value);
+const globals = {
+	agent: (prompt, opts) => call("agent", [prompt, opts]),
+	workflow: (ref, args) => call("workflow", [ref, args]),
+	parallel, pipeline,
+	phase: (title) => notice("phase", title),
+	log,
+	console: { log, info: log, warn: (value) => log(`[warn] ${String(value)}`), error: (value) => log(`[error] ${String(value)}`) },
+	args: workerData.args,
+	budget,
+};
+
+// A busy loop or microtask spin starves this timer, so the counter stops.
+const heartbeat = setInterval(() => { notices = 0; Atomics.add(shared, SLOT_HEARTBEAT, 1n); }, 25);
+// First beat before the script runs: from here on the host applies the script
+// timeout, not the startup grace — a script that spins from its first line is
+// caught just like one that spins after an await.
+Atomics.add(shared, SLOT_HEARTBEAT, 1n);
+try {
+	const context = vm.createContext({ __workflow__: globals }, { codeGeneration: { strings: false, wasm: false } });
+	const script = new vm.Script(workerData.source, { filename: workerData.filename });
+	const value = await script.runInContext(context);
+	send({ type: "result", value });
+} catch (error) {
+	send({ type: "error", message: error?.message ?? String(error) });
+} finally {
+	clearInterval(heartbeat);
+	parentPort.close();
+}

package/extensions/workflow/types.ts

@@ -51,8 +51,26 @@ export interface AgentCallResult {
 	worktreePath?: string;
 }
 
+/** One tool call an agent made, kept structured so the viewer owns the formatting. */
+export interface ToolActivity {
+	name: string;
+	/** One-line argument summary (summarizeArgs output); absent when unavailable. */
+	argsSummary?: string;
+}
+
+/** Mid-run facts an executing agent reports back (resolved model, tool calls). */
+export interface AgentRunUpdate {
+	/** Resolved model id, known once per run. */
+	model?: string;
+	tool?: ToolActivity;
+}
+
 /** The one injection point globals.ts needs: something that runs a real agent. */
-export type AgentCallFn = (prompt: string, opts: AgentCallOptions) => Promise<AgentCallResult>;
+export type AgentCallFn = (
+	prompt: string,
+	opts: AgentCallOptions,
+	onUpdate?: (update: AgentRunUpdate) => void,
+) => Promise<AgentCallResult>;
 
 /** One line of journal.jsonl. */
 export interface JournalEntry {
@@ -71,16 +89,64 @@ export interface BudgetSnapshot {
 
 export type RunStatus = "running" | "completed" | "failed" | "aborted";
 
-/** Progress events a run emits (consumed by the widget, /workflows, onUpdate). */
-export interface RunProgressEvent {
-	type: "log" | "phase" | "agentStart" | "agentEnd";
-	text?: string;
+/** Fields shared by every per-agent progress event. */
+export interface AgentEventBase {
+	callIndex: number;
+	label: string;
 	phase?: string;
-	label?: string;
-	callIndex?: number;
+}
+
+/**
+ * Progress events a run emits (consumed by the widget, /workflows, onUpdate).
+ * A discriminated union so producers (globals.ts) and consumers (records.ts,
+ * run-manager's formatEvent) agree on which fields each event carries.
+ *
+ * `source` marks nested-workflow provenance (the child workflow's name,
+ * stamped by run-manager's runChild). A child restarts callIndex at 0, so
+ * records must key on (source, callIndex), never callIndex alone.
+ */
+export type RunProgressEvent = (
+	| { type: "log"; text: string; phase?: string }
+	| { type: "phase"; phase: string }
+	| ({ type: "agentStart"; prompt: string } & AgentEventBase)
+	/** Mid-run update; a bare one may lack the label (records tolerates that). */
+	| ({ type: "agentUpdate"; callIndex: number; label?: string; phase?: string } & AgentRunUpdate)
+	| ({
+			type: "agentEnd";
+			tokens?: AgentTokens;
+			cost?: number;
+			replayed?: boolean;
+			/** Replayed ends carry the prompt (there was no agentStart). */
+			prompt?: string;
+			/** Truncated preview of the produced value. */
+			preview?: string;
+			/** Failure message; presence means the agent failed. */
+			text?: string;
+	  } & AgentEventBase)
+) & { source?: string };
+
+/** Per-agent state folded from RunProgressEvents (viewer's detail source). */
+export interface AgentRecord {
+	callIndex: number;
+	/** Nested workflow() provenance: the child workflow's name, if any. */
+	source?: string;
+	label: string;
+	phase?: string;
+	prompt?: string;
+	model?: string;
+	status: "running" | "done" | "failed" | "replayed";
 	tokens?: AgentTokens;
 	cost?: number;
-	replayed?: boolean;
+	startedAt?: number;
+	finishedAt?: number;
+	/** Tool calls made, oldest first, capped at ACTIVITY_CAP. */
+	activity: ToolActivity[];
+	/** Total tool calls made, uncapped (activity keeps only the tail). */
+	toolCalls: number;
+	/** Truncated preview of the agent's returned value. */
+	outcome?: string;
+	/** Failure message when status === "failed". */
+	error?: string;
 }
 
 /** A saved workflow discovered in .claude/workflows/ or ~/.claude/workflows/. */