@tekmidian/pai 0.36.2 → 0.38.0

package/dist/daemon-mcp/index.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { t as PaiClient } from "../ipc-client-BmypMNYk.mjs";
 import { o as loadConfig } from "../config-B64vFg14.mjs";
+import { A as ledgerPath, D as ledgerSummary, E as loadStatus, P as readWorkersSection, _ as testProvider, a as setClass, c as unsetClass, f as psOutput, g as runWorker, h as runChain, i as removeProvider, j as workersLogDir, l as updateProvider, n as classTargetText, o as setProviderEnabled, p as replayOutput, r as describeProviders, s as setWorkersEnabled, t as addProvider, u as useProvider, x as sayToWorker } from "../providers-DUshcB-d.mjs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -1406,6 +1407,97 @@ function handleIntersectionResults(result, left, right) {
 	result.value = merged.data;
 	return result;
 }
+const $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+	$ZodType.init(inst, def);
+	inst._zod.parse = (payload, ctx) => {
+		const input = payload.value;
+		if (!isPlainObject(input)) {
+			payload.issues.push({
+				expected: "record",
+				code: "invalid_type",
+				input,
+				inst
+			});
+			return payload;
+		}
+		const proms = [];
+		const values = def.keyType._zod.values;
+		if (values) {
+			payload.value = {};
+			const recordKeys = /* @__PURE__ */ new Set();
+			for (const key of values) if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+				recordKeys.add(typeof key === "number" ? key.toString() : key);
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[key] = result.value;
+				}
+			}
+			let unrecognized;
+			for (const key in input) if (!recordKeys.has(key)) {
+				unrecognized = unrecognized ?? [];
+				unrecognized.push(key);
+			}
+			if (unrecognized && unrecognized.length > 0) payload.issues.push({
+				code: "unrecognized_keys",
+				input,
+				inst,
+				keys: unrecognized
+			});
+		} else {
+			payload.value = {};
+			for (const key of Reflect.ownKeys(input)) {
+				if (key === "__proto__") continue;
+				let keyResult = def.keyType._zod.run({
+					value: key,
+					issues: []
+				}, ctx);
+				if (keyResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+				if (typeof key === "string" && number$1.test(key) && keyResult.issues.length) {
+					const retryResult = def.keyType._zod.run({
+						value: Number(key),
+						issues: []
+					}, ctx);
+					if (retryResult instanceof Promise) throw new Error("Async schemas not supported in object keys currently");
+					if (retryResult.issues.length === 0) keyResult = retryResult;
+				}
+				if (keyResult.issues.length) {
+					if (def.mode === "loose") payload.value[key] = input[key];
+					else payload.issues.push({
+						code: "invalid_key",
+						origin: "record",
+						issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+						input: key,
+						path: [key],
+						inst
+					});
+					continue;
+				}
+				const result = def.valueType._zod.run({
+					value: input[key],
+					issues: []
+				}, ctx);
+				if (result instanceof Promise) proms.push(result.then((result) => {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}));
+				else {
+					if (result.issues.length) payload.issues.push(...prefixIssues(key, result.issues));
+					payload.value[keyResult.value] = result.value;
+				}
+			}
+		}
+		if (proms.length) return Promise.all(proms).then(() => payload);
+		return payload;
+	};
+});
 const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
 	$ZodType.init(inst, def);
 	const values = getEnumValues(def.entries);
@@ -2614,6 +2706,39 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 	const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
 	json.allOf = [...isSimpleIntersection(a) ? a.allOf : [a], ...isSimpleIntersection(b) ? b.allOf : [b]];
 };
+const recordProcessor = (schema, ctx, _json, params) => {
+	const json = _json;
+	const def = schema._zod.def;
+	json.type = "object";
+	const keyType = def.keyType;
+	const patterns = keyType._zod.bag?.patterns;
+	if (def.mode === "loose" && patterns && patterns.size > 0) {
+		const valueSchema = process$1(def.valueType, ctx, {
+			...params,
+			path: [
+				...params.path,
+				"patternProperties",
+				"*"
+			]
+		});
+		json.patternProperties = {};
+		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
+	} else {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$1(def.keyType, ctx, {
+			...params,
+			path: [...params.path, "propertyNames"]
+		});
+		json.additionalProperties = process$1(def.valueType, ctx, {
+			...params,
+			path: [...params.path, "additionalProperties"]
+		});
+	}
+	const keyValues = keyType._zod.values;
+	if (keyValues) {
+		const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+		if (validKeyValues.length > 0) json.required = validKeyValues;
+	}
+};
 const nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const inner = process$1(def.innerType, ctx, params);
@@ -3047,6 +3172,21 @@ function intersection(left, right) {
 		right
 	});
 }
+const ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
+	$ZodRecord.init(inst, def);
+	ZodType.init(inst, def);
+	inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
+	inst.keyType = def.keyType;
+	inst.valueType = def.valueType;
+});
+function record(keyType, valueType, params) {
+	return new ZodRecord({
+		type: "record",
+		keyType,
+		valueType,
+		...normalizeParams(params)
+	});
+}
 const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
 	$ZodEnum.init(inst, def);
 	ZodType.init(inst, def);
@@ -3299,6 +3439,7 @@ Fetch the full skill instructions with: prompts/get { name: "<skill-name>" }
 | what's emerging, find patterns in vault | vault-emerge |
 | find orphans, orphaned notes | vault-orphans |
 | trace idea, how did X evolve | vault-trace |
+| run a worker, check workers, worker providers | worker |
 
 ### Reference Resources
 
@@ -4377,6 +4518,70 @@ Otherwise the open items live only in a session note nobody re-reads, which is t
 `
 };
 
+//#endregion
+//#region src/daemon-mcp/prompts/worker.ts
+const worker = {
+	description: "Run, watch and route subagent workers on configured providers",
+	content: `## Worker Skill
+
+USE WHEN delegating subagent work, checking on running workers, or managing worker providers/classes from chat.
+
+### Delegating
+
+The Agent tool is denied when workers are on — delegate with Bash instead:
+
+\`\`\`
+pai worker run --label "short task label" --class research \\
+  -p '<full, self-contained task spec>' \\
+  --allowedTools 'Read,Edit,Write,Bash,Grep,Glob' --output-format json
+\`\`\`
+
+- Always run in background (run_in_background: true) and with a timeout.
+- Classes: draft (spec writing), plan, implement (default quality), review,
+  research (web: add WebSearch,WebFetch), spotcheck (cheap/fast model), simple,
+  complex, image. \`--role\` still works as an alias of \`--class\`.
+- Anything larger than a one-file change goes through a chain:
+  \`pai worker run --chain draft,implement …\` — the draft stage turns the brief
+  into a spec file, implement runs with it, \`--chain draft,implement,review\`
+  adds a review pass. \`--class spotcheck\` for verification runs.
+- The answer is in the \`result\` field of the JSON it prints. Review the diff yourself.
+- \`--no-pane\` suppresses the iTerm follow pane; panes open automatically otherwise.
+- \`--agent <name>\` runs a definition from ~/.claude/agents/<name>.md (the agent
+  library runs on workers: body becomes the system prompt, tools the allowlist,
+  model the class).
+
+### Watching
+
+- \`worker_ps\` — running + last finished workers (chains show as trees).
+- \`worker_replay\` with id — the transcript of one worker.
+- CLI equivalents: \`pai worker ps\`, \`pai worker follow <id>\`.
+
+### Routing
+
+- \`worker_status\` — on/off, active provider, providers, run tally.
+- \`worker_providers\` — list/add/update/remove/use/enable/disable/test. Adding
+  needs name, base_url, model and a key (key file path, or a raw key which is
+  parked in ~/.config/pai/keys/<name>, mode 0600). update changes cost_tier
+  (1 cheapest … 5 most expensive) and tags (code, vision, image-gen,
+  long-context, fast, reasoning).
+- \`worker_classes\` — list/set/unset class → provider[/fast], or constraints
+  only (max_cost_tier, require_tags) so auto-routing picks a qualifying provider.
+- \`worker_run\` — start a worker or chain from chat; returns the id immediately.
+- \`worker_toggle\` — off makes Agent subagents run on Anthropic again.
+
+### Preferences from chat (map the phrase, use the tool, never mention files)
+
+- "use <provider> for image generation" / "route research to <provider>" →
+  worker_classes set <class>=<provider>. One line back.
+- "prefer the flash model for simple tasks" / "cheap only for drafts" →
+  worker_classes set simple|draft=<provider>/fast (or a max_cost_tier). One line.
+- "reviews should use a reasoning model" → worker_classes set review with
+  require_tags ["reasoning"] (drop the pin if one exists). One line.
+- "what handles reviews" / "show the routing table" → worker_classes list
+  (plus worker_status for providers). One or two lines.
+- Never tell the user to edit a config file — the tools do it.`
+};
+
 //#endregion
 //#region src/daemon-mcp/resources/aesthetic.ts
 const aesthetic = {
@@ -5261,7 +5466,8 @@ async function startShim() {
 		"whisper": whisper,
 		"consolidate": consolidate,
 		"advisor": advisor,
-		"tasks": tasks
+		"tasks": tasks,
+		"worker": worker
 	};
 	for (const [promptName, skill] of Object.entries(SKILL_PROMPTS)) server.prompt(promptName, skill.description, () => ({ messages: [{
 		role: "user",
@@ -5521,6 +5727,348 @@ async function startShim() {
 		top_k: number().int().min(1).max(100).optional().describe("Maximum KG triples to return after re-ranking. Default: 20."),
 		tenant_id: string().optional().describe("Tenant ID for entity lookup scoping. Default: 'default'.")
 	}, async (args) => proxyTool("memory_kg_search", args));
+	const workerText = (s) => ({ content: [{
+		type: "text",
+		text: s
+	}] });
+	const workerError = (e) => ({
+		content: [{
+			type: "text",
+			text: e instanceof Error ? e.message : String(e)
+		}],
+		isError: true
+	});
+	server.tool("worker_status", [
+		"Show the worker system state: on/off, active provider, configured providers,",
+		"roles, and today's run tally from the ledger.",
+		"",
+		"Use this before delegating with `pai worker run` to see what routing will choose."
+	].join("\n"), {}, async () => {
+		try {
+			const { workers } = readWorkersSection();
+			const s = ledgerSummary(ledgerPath(workersLogDir(workers)), "all", 10);
+			const tally = s ? [`runs ${s.scope}: ${s.started} started, ${s.endedOk} ok, ${s.endedFailed} failed`, `agent hook: ${s.denied} denied, ${s.allowed} allowed, ${s.reroutes} reroutes`] : ["no runs recorded yet"];
+			return workerText([
+				`workers: ${workers.enabled ? "on" : "off"}`,
+				`active provider: ${workers.active ?? "(none)"}`,
+				...describeProviders(workers),
+				"",
+				...tally
+			].join("\n"));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_providers", [
+		"Manage worker providers (list, add, update, remove, use, enable, disable, test).",
+		"",
+		"action=list (default) shows providers (with cost tier and tags), classes and routing.",
+		"action=add needs name, model — and either key_file or key, plus:",
+		"  base_url (anthropic protocol) or upstream_url (protocol=openai, runs",
+		"  through the local PAI proxy). A raw key is written to",
+		"  ~/.config/pai/keys/<name> (mode 0600); only the path lands in the config.",
+		"  engine=codex runs the Codex CLI instead of Claude Code.",
+		"action=update changes cost_tier / tags of an existing provider.",
+		"action=test runs a one-word pong probe through the provider",
+		"  (reports 'codex not installed' when that engine's CLI is missing)."
+	].join("\n"), {
+		action: _enum([
+			"list",
+			"add",
+			"update",
+			"remove",
+			"use",
+			"enable",
+			"disable",
+			"test"
+		]).optional().describe("Default: list."),
+		name: string().optional().describe("Provider name (required for every action but list)."),
+		base_url: string().optional().describe("Anthropic-compatible API base URL (add)."),
+		upstream_url: string().optional().describe("Chat Completions base URL (add, protocol=openai)."),
+		protocol: _enum(["anthropic", "openai"]).optional().describe("Protocol (add). Default: anthropic."),
+		engine: _enum(["claude", "codex"]).optional().describe("Runner engine (add). Default: claude."),
+		context_window: number().int().positive().optional().describe("Context window for the meter (add). Default: 200000."),
+		key_file: string().optional().describe("File holding the API token, 0600 (add)."),
+		key: string().optional().describe("Raw API token (add) — parked in ~/.config/pai/keys/<name>."),
+		model: string().optional().describe("Default model id (add)."),
+		fast_model: string().optional().describe("Cheaper model for spotchecks (add, optional)."),
+		env: record(string(), string()).optional().describe("Extra env for runs (add, optional)."),
+		note: string().optional().describe("Human note shown in listings (add, optional)."),
+		quota_probe: string().optional().describe("URL whose JSON first number is the quota percent (add, optional)."),
+		cost_tier: number().int().min(1).max(5).optional().describe("Cost tier 1 (cheapest) … 5 (most expensive). Default 3. (add, update)"),
+		tags: array(_enum([
+			"code",
+			"vision",
+			"image-gen",
+			"long-context",
+			"fast",
+			"reasoning"
+		])).optional().describe("Capability tags (add, update).")
+	}, async (args) => {
+		try {
+			const action = args.action ?? "list";
+			if (action === "list") return workerText(describeProviders(readWorkersSection().workers).join("\n"));
+			if (!args.name) return workerError(/* @__PURE__ */ new Error("name is required for this action"));
+			if (action === "update") {
+				if (args.cost_tier === void 0 && args.tags === void 0) return workerError(/* @__PURE__ */ new Error("update needs cost_tier and/or tags"));
+				updateProvider(args.name, {
+					...args.cost_tier !== void 0 ? { costTier: args.cost_tier } : {},
+					...args.tags !== void 0 ? { tags: args.tags } : {}
+				});
+				return workerText([`provider ${args.name} updated`, ...describeProviders(readWorkersSection().workers)].join("\n"));
+			}
+			if (action === "add") {
+				if (!args.model) return workerError(/* @__PURE__ */ new Error("add needs model"));
+				if (args.protocol !== "openai" && !args.base_url) return workerError(/* @__PURE__ */ new Error("add needs base_url (only protocol=openai goes without it)"));
+				const workers = addProvider({
+					name: args.name,
+					baseUrl: args.base_url ?? "",
+					keyFile: args.key_file ?? null,
+					...args.key !== void 0 ? { key: args.key } : {},
+					model: args.model,
+					...args.fast_model ? { fastModel: args.fast_model } : {},
+					env: args.env ?? {},
+					...args.note ? { note: args.note } : {},
+					...args.protocol ? { protocol: args.protocol } : {},
+					...args.upstream_url ? { upstreamUrl: args.upstream_url } : {},
+					...args.engine ? { engine: args.engine } : {},
+					...args.context_window ? { contextWindow: args.context_window } : {},
+					...args.quota_probe ? { quotaProbe: args.quota_probe } : {},
+					...args.cost_tier !== void 0 ? { costTier: args.cost_tier } : {},
+					...args.tags?.length ? { tags: args.tags } : {}
+				});
+				return workerText([`provider ${args.name} added; active: ${workers.active ?? "(none)"}; workers ${workers.enabled ? "on" : "off"}`, ...describeProviders(workers)].join("\n"));
+			}
+			if (action === "remove") {
+				removeProvider(args.name);
+				return workerText(`provider ${args.name} removed`);
+			}
+			if (action === "use") {
+				useProvider(args.name);
+				return workerText(`active provider: ${args.name}`);
+			}
+			if (action === "enable" || action === "disable") {
+				setProviderEnabled(args.name, action === "enable");
+				return workerText(`provider ${args.name} ${action}d`);
+			}
+			const { workers } = readWorkersSection();
+			const p = workers.providers[args.name];
+			if (!p) return workerError(/* @__PURE__ */ new Error(`no provider named "${args.name}"`));
+			const r = await testProvider(args.name, p, workersLogDir(workers));
+			if (r.skipped) return workerText(`${r.provider} ${r.model}  ${r.skipped}\nreply: ${r.result.slice(0, 200)}`);
+			return workerText(`${r.provider} ${r.model}  ${(r.latencyMs / 1e3).toFixed(1)}s\nreply: ${r.result.slice(0, 200)}\n${r.ok ? "OK" : "FAILED"}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_classes", [
+		"Manage worker classes (list, set, unset).",
+		"",
+		"A class maps a task class to a provider, optionally its fast model:",
+		"implement=glm, research=glm, spotcheck=glm/fast.",
+		"set can instead give routing constraints only (max_cost_tier,",
+		"require_tags) — auto-routing then picks a qualifying provider.",
+		"Runs pick the provider via --class first, then the active provider."
+	].join("\n"), {
+		action: _enum([
+			"list",
+			"set",
+			"unset"
+		]).optional().describe("Default: list."),
+		class: string().optional().describe("Class name (set/unset), e.g. implement, spotcheck."),
+		target: string().optional().describe("Provider or provider/fast (set)."),
+		max_cost_tier: number().int().min(1).max(5).optional().describe("Auto-routing considers only providers up to this cost tier (set)."),
+		require_tags: array(_enum([
+			"code",
+			"vision",
+			"image-gen",
+			"long-context",
+			"fast",
+			"reasoning"
+		])).optional().describe("Auto-routing needs these tags (set).")
+	}, async (args) => {
+		try {
+			const action = args.action ?? "list";
+			if (action === "list") {
+				const { workers } = readWorkersSection();
+				const entries = Object.entries(workers.classes);
+				return workerText(entries.length ? entries.map(([cls, t]) => `${cls}: ${classTargetText(t)}`).join("\n") : "no classes set");
+			}
+			if (!args.class) return workerError(/* @__PURE__ */ new Error("class is required for this action"));
+			if (action === "set") {
+				const hasConstraints = args.max_cost_tier !== void 0 || args.require_tags !== void 0;
+				if (!args.target && !hasConstraints) return workerError(/* @__PURE__ */ new Error("set needs target provider[/fast] and/or max_cost_tier/require_tags"));
+				const target = args.target !== void 0 && !hasConstraints ? args.target : {
+					...args.target ? { provider: args.target.split("/")[0] } : {},
+					...args.max_cost_tier !== void 0 ? { maxCostTier: args.max_cost_tier } : {},
+					...args.require_tags !== void 0 ? { requireTags: args.require_tags } : {}
+				};
+				setClass(args.class, target);
+				return workerText(`class ${args.class} → ${classTargetText(target)}`);
+			}
+			unsetClass(args.class);
+			return workerText(`class ${args.class} removed`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_run", [
+		"Start a worker (or a chain) and return its id immediately.",
+		"",
+		"This is the chat-side face of `pai worker run`: prompt is required,",
+		"chain (e.g. \"draft,implement\") runs spec-first stages, class picks the",
+		"provider (default: active). Check on it with worker_ps / worker_replay,",
+		"talk to it with worker_say."
+	].join("\n"), {
+		prompt: string().min(1).describe("The task (the -p value)."),
+		chain: string().optional().describe("Comma-separated stages, e.g. draft,implement or draft,implement,review."),
+		class: string().optional().describe("Task class (draft, implement, review, research, spotcheck, simple, complex, image)."),
+		label: string().optional().describe("Short task label shown in worker_ps."),
+		cwd: string().optional().describe("Working directory (default: here)."),
+		allowed_tools: string().optional().describe("Comma-separated tool allowlist passed to the worker."),
+		mcp: string().optional().describe("MCP servers/sets the worker may use (comma-separated).")
+	}, async (args) => {
+		try {
+			const claudeArgs = [
+				"-p",
+				args.prompt,
+				...args.allowed_tools ? ["--allowedTools", args.allowed_tools] : []
+			];
+			let startedIdResolve;
+			let startupFailure = null;
+			const idArrived = new Promise((resolve) => {
+				startedIdResolve = resolve;
+			});
+			const background = async () => {
+				if (args.chain) return runChain({
+					stages: args.chain.split(","),
+					className: args.class,
+					label: args.label,
+					noPane: false,
+					mcpFlag: args.mcp,
+					brief: args.prompt,
+					claudeArgs,
+					...args.cwd ? { cwd: args.cwd } : {},
+					onChainStart: (id) => startedIdResolve(id),
+					quiet: true
+				});
+				return runWorker({
+					className: args.class,
+					label: args.label,
+					noPane: false,
+					mcpFlag: args.mcp,
+					claudeArgs,
+					...args.cwd ? { cwd: args.cwd } : {},
+					onWorkerStart: (wid) => startedIdResolve(wid),
+					quiet: true
+				});
+			};
+			background().catch((e) => {
+				startupFailure = e;
+				startedIdResolve("");
+			});
+			const id = await Promise.race([idArrived, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("worker did not start within 15s")), 15e3))]);
+			if (!id) return workerError(startupFailure ?? /* @__PURE__ */ new Error("worker failed to start"));
+			return workerText(`${id} started${args.chain ? ` (chain: ${args.chain})` : ""} — check on it with worker_ps, worker_replay, worker_say`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_toggle", [
+		"Turn worker routing on or off.",
+		"",
+		"off: the Agent-tool hook stops denying, subagents run on Anthropic.",
+		"on: subagents are denied and rewritten to `pai worker run`."
+	].join("\n"), { enabled: boolean().describe("true = route subagents to workers, false = Anthropic.") }, async (args) => {
+		try {
+			const workers = setWorkersEnabled(args.enabled);
+			return workerText(`workers ${workers.enabled ? "on" : "off"} — Agent subagents ${workers.enabled ? "denied and rewritten to `pai worker run`" : "run on Anthropic"}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_ps", [
+		"List workers: running (id, provider, age, turns, current tool) and the last finished.",
+		"",
+		"Use this to check on delegated `pai worker run` calls; worker_replay shows",
+		"the transcript of one worker."
+	].join("\n"), { all: boolean().optional().describe("Show workers of all sessions (default: this one's).") }, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			return workerText(psOutput(workersLogDir(workers), args.all === true, {}, false));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_replay", [
+		"Replay the transcript of one worker: tool calls, short outputs, result.",
+		"",
+		"Plain text, no colors. Use tail to cap the output."
+	].join("\n"), {
+		id: string().describe("Worker id (as shown by worker_ps)."),
+		tail: number().int().min(1).max(2e3).optional().describe("Last N rendered lines. Default: all.")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			return workerText(replayOutput(workersLogDir(workers), args.id, false, args.tail));
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_say", [
+		"Send one message to a RUNNING worker: it lands on the worker's open stdin",
+		"as a user message, mid-run, without breaking its stream.",
+		"",
+		"Fails with an explanation when the worker already finished — then use",
+		"worker_resume (or `pai worker resume <id> \"text\"`) instead."
+	].join("\n"), {
+		id: string().describe("Worker id (as shown by worker_ps)."),
+		text: string().min(1).describe("The message to send (one line).")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			await sayToWorker(workersLogDir(workers), args.id, args.text);
+			return workerText(`sent to ${args.id}`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
+	server.tool("worker_resume", [
+		"Continue a FINISHED worker with a follow-up message: claude --resume on the",
+		"same provider, same Claude session, context intact.",
+		"",
+		"Returns the new worker id. Not for running workers — say to those instead."
+	].join("\n"), {
+		id: string().describe("Worker id of the finished run (as shown by worker_ps)."),
+		text: string().min(1).describe("The follow-up message.")
+	}, async (args) => {
+		try {
+			const { workers } = readWorkersSection();
+			const old = loadStatus(workersLogDir(workers), args.id);
+			if (!old) return workerError(/* @__PURE__ */ new Error(`no worker named "${args.id}"`));
+			if (old.state === "running") return workerError(/* @__PURE__ */ new Error(`worker ${args.id} is still running — send messages with worker_say`));
+			if (!old.claudeSession) return workerError(/* @__PURE__ */ new Error(`worker ${args.id} recorded no Claude session id — it predates resume support or ran through an engine that does not expose one`));
+			let newId = "";
+			const rc = await runWorker({
+				providerFlag: old.provider,
+				modelFlag: old.model,
+				label: `↩ ${old.label}`,
+				noPane: true,
+				claudeArgs: [
+					"--resume",
+					old.claudeSession,
+					"-p",
+					args.text
+				],
+				onWorkerStart: (wid) => {
+					newId = wid;
+				}
+			});
+			return workerText(`resumed ${args.id} as ${newId || "(unknown id)"} — rc=${rc}\ncheck on it with worker_ps / worker_replay`);
+		} catch (e) {
+			return workerError(e);
+		}
+	});
 	const transport = new StdioServerTransport();
 	await server.connect(transport);
 }