@howarewoo/pi-subagents 0.0.0-stage → 0.2.0

package/src/task-input.ts

@@ -0,0 +1,74 @@
+import { stat, realpath } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import type { ExtensionToolContext, ReadToolDetails } from "@earendil-works/pi-coding-agent";
+
+function hasDeniedTaskComponent(path: string): boolean {
+  return path.split(/[\\/]/).some((part) => part.startsWith(".") || part === "node_modules");
+}
+
+/** Content is obtained only through the effective public read dispatcher, never raw filesystem reads. */
+export async function readTaskInput(
+  path: string,
+  ctx: ExtensionToolContext,
+  signal?: AbortSignal,
+  beforeRead?: () => void | Promise<void>,
+  cwd = ctx.cwd,
+): Promise<string> {
+  if (!path || isAbsolute(path) || path.includes("\0") || hasDeniedTaskComponent(path))
+    throw new Error(
+      "taskFile must be an explicit non-hidden workspace-relative path without traversal",
+    );
+  if (!ctx.tools.some((tool) => tool.name === "read"))
+    throw new Error("taskFile requires a callable parent read tool");
+  const base = await realpath(cwd);
+  const target = resolve(base, path);
+  const checkedPath = await realpath(target);
+  const inside = relative(base, checkedPath);
+  if (!inside || inside === ".." || inside.startsWith(".." + sep) || isAbsolute(inside))
+    throw new Error("taskFile escapes workspace");
+  if (hasDeniedTaskComponent(inside))
+    throw new Error("taskFile resolved target must be non-hidden and outside node_modules");
+  const before = await stat(target);
+  if (!before.isFile() || before.size === 0 || before.size > 50000)
+    throw new Error("taskFile must be a nonempty regular text file of at most 50000 bytes");
+  signal?.throwIfAborted();
+  await beforeRead?.();
+  signal?.throwIfAborted();
+  const outcome = await ctx.executeTool("read", { path: target }, { signal });
+  if (outcome.isError)
+    throw new Error(
+      "taskFile read denied or failed: " +
+        outcome.result.content
+          .filter((block) => block.type === "text")
+          .map((block) => block.text)
+          .join("\n"),
+    );
+  const details = outcome.result.details as ReadToolDetails | undefined;
+  if (
+    details?.truncation?.truncated ||
+    outcome.result.content.length !== 1 ||
+    outcome.result.content[0].type !== "text"
+  )
+    throw new Error("taskFile must be complete untruncated text");
+  const text = outcome.result.content[0].text;
+  if (
+    !text.trim() ||
+    text.includes("\0") ||
+    text.includes("\ufffd") ||
+    Buffer.byteLength(text) > 50000
+  )
+    throw new Error(
+      "taskFile must contain nonempty UTF-8 text without replacement characters or NUL",
+    );
+  const after = await stat(target);
+  if (
+    (await realpath(target)) !== checkedPath ||
+    before.dev !== after.dev ||
+    before.ino !== after.ino ||
+    before.size !== after.size ||
+    before.mtimeMs !== after.mtimeMs ||
+    before.ctimeMs !== after.ctimeMs
+  )
+    throw new Error("taskFile changed during preflight; retry");
+  return text;
+}

package/src/task-presentation.ts

@@ -0,0 +1,165 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ChildSnapshot, DelegationCoordinator } from "./coordinator.ts";
+import { safe } from "./thread.ts";
+
+export const lineText = (text: string) => safe(text).replaceAll("\n", " ");
+export const assignmentHeadline = (child: ChildSnapshot) =>
+  safe(child.assignment)
+    .split("\n")
+    .map((line) => line.trim())
+    .find(Boolean)
+    ?.replace(/^#{1,6}\s+/, "") || "Assignment";
+export const agentLabel = (child: ChildSnapshot) =>
+  `${assignmentHeadline(child)} · ${lineText(child.profile)}`;
+export const active = (child: ChildSnapshot) => !child.disposed && child.status !== "paused";
+export const activity = (child: ChildSnapshot) =>
+  (child.status === "paused"
+    ? `Paused: ${child.pauseReason ?? "deadline"} · context ${child.retainedContext ? "retained" : "not yet available"} · resume via model or stop in Hub`
+    : child.error) ||
+  (active(child) ? child.activity || child.progress : child.result) ||
+  child.progress ||
+  "Waiting for SDK activity";
+export const writerWarning = "Model-tool writer only: no conflicting manual !/!! or external edits";
+export const statuses = [
+  "queued",
+  "setup",
+  "running",
+  "draining",
+  "pausing",
+  "paused",
+  "settled",
+  "failed",
+  "cancelled",
+] as const;
+export function fleetSummary(children: ChildSnapshot[]): string {
+  return children.length
+    ? statuses
+        .map((status) => `${status} ${children.filter((child) => child.status === status).length}`)
+        .join(" · ")
+    : "No tasks · ask the model to delegate_task";
+}
+
+export function taskCard(child: ChildSnapshot | undefined, expanded = false): string[] {
+  if (!child)
+    return [
+      "Task identity unavailable",
+      "See tool error; /subagent-hub lists current runtime tasks",
+    ];
+  const headline = `${truncateToWidth(assignmentHeadline(child), 240, "… [preview truncated]")} · ${lineText(child.profile)} #${child.generation} · ${child.status}`;
+  if (!expanded)
+    return [
+      headline,
+      ...(child.status === "paused"
+        ? [
+            `Pause: ${truncateToWidth(lineText(child.pauseReason ?? "deadline"), 240, "… [preview truncated]")}`,
+          ]
+        : child.error
+          ? [`Error: ${truncateToWidth(lineText(child.error), 240, "… [preview truncated]")}`]
+          : []),
+    ].map(lineText);
+  return [
+    headline,
+    `Identity ${child.id} #${child.generation}`,
+    `${child.model.provider}/${child.model.id} · effort ${child.effort ?? "unavailable"}`,
+    truncateToWidth(lineText(activity(child)), 240, "… [preview truncated]"),
+    `Prewalk ${child.prewalk ? JSON.stringify(child.prewalk) : "off"} · advisor unavailable`,
+    `Parent ${child.parentId}${child.parentGeneration ? ` #${child.parentGeneration}` : ""} · depth ${child.depth} · writer lease ${child.writerLease}`,
+    ...(child.outcome
+      ? [
+          `Structured ${child.outcome.validation} · ${child.outcome.finalized ? "finalized" : "provisional"} · attempts ${child.outcome.attempts}`,
+        ]
+      : []),
+    ...(child.limitReason ? [`Limit: ${child.limitReason}`] : []),
+    ...(child.pauseReason
+      ? [
+          `Pause: ${child.pauseReason} · context ${child.retainedContext ? "retained" : "not yet available"} · resume via model control after drain`,
+        ]
+      : []),
+    `Window ${child.window ?? 1} · cumulative requests ${child.telemetry.requests ?? 0}/${child.limits.requests} · tools ${child.toolCalls}/${child.limits.tools} · spawns ${child.spawned ?? 0}/${child.limits.spawns}`,
+    ...(child.artifacts ? [`Artifacts: ${JSON.stringify(child.artifacts)}`] : []),
+    "Assignment: " + truncateToWidth(lineText(child.assignment), 480, "… [preview truncated]"),
+    "Result: " +
+      truncateToWidth(
+        lineText(child.result || child.error || "Not available yet"),
+        480,
+        "… [preview truncated]",
+      ),
+    child.transcript
+      ? `Full transcript: ${child.transcript} · /subagent-hub`
+      : "Transcript unavailable (setup) · /subagent-hub",
+  ].map(lineText);
+}
+
+/** Read-only content projection: never dumps provider/auth objects, image payloads or opaque signatures. */
+export function transcriptLines(
+  messages: ReturnType<DelegationCoordinator["messages"]>,
+  toolsOnly = false,
+): string[] {
+  const lines: string[] = [];
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    const start = lines.length;
+    const blocks = "content" in message ? message.content : undefined;
+    if (!toolsOnly || message.role === "toolResult") {
+      lines.push(
+        `[${message.role}${message.role === "toolResult" ? ` ${message.toolName} ${message.toolCallId} ${message.isError ? "ERROR" : "result"}` : ""}]`,
+      );
+      if (typeof blocks === "string") lines.push(safe(blocks));
+    }
+    if (Array.isArray(blocks))
+      for (const block of blocks) {
+        if (block.type === "toolCall")
+          lines.push(
+            `Tool ${block.name} ${block.id}\nArguments: ${safe(JSON.stringify(block.arguments, null, 2))}`,
+          );
+        else if (!toolsOnly || message.role === "toolResult") {
+          if (block.type === "text") lines.push(safe(block.text));
+          else if (block.type === "thinking") lines.push("Thinking: " + safe(block.thinking));
+          else if (block.type === "image")
+            lines.push(`[image ${safe(block.mimeType)}; payload omitted]`);
+        }
+      }
+    if (message.role === "assistant" && message.errorMessage)
+      lines.push("Error: " + safe(message.errorMessage));
+    if (start && lines.length > start) lines.splice(start, 0, "");
+  }
+  return lines.length
+    ? lines.map(safe)
+    : [toolsOnly ? "No tool calls yet" : "Waiting for SDK messages"];
+}
+
+export function taskDetails(
+  child: ChildSnapshot,
+  presence: ReturnType<DelegationCoordinator["agents"]>[number]["presence"],
+): string[] {
+  const metric = (value: unknown) =>
+    value === null || value === undefined ? "unavailable" : JSON.stringify(value);
+  return [
+    `Identity ${child.id} #${child.generation}`,
+    "",
+    "Assignment",
+    safe(child.assignment),
+    "",
+    "Result",
+    safe(child.result || "Not available yet"),
+    "",
+    ...(child.error ? ["Error", safe(child.error), ""] : []),
+    ...(child.outcome ? ["Structured outcome", JSON.stringify(child.outcome, null, 2), ""] : []),
+    ...(child.artifacts ? ["Saved artifacts", JSON.stringify(child.artifacts, null, 2), ""] : []),
+    `Workspace: ${safe(child.cwd ?? "parent workspace")}`,
+    `Effective builtin tools: ${child.tools.join(", ")}`,
+    `${child.model.provider}/${child.model.id} · effort ${child.effort ?? "unavailable"}`,
+    `Prewalk ${child.prewalk ? JSON.stringify(child.prewalk) : "off"} · advisor unavailable`,
+    `Presence ${presence ?? "historical"} · resources ${child.disposed ? "disposed" : child.status === "paused" ? "idle SDK; context retained; model resume required" : "live"}`,
+    `Elapsed ${Math.max(0, Math.floor(((child.endedAt ?? Date.now()) - child.createdAt) / 1000))}s`,
+    `Direct requests ${metric(child.telemetry.requests)} · cost ${metric(child.telemetry.cost)}`,
+    `Direct tokens ${metric(child.telemetry.tokens)}`,
+    `Context ${metric(child.telemetry.context)}`,
+    `Parent ${child.parentId} #${child.parentGeneration ?? "root"} · depth ${child.depth} · direct generation only`,
+    `Limits ${JSON.stringify(child.limits)} · calls ${child.toolCalls} · reason ${child.limitReason ?? "none"}`,
+    "Activity: " + safe(activity(child)),
+    "Full transcript: " + safe(child.transcript ?? "unavailable (queued/setup)"),
+    "Followup/revive: native delegate_coordinate only (Hub has no tool dispatcher)",
+    ...(child.writerLease ? [writerWarning] : []),
+  ];
+}

package/src/thread.ts

@@ -0,0 +1,268 @@
+import {
+  AssistantMessageComponent,
+  UserMessageComponent,
+  ToolExecutionComponent,
+  getMarkdownTheme,
+  createReadToolDefinition,
+  createBashToolDefinition,
+  createEditToolDefinition,
+  createWriteToolDefinition,
+  createGrepToolDefinition,
+  createFindToolDefinition,
+  createLsToolDefinition,
+  type ToolRenderers,
+} from "@earendil-works/pi-coding-agent";
+import { Text, wrapTextWithAnsi, type Component, type TUI } from "@earendil-works/pi-tui";
+import type { DelegationCoordinator } from "./coordinator.ts";
+
+export function safe(text: string): string {
+  return text
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(
+      /[\x00-\x08\x0b-\x1f\x7f-\x9f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069\u2028\u2029]/g,
+      " ",
+    )
+    .replaceAll("\t", "  ");
+}
+
+// Inputs are sanitized before native rendering. Only native SGR survives the output boundary,
+// not OSC links/shell zones, image protocols or cursor-control sequences.
+export function nativeText(text: string): string {
+  return text
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+    .split(/(\x1b\[[0-9;:]*m)/g)
+    .map((part, index) => (index % 2 ? part : safe(part)))
+    .join("");
+}
+function safeValue(value: unknown): unknown {
+  if (typeof value === "string") return safe(value);
+  if (Array.isArray(value)) return value.map(safeValue);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [safe(key), safeValue(item)]),
+    );
+  return value;
+}
+
+type Messages = ReturnType<DelegationCoordinator["messages"]>;
+export type ThreadDependencies = Readonly<{
+  tui: TUI;
+  cwd: string;
+  toolRenderers?: Readonly<Record<string, ToolRenderers>>;
+}>;
+export type LiveTool = {
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+  content?: readonly { type: string; text?: string; mimeType?: string }[];
+};
+const textContent = (content: readonly { type: string; text?: string; mimeType?: string }[]) =>
+  content.flatMap((block) =>
+    block.type === "text"
+      ? [{ type: "text", text: safe(block.text ?? "") }]
+      : block.type === "image"
+        ? [{ type: "text", text: `[image ${safe(block.mimeType ?? "unknown")}; payload omitted]` }]
+        : [],
+  );
+
+/** Selected-generation readonly projection through the same public classes as Pi's main chat. */
+export function createNativeThread({ tui, cwd, toolRenderers }: ThreadDependencies) {
+  const renderers = new Map<string, ToolRenderers>(
+    [
+      createReadToolDefinition(cwd),
+      createBashToolDefinition(cwd),
+      createEditToolDefinition(cwd),
+      createWriteToolDefinition(cwd),
+      createGrepToolDefinition(cwd),
+      createFindToolDefinition(cwd),
+      createLsToolDefinition(cwd),
+    ].map(({ name, renderShell, renderCall, renderResult }) => [
+      name,
+      { renderShell, renderCall, renderResult } as ToolRenderers,
+    ]),
+  );
+  for (const [name, renderersForTool] of Object.entries(toolRenderers ?? {}))
+    renderers.set(name, renderersForTool);
+  const cache = new Map<string, { signature: string; component: Component }>();
+  let generation: string | undefined;
+  return {
+    render(
+      ref: string,
+      messages: Messages,
+      partial: Messages[number] | undefined,
+      live: LiveTool | undefined,
+      width: number,
+    ): string[] {
+      if (generation !== ref) {
+        cache.clear();
+        generation = ref;
+      }
+      const used = new Set<string>();
+      const components: Component[] = [];
+      const append = (
+        key: string,
+        value: unknown,
+        build: () => Component,
+        update?: (component: Component) => void,
+      ) => {
+        const signature = JSON.stringify(value);
+        let entry = cache.get(key);
+        if (!entry || entry.signature !== signature) {
+          if (entry && update) {
+            update(entry.component);
+            entry.signature = signature;
+          } else {
+            entry = { signature, component: build() };
+            cache.set(key, entry);
+          }
+        }
+        used.add(key);
+        components.push(entry.component);
+      };
+      const all = partial ? [...messages, partial] : messages;
+      const results = new Map(
+        all.flatMap((message) =>
+          message.role === "toolResult" ? [[message.toolCallId, message] as const] : [],
+        ),
+      );
+      const toolIds = new Set<string>();
+      const tool = (name: string, id: string, args: unknown, failure?: string) => {
+        if (toolIds.has(id)) return;
+        toolIds.add(id);
+        const result = results.get(id);
+        const active = live?.toolCallId === id ? live : undefined;
+        const content = result
+          ? textContent(result.content)
+          : active?.content
+            ? textContent(active.content)
+            : failure
+              ? [{ type: "text", text: safe(failure) }]
+              : undefined;
+        // Only the documented edit diff is renderer input. Never pass arbitrary tool details.
+        const details = result?.details;
+        const diff =
+          name === "edit" &&
+          details &&
+          typeof details === "object" &&
+          "diff" in details &&
+          typeof details.diff === "string"
+            ? {
+                diff: safe(details.diff),
+                ...("firstChangedLine" in details && typeof details.firstChangedLine === "number"
+                  ? { firstChangedLine: details.firstChangedLine }
+                  : {}),
+              }
+            : undefined;
+        const toolArgs = safeValue(active?.args ?? args);
+        const output = content
+          ? { content, details: diff, isError: result?.isError ?? !!failure }
+          : undefined;
+        append("tool:" + id, [name, toolArgs, output, !!active], () => {
+          const component = new ToolExecutionComponent(
+            safe(name),
+            safe(id),
+            toolArgs,
+            { showImages: false },
+            renderers.get(name),
+            tui,
+            cwd,
+          );
+          component.setExpanded(true);
+          // Native edit's completed-args preview reads cwd files. Recorded result.diff is sufficient.
+          if (name !== "edit") component.setArgsComplete();
+          // Do not mark execution started: this observer must not invent elapsed clocks/timers.
+          if (output) component.updateResult(output, !!active && !result);
+          return component;
+        });
+      };
+      all.forEach((message, index) => {
+        if (message.role === "system") return;
+        if (message.role === "assistant") {
+          const content: typeof message.content = message.content.map((block) =>
+            block.type === "text"
+              ? { type: "text", text: safe(block.text) }
+              : block.type === "thinking"
+                ? { type: "thinking", thinking: safe(block.thinking) }
+                : {
+                    type: "toolCall",
+                    id: safe(block.id),
+                    name: safe(block.name),
+                    arguments: safeValue(block.arguments) as typeof block.arguments,
+                  },
+          );
+          const projected = {
+            role: message.role,
+            api: message.api,
+            provider: message.provider,
+            model: message.model,
+            timestamp: message.timestamp,
+            usage: message.usage,
+            stopReason: message.stopReason,
+            content,
+            errorMessage: message.errorMessage ? safe(message.errorMessage) : undefined,
+          };
+          const streaming = message === partial;
+          append(
+            "assistant:" + index,
+            [projected, streaming],
+            () => {
+              const component = new AssistantMessageComponent(projected, false, getMarkdownTheme());
+              component.updateContent(projected, streaming);
+              return component;
+            },
+            (component) =>
+              (component as AssistantMessageComponent).updateContent(projected, streaming),
+          );
+          for (const block of message.content)
+            if (block.type === "toolCall")
+              tool(
+                block.name,
+                block.id,
+                block.arguments,
+                message.stopReason === "error" || message.stopReason === "aborted"
+                  ? message.errorMessage || "Operation aborted"
+                  : undefined,
+              );
+          if (
+            message.errorMessage &&
+            message.stopReason !== "error" &&
+            message.stopReason !== "aborted"
+          ) {
+            append(
+              "error:" + index,
+              message.errorMessage,
+              () => new Text("Error: " + safe(message.errorMessage!), 1, 0),
+            );
+          }
+        } else if (message.role === "toolResult") {
+          if (!toolIds.has(message.toolCallId)) tool(message.toolName, message.toolCallId, {});
+        } else if ("content" in message) {
+          const text =
+            typeof message.content === "string"
+              ? safe(message.content)
+              : Array.isArray(message.content)
+                ? textContent(message.content)
+                    .map((block) => block.text)
+                    .join("\n")
+                : "";
+          append("user:" + index, text, () => new UserMessageComponent(text, getMarkdownTheme()));
+        }
+      });
+      if (live && !toolIds.has(live.toolCallId)) tool(live.toolName, live.toolCallId, live.args);
+      for (const key of cache.keys()) if (!used.has(key)) cache.delete(key);
+      return components.flatMap((component) =>
+        component
+          .render(Math.max(12, width))
+          .flatMap((line) => wrapTextWithAnsi(nativeText(line), Math.max(1, width))),
+      );
+    },
+    invalidate() {
+      for (const entry of cache.values()) entry.component.invalidate();
+    },
+    clear() {
+      cache.clear();
+      generation = undefined;
+    },
+  };
+}

package/src/tool-schemas.ts

@@ -0,0 +1,165 @@
+import { Type } from "typebox";
+import { EFFORTS } from "./model-policy.ts";
+import { COORDINATION_ACTIONS } from "./profiles.ts";
+
+const role = Type.Union([
+  Type.Literal("general"),
+  Type.Literal("scout"),
+  Type.Literal("review"),
+  Type.Literal("implementation"),
+]);
+const limits = Type.Object(
+  {
+    depth: Type.Optional(Type.Integer({ minimum: 0 })),
+    spawns: Type.Optional(Type.Integer({ minimum: 0 })),
+    deadlineMs: Type.Optional(Type.Integer({ minimum: 1 })),
+    requests: Type.Optional(Type.Integer({ minimum: 1 })),
+    tools: Type.Optional(Type.Integer({ minimum: 1 })),
+  },
+  { additionalProperties: false },
+);
+const modelSelection = Type.Object(
+  {
+    provider: Type.String({ minLength: 1 }),
+    id: Type.String({ minLength: 1 }),
+    effort: Type.Enum(EFFORTS),
+  },
+  { additionalProperties: false },
+);
+const assignment = {
+  cwd: Type.Optional(
+    Type.String({
+      minLength: 1,
+      description:
+        "Existing workspace; absolute or relative to root parent cwd. No new permissions or sandbox.",
+    }),
+  ),
+  models: Type.Optional(Type.Array(modelSelection, { maxItems: 64 })),
+  model: Type.Optional(modelSelection),
+  assignment: Type.Optional(Type.String({ minLength: 1 })),
+  taskFile: Type.Optional(Type.String({ minLength: 1 })),
+  resultSchema: Type.Optional(Type.Unknown()),
+  profile: role,
+  spawn: Type.Optional(Type.Array(role)),
+  coordination: Type.Optional(
+    Type.Array(Type.Union(COORDINATION_ACTIONS.map((action) => Type.Literal(action)))),
+  ),
+  limits: Type.Optional(limits),
+};
+const item = Type.Object(assignment, { additionalProperties: false });
+export const parameters = Type.Union([
+  Type.Object(
+    { ...assignment, background: Type.Optional(Type.Boolean()) },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      tasks: Type.Array(item, { minItems: 1, maxItems: 64 }),
+      background: Type.Optional(Type.Boolean()),
+    },
+    { additionalProperties: false },
+  ),
+]);
+
+const identity = Type.Object(
+  { id: Type.String({ minLength: 1 }), generation: Type.Integer({ minimum: 1 }) },
+  { additionalProperties: false },
+);
+export const coordinationParameters = Type.Union([
+  Type.Object(
+    {
+      action: Type.Literal("message"),
+      target: Type.Optional(identity),
+      text: Type.String({ minLength: 1, maxLength: 4096 }),
+      mode: Type.Optional(
+        Type.Union([Type.Literal("inbox"), Type.Literal("steer"), Type.Literal("followUp")]),
+      ),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object({ action: Type.Literal("inbox") }, { additionalProperties: false }),
+  Type.Object(
+    {
+      action: Type.Literal("wait"),
+      target: Type.Optional(identity),
+      messageId: Type.Optional(Type.String({ minLength: 1 })),
+      timeoutMs: Type.Integer({ minimum: 1, maximum: 60000 }),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      action: Type.Union([Type.Literal("park"), Type.Literal("stop"), Type.Literal("status")]),
+      target: identity,
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      action: Type.Union([Type.Literal("followup"), Type.Literal("revive")]),
+      target: identity,
+      assignment: Type.String({ minLength: 1 }),
+      resultSchema: Type.Optional(Type.Unknown()),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      action: Type.Literal("resume"),
+      target: identity,
+      assignment: Type.String({ minLength: 1 }),
+    },
+    { additionalProperties: false },
+  ),
+]);
+
+const worker = Type.Union([role, Type.Literal("worker")]);
+const compatibleItem = Type.Object(
+  {
+    agent: worker,
+    task: Type.String({ minLength: 1 }),
+    cwd: Type.Optional(
+      Type.String({
+        minLength: 1,
+        description:
+          "Existing workspace; absolute or relative to root parent cwd. Omit to inherit the call default.",
+      }),
+    ),
+    model: Type.Optional(Type.Union([modelSelection, Type.String({ minLength: 1 })])),
+    limits: Type.Optional(limits),
+  },
+  { additionalProperties: false },
+);
+export const compatibleParameters = Type.Union([
+  Type.Object(
+    { ...compatibleItem.properties, async: Type.Optional(Type.Boolean()) },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      tasks: Type.Array(compatibleItem, { minItems: 1, maxItems: 64 }),
+      async: Type.Optional(Type.Boolean()),
+      cwd: Type.Optional(Type.String({ minLength: 1 })),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    { action: Type.Union([Type.Literal("list"), Type.Literal("agents")]) },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      action: Type.Union([Type.Literal("status"), Type.Literal("stop")]),
+      id: Type.String({ minLength: 1 }),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      action: Type.Union([Type.Literal("steer"), Type.Literal("resume")]),
+      id: Type.String({ minLength: 1 }),
+      message: Type.String({ minLength: 1 }),
+    },
+    { additionalProperties: false },
+  ),
+]);