@hheei/pi-subagents 0.7.0 → 0.8.0

package/dist/mcp/delegate.d.ts

@@ -0,0 +1,30 @@
+import { Type } from "typebox";
+import type { DelegateSubagentInput } from "../domain.js";
+export interface DelegateMcpInput extends DelegateSubagentInput {
+    /** Return immediately with a recoverable delegation ID instead of waiting for settlement. */
+    readonly wait?: boolean;
+}
+/**
+ * MCP-facing input contract. Both id and agent may be supplied: id is authoritative and agent is
+ * ignored. Do not express the target as an exclusive union in the advertised tool schema.
+ */
+export declare const delegateInputSchema: Type.TObject<{
+    task: Type.TString;
+    wait: Type.TOptional<Type.TBoolean>;
+    id: Type.TOptional<Type.TString>;
+    agent: Type.TOptional<Type.TString>;
+    cwd: Type.TOptional<Type.TString>;
+}>;
+export declare const delegateToolMetadata: {
+    readonly name: "delegate";
+    readonly description: "Delegate work to a new or existing Pi agent. Supply agent to start a new session, or id to continue an existing one; with both, id wins and agent is ignored. Returns the delegation's id, revision, status and hasOutput, and by default waits for the result.";
+    readonly inputSchema: Type.TObject<{
+        task: Type.TString;
+        wait: Type.TOptional<Type.TBoolean>;
+        id: Type.TOptional<Type.TString>;
+        agent: Type.TOptional<Type.TString>;
+        cwd: Type.TOptional<Type.TString>;
+    }>;
+};
+/** Validate untrusted MCP arguments before submitting them to the manager. */
+export declare function parseDelegateInput(input: unknown): DelegateMcpInput;

package/dist/mcp/delegate.js

@@ -0,0 +1,44 @@
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { stripHindsightContent } from "../launch-spec.js";
+/**
+ * MCP-facing input contract. Both id and agent may be supplied: id is authoritative and agent is
+ * ignored. Do not express the target as an exclusive union in the advertised tool schema.
+ */
+export const delegateInputSchema = Type.Object({
+    task: Type.String({
+        minLength: 1,
+        description: "Work to perform in the selected child session.",
+    }),
+    wait: Type.Optional(Type.Boolean({
+        description: "Wait for the final result (default true). False returns a recoverable delegation ID immediately.",
+    })),
+    id: Type.Optional(Type.String({
+        description: "Existing child ID. Takes precedence over agent and reuses its session.",
+    })),
+    agent: Type.Optional(Type.String({
+        description: "Agent definition for a new child. Ignored whenever id is supplied.",
+    })),
+    cwd: Type.Optional(Type.String({ description: "Working directory for a new child; ignored with id." })),
+}, { additionalProperties: false });
+export const delegateToolMetadata = {
+    name: "delegate",
+    description: "Delegate work to a new or existing Pi agent. Supply agent to start a new session, or id to continue an existing one; with both, id wins and agent is ignored. Returns the delegation's id, revision, status and hasOutput, and by default waits for the result.",
+    inputSchema: delegateInputSchema,
+};
+/** Validate untrusted MCP arguments before submitting them to the manager. */
+export function parseDelegateInput(input) {
+    if (!Value.Check(delegateInputSchema, input)) {
+        throw new Error("Invalid delegate parameters");
+    }
+    if (stripHindsightContent(input.task) === "")
+        throw new Error("Task must not be empty");
+    if (input.id !== undefined) {
+        if (input.id.trim() === "")
+            throw new Error("Child id must not be empty");
+    }
+    else if (input.agent === undefined || input.agent.trim() === "") {
+        throw new Error("Agent is required without an id");
+    }
+    return input;
+}

package/dist/mcp/views.d.ts

@@ -0,0 +1,5 @@
+export declare const TASK_CARD_URI = "ui://hheei/subagents/task";
+export declare const DASHBOARD_URI = "ui://hheei/subagents/dashboard";
+export declare const APP_MIME = "text/html;profile=mcp-app";
+/** Static MCP Apps page. `{{VIEW}}` is `task` or `dashboard`; the file ships beside this module in dist. */
+export declare function readAppHtml(kind: "task" | "dashboard"): Promise<string>;

package/dist/mcp/views.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+export const TASK_CARD_URI = "ui://hheei/subagents/task";
+export const DASHBOARD_URI = "ui://hheei/subagents/dashboard";
+export const APP_MIME = "text/html;profile=mcp-app";
+let template;
+/** Static MCP Apps page. `{{VIEW}}` is `task` or `dashboard`; the file ships beside this module in dist. */
+export async function readAppHtml(kind) {
+    template ??= readFile(new URL("./app.html", import.meta.url), "utf8");
+    const html = await template;
+    const title = kind === "task" ? "Subagent" : "Subagents";
+    return html.replaceAll("{{VIEW}}", kind).replaceAll("{{TITLE}}", title);
+}

package/dist/mcp-server.d.ts

@@ -0,0 +1,6 @@
+import { type McpServer } from "@modelcontextprotocol/server";
+/**
+ * MCP Apps descriptor metadata. The ext-apps package is not a dependency: its peers pull React and
+ * Zod, and a host only needs both resource URI keys plus the mcp-app HTML MIME type.
+ */
+export declare function createSubagentMcpServer(controllerSocket: () => Promise<string>, workspace: string): McpServer;

package/dist/mcp-server.js

@@ -0,0 +1,287 @@
+import { fromJsonSchema, McpServer as Server } from "@modelcontextprotocol/server";
+import { discoverAgents } from "./agent-resolver.js";
+import { callController } from "./controller-ipc.js";
+import { isOperationError } from "./domain.js";
+import { delegateToolMetadata, parseDelegateInput } from "./mcp/delegate.js";
+import { APP_MIME, DASHBOARD_URI, readAppHtml, TASK_CARD_URI } from "./mcp/views.js";
+const APP_ONLY = { ui: { visibility: ["app"] } };
+const BOTH = { ui: { visibility: ["model", "app"] } };
+/**
+ * MCP Apps descriptor metadata. The ext-apps package is not a dependency: its peers pull React and
+ * Zod, and a host only needs both resource URI keys plus the mcp-app HTML MIME type.
+ */
+export function createSubagentMcpServer(controllerSocket, workspace) {
+    const server = new Server({ name: "pi_agents", version: "0.7.0" });
+    registerAppTool(server, delegateToolMetadata.name, TASK_CARD_URI, {
+        description: delegateToolMetadata.description,
+        inputSchema: fromJsonSchema(delegateToolMetadata.inputSchema),
+        handler: async (args, signal) => {
+            const input = parseDelegateInput(args);
+            return toolResult(await callController(await controllerSocket(), { op: "delegate", input }, signal));
+        },
+    });
+    registerPlain(server, "get", "Read one agent delegation: the newest by default, or one revision, with its output when asked.", {
+        type: "object",
+        additionalProperties: false,
+        required: ["id"],
+        properties: {
+            id: { type: "string", minLength: 1 },
+            revision: { type: "integer", minimum: 1 },
+            includeOutput: { type: "boolean" },
+        },
+    }, async (args, signal) => forward(controllerSocket, "get", {
+        id: requiredString(args, "id"),
+        ...(optionalPositive(args, "revision") === undefined
+            ? {}
+            : { revision: optionalPositive(args, "revision") }),
+        includeOutput: isRecord(args) && args.includeOutput === true,
+    }, signal), BOTH);
+    registerPlain(server, "stop", "Stop one agent runtime: open delegations fail, finished ones and the session are kept.", idSchema("id"), async (args, signal) => forward(controllerSocket, "stop", { id: requiredString(args, "id") }, signal), BOTH);
+    registerAppTool(server, "dashboard", DASHBOARD_URI, {
+        description: "List this workspace's agents with their runtime state and latest delegation.",
+        inputSchema: fromJsonSchema({ type: "object", additionalProperties: false, properties: {} }),
+        handler: async (_args, signal) => toolResult(await callController(await controllerSocket(), { op: "list", input: {} }, signal)),
+    });
+    registerPlain(server, "list", "List this workspace's agents with their runtime state and latest delegation.", { type: "object", additionalProperties: false, properties: {} }, async (_args, signal) => forward(controllerSocket, "list", {}, signal), APP_ONLY);
+    registerPlain(server, "transcript", "Read one page of an agent's session history.", {
+        type: "object",
+        additionalProperties: false,
+        required: ["id"],
+        properties: {
+            id: { type: "string", minLength: 1 },
+            cursor: { type: "integer", minimum: 0 },
+            limit: { type: "integer", minimum: 1, maximum: 50 },
+        },
+    }, async (args, signal) => forward(controllerSocket, "transcript", {
+        id: requiredString(args, "id"),
+        cursor: optionalNumber(args, "cursor"),
+        limit: optionalNumber(args, "limit"),
+    }, signal), APP_ONLY);
+    registerPlain(server, "receipts", "List recent delegations of this workspace as id and revision, without their output.", {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            cursor: { type: "integer", minimum: 0 },
+            limit: { type: "integer", minimum: 1, maximum: 50 },
+        },
+    }, async (args, signal) => forward(controllerSocket, "receipts", {
+        cursor: optionalNumber(args, "cursor"),
+        limit: optionalNumber(args, "limit"),
+    }, signal), APP_ONLY);
+    registerPlain(server, "catalog", "List agent definitions available to a new agent.", { type: "object", additionalProperties: false, properties: {} }, async () => {
+        const agents = await discoverAgents(workspace);
+        return {
+            text: agents.map((agent) => agent.name).join(", "),
+            structuredContent: {
+                agents: agents.map((agent) => ({ name: agent.name, enabled: agent.enabled === true })),
+            },
+            isError: false,
+        };
+    }, APP_ONLY);
+    registerHtml(server, "Agent task", TASK_CARD_URI, "task");
+    registerHtml(server, "Agent dashboard", DASHBOARD_URI, "dashboard");
+    return server;
+}
+async function forward(controllerSocket, op, input, signal) {
+    return toolResult(await callController(await controllerSocket(), { op, input }, signal));
+}
+function registerAppTool(server, name, resourceUri, tool) {
+    registerPlain(server, name, tool.description, undefined, tool.handler, { ui: { resourceUri, visibility: ["model", "app"] }, "ui/resourceUri": resourceUri }, tool.inputSchema);
+}
+function registerPlain(server, name, description, schema, handler, visibility, inputSchema = schema === undefined ? undefined : fromJsonSchema(schema)) {
+    server.registerTool(name, {
+        description,
+        ...(inputSchema === undefined ? {} : { inputSchema }),
+        ...(visibility === undefined ? {} : { _meta: visibility }),
+    }, async (args, ctx) => {
+        const payload = await handler(args, ctx.mcpReq.signal);
+        return {
+            content: [{ type: "text", text: payload.text }],
+            structuredContent: payload.structuredContent,
+            isError: payload.isError,
+        };
+    });
+}
+function registerHtml(server, name, uri, kind) {
+    server.registerResource(name, uri, { mimeType: APP_MIME, description: name }, async (resource) => ({
+        contents: [{ uri: resource.href, mimeType: APP_MIME, text: await readAppHtml(kind) }],
+    }));
+}
+function toolResult(reply) {
+    if (!reply.ok || !isRecord(reply.result)) {
+        const error = reply.error ?? "Controller call failed";
+        return { text: error, structuredContent: { error }, isError: true };
+    }
+    const value = reply.result;
+    if (isOperationError(value)) {
+        return {
+            text: value.reason,
+            structuredContent: {
+                error: value.reason,
+                operation: value.operation,
+                ...(typeof value.childId === "string" ? { id: value.childId } : {}),
+                ...(Array.isArray(value.sideEffects)
+                    ? { sideEffects: value.sideEffects.filter(isString) }
+                    : {}),
+                ...(typeof value.safeToRetry === "boolean" ? { safeToRetry: value.safeToRetry } : {}),
+            },
+            isError: true,
+        };
+    }
+    return {
+        text: summarize(value),
+        structuredContent: project(value),
+        isError: failedDelegation(value),
+    };
+}
+function project(value) {
+    const progress = isRecord(value.progress) ? value.progress : undefined;
+    return {
+        ...(typeof value.id === "string" ? { id: value.id } : {}),
+        ...(typeof value.revision === "number" ? { revision: value.revision } : {}),
+        ...(typeof value.status === "string" ? { status: value.status } : {}),
+        ...(typeof value.task === "string" ? { task: value.task } : {}),
+        ...(typeof value.hasOutput === "boolean" ? { hasOutput: value.hasOutput } : {}),
+        ...(typeof value.resultText === "string" ? { resultText: value.resultText } : {}),
+        ...(typeof value.agent === "string" ? { agent: value.agent } : {}),
+        ...(typeof value.cwd === "string" ? { cwd: value.cwd } : {}),
+        ...(typeof value.createdAt === "number" ? { createdAt: value.createdAt } : {}),
+        ...(typeof value.delivery === "string" ? { delivery: value.delivery } : {}),
+        ...(progress === undefined
+            ? {}
+            : {
+                progress: {
+                    runtimeState: typeof progress.runtimeState === "string" ? progress.runtimeState : "unknown",
+                    ...(typeof progress.summary === "string" ? { summary: progress.summary } : {}),
+                    ...(typeof progress.activeTool === "string" ? { activeTool: progress.activeTool } : {}),
+                },
+            }),
+        ...(isRecord(value.error) ? { error: cleanError(value.error) } : {}),
+        ...(typeof value.total === "number" ? { total: value.total } : {}),
+        ...(typeof value.running === "number" ? { running: value.running } : {}),
+        ...(typeof value.blocked === "number" ? { blocked: value.blocked } : {}),
+        ...(typeof value.completed === "number" ? { completed: value.completed } : {}),
+        ...(typeof value.failed === "number" ? { failed: value.failed } : {}),
+        ...(Array.isArray(value.children)
+            ? { children: value.children.filter(isRecord).map(cleanChild) }
+            : {}),
+        ...(Array.isArray(value.entries) ? { entries: value.entries } : {}),
+        ...(Array.isArray(value.receipts)
+            ? { receipts: value.receipts.filter(isRecord).map(cleanHistory) }
+            : {}),
+        ...(typeof value.nextCursor === "number" ? { nextCursor: value.nextCursor } : {}),
+    };
+}
+function cleanError(error) {
+    return {
+        reason: typeof error.reason === "string" ? error.reason : "Delegation failed",
+        safeToRetry: error.safeToRetry === true,
+        sideEffects: Array.isArray(error.sideEffects) ? error.sideEffects.filter(isString) : [],
+    };
+}
+function summarize(value) {
+    if (Array.isArray(value.children)) {
+        const counts = ["total", "running", "blocked", "completed", "failed"]
+            .filter((key) => typeof value[key] === "number")
+            .map((key) => `${key} ${String(value[key])}`)
+            .join(" · ");
+        const lines = value.children.filter(isRecord).map((child) => {
+            const agent = typeof child.agent === "string" ? ` (${child.agent})` : "";
+            const state = typeof child.runtimeState === "string" ? child.runtimeState : "unknown";
+            const status = typeof child.status === "string" ? ` / ${child.status}` : "";
+            const revision = typeof child.revision === "number" ? ` · rev ${child.revision}` : "";
+            const summary = typeof child.summary === "string" ? ` — ${child.summary}` : "";
+            return `- ${String(child.id)}${agent}: ${state}${status}${revision}${summary}`;
+        });
+        const head = value.children.length === 0 ? "No agents" : counts;
+        return lines.length === 0 ? head : `${head}\n${lines.join("\n")}`;
+    }
+    if (Array.isArray(value.entries))
+        return `${value.entries.length} entries`;
+    if (Array.isArray(value.receipts))
+        return `${value.receipts.length} receipts`;
+    if (typeof value.id === "string" && typeof value.status === "string") {
+        const agent = typeof value.agent === "string" ? ` (${value.agent})` : "";
+        const revision = typeof value.revision === "number" ? ` · rev ${value.revision}` : "";
+        const progress = isRecord(value.progress) ? value.progress : undefined;
+        const runtime = progress !== undefined && typeof progress.runtimeState === "string"
+            ? ` (${progress.runtimeState})`
+            : "";
+        const active = progress !== undefined &&
+            typeof progress.activeTool === "string" &&
+            progress.activeTool !== ""
+            ? `: running ${progress.activeTool}`
+            : "";
+        const error = isRecord(value.error) && typeof value.error.reason === "string"
+            ? `\nError: ${value.error.reason}`
+            : "";
+        const body = typeof value.resultText === "string" && value.resultText !== ""
+            ? `\n${value.resultText}`
+            : value.hasOutput === true
+                ? "\nThe output was not requested; read it with includeOutput."
+                : "";
+        return `${value.id}${agent} ${value.status}${runtime}${revision}${active}${error}${body}`;
+    }
+    return "ok";
+}
+function cleanChild(child) {
+    return {
+        id: typeof child.id === "string" ? child.id : "",
+        ...(typeof child.agent === "string" ? { agent: child.agent } : {}),
+        runtimeState: typeof child.runtimeState === "string" ? child.runtimeState : "unknown",
+        revision: typeof child.revision === "number" ? child.revision : 0,
+        status: typeof child.status === "string" ? child.status : "unknown",
+        hasOutput: child.hasOutput === true,
+        ...(typeof child.summary === "string" ? { summary: child.summary } : {}),
+    };
+}
+function cleanHistory(receipt) {
+    return {
+        id: typeof receipt.id === "string" ? receipt.id : "",
+        revision: typeof receipt.revision === "number" ? receipt.revision : 0,
+        status: typeof receipt.status === "string" ? receipt.status : "unknown",
+        task: typeof receipt.task === "string" ? receipt.task : "",
+        hasOutput: receipt.hasOutput === true,
+        createdAt: typeof receipt.createdAt === "number" ? receipt.createdAt : 0,
+    };
+}
+function failedDelegation(value) {
+    return value.status === "failed" || value.status === "uncertain" || value.status === "blocked";
+}
+function isString(value) {
+    return typeof value === "string";
+}
+function idSchema(name) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: [name],
+        properties: { [name]: { type: "string", minLength: 1 } },
+    };
+}
+function requiredString(args, key) {
+    const value = isRecord(args) ? args[key] : undefined;
+    if (typeof value !== "string" || value === "")
+        throw new Error(`${key} is required`);
+    return value;
+}
+function optionalNumber(args, key) {
+    if (!isRecord(args) || args[key] === undefined)
+        return undefined;
+    const value = args[key];
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${key} must be an integer`);
+    }
+    return value;
+}
+function optionalPositive(args, key) {
+    const value = optionalNumber(args, key);
+    if (value === undefined)
+        return undefined;
+    if (value < 1)
+        throw new Error(`${key} must be a positive integer`);
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/mcp-stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-stdio.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createConnection } from "node:net";
+import { fileURLToPath } from "node:url";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { controllerSocketPath, recordedControllerPid, stopPreviousController, } from "./controller.js";
+import { CONTROLLER_PROTOCOL, controllerProtocol } from "./controller-ipc.js";
+import { createControllerSocket } from "./controller-socket.js";
+import { createSubagentMcpServer } from "./mcp-server.js";
+const workspace = readWorkspace(process.argv.slice(2));
+const controllerSocket = createControllerSocket({
+    locate: () => controllerSocketPath(getAgentDir(), workspace),
+    ready: controllerReady,
+    start: () => spawnController(workspace, getAgentDir()),
+});
+serveStdio(() => createSubagentMcpServer(controllerSocket, workspace), { legacy: "serve" });
+function readWorkspace(argv) {
+    const index = argv.indexOf("--cwd");
+    const value = index === -1 ? undefined : argv[index + 1];
+    if (value === undefined || !value.startsWith("/")) {
+        console.error("pi-subagents-mcp requires --cwd /absolute/workspace");
+        process.exit(2);
+    }
+    return value;
+}
+function spawnController(cwd, agentDir) {
+    const main = fileURLToPath(new URL("./controller-main.js", import.meta.url));
+    const child = spawn(process.execPath, [main, cwd, agentDir], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stderr = "";
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+        stderr = tail(stderr, chunk);
+    });
+    return new Promise((resolve, reject) => {
+        let stdout = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            fail(new Error(stderr.trim() || "Controller did not become ready"));
+        }, 30_000);
+        const succeed = (path) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.stdout?.off("data", onStdout);
+            resolve(path);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill("SIGTERM");
+            reject(error);
+        };
+        const onStdout = (chunk) => {
+            if (settled)
+                return;
+            stdout = tail(stdout, chunk);
+            const line = stdout.split("\n").find((item) => item.startsWith("ready "));
+            if (line !== undefined)
+                succeed(line.slice("ready ".length).trim());
+        };
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", onStdout);
+        child.once("error", (error) => {
+            fail(error);
+        });
+        child.once("exit", (code) => {
+            fail(new Error(stderr.trim() || `Controller exited ${code ?? "unknown"}`));
+        });
+    });
+}
+function tail(current, chunk) {
+    const next = current + chunk;
+    return next.length > 4096 ? next.slice(-4096) : next;
+}
+/**
+ * A controller from an earlier build answers on the same socket with a call surface this build does
+ * not speak. It is replaced instead of being used, so an upgrade never keeps running old code.
+ */
+async function controllerReady(socketPath) {
+    if (!(await socketReady(socketPath)))
+        return false;
+    const agentDir = getAgentDir();
+    const owner = recordedControllerPid(agentDir, workspace);
+    const probe = await controllerProtocol(socketPath);
+    if (probe.state === "ready" && probe.protocol === CONTROLLER_PROTOCOL)
+        return true;
+    // A timeout or a refused connection is not proof of an old build. Stopping here killed a
+    // controller that had already been replaced, or one that was merely slow.
+    if (probe.state !== "foreign")
+        return false;
+    await stopPreviousController(agentDir, workspace, owner);
+    return false;
+}
+function socketReady(socketPath) {
+    return new Promise((resolve) => {
+        const socket = createConnection(socketPath);
+        const finish = (ready) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(ready);
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}

package/dist/process-lock.d.ts

@@ -7,5 +7,5 @@ export interface ProcessLock {
     release(): void;
 }
 export declare function processLockPath(stateFile: string, parentSessionId: string, subagentId: string): string | undefined;
-export declare function holdProcessLock(lockPath: string): ProcessLock;
+export declare function holdProcessLock(lockPath: string, waitMs?: number): ProcessLock;
 export declare function processLockHeld(lockPath: string): boolean;

package/dist/process-lock.js

@@ -7,11 +7,13 @@ export function processLockPath(stateFile, parentSessionId, subagentId) {
         return undefined;
     return join(dirname(stateFile), "locks", parentSessionId, `${subagentId}.lock`);
 }
-export function holdProcessLock(lockPath) {
+export function holdProcessLock(lockPath, waitMs = 2_000) {
+    if (!Number.isInteger(waitMs) || waitMs < 0)
+        throw new Error("Invalid process lock wait");
     mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });
     const db = new DatabaseSync(lockPath);
     chmodSync(lockPath, 0o600);
-    db.exec("PRAGMA busy_timeout = 2000");
+    db.exec(`PRAGMA busy_timeout = ${waitMs}`);
     db.exec("BEGIN EXCLUSIVE");
     let released = false;
     return {

package/dist/protocol.d.ts

@@ -1,13 +1,12 @@
 import { type Static, Type } from "typebox";
-export declare const DEFAULT_MAX_FRAME_BYTES: number;
-export declare const DEFAULT_MAX_PENDING_REQUESTS = 128;
+/** How many queued child events a parent that stopped reading keeps before the oldest are dropped. */
 export declare const DEFAULT_MAX_BUFFERED_EVENTS = 256;
 /**
  * Every operation one end of the bridge may ask of the other. The parent drives the child with the
  * input and state operations; the child returns reports and its Task result as requests, so a
  * report the parent refuses (a second Task result) is refused to the child that sent it.
  */
-export declare const BRIDGE_OPERATIONS: readonly ["prompt", "steer", "follow_up", "abort", "get_state", "get_entries", "session_facts", "shutdown", "contact_parent", "task_result"];
+export declare const BRIDGE_OPERATIONS: readonly ["prompt", "steer", "abort", "get_state", "get_entries", "session_facts", "shutdown", "contact_parent", "task_result"];
 export type BridgeOperation = (typeof BRIDGE_OPERATIONS)[number];
 /** Child-branch event: the child left the bound session, quit, or was interrupted. */
 export declare const CHILD_LIFECYCLE_EVENT: "child_lifecycle";
@@ -28,7 +27,6 @@ export declare const HelloFrameSchema: Type.TObject<{
     subagentId: Type.TString;
     runtimeIdentity: Type.TString;
     endpoint: Type.TString;
-    token: Type.TString;
     version: Type.TLiteral<1>;
     type: Type.TLiteral<"hello">;
     role: Type.TOptional<Type.TLiteral<"child">>;
@@ -41,7 +39,7 @@ export declare const RequestFrameSchema: Type.TObject<{
     version: Type.TLiteral<1>;
     type: Type.TLiteral<"request">;
     id: Type.TString;
-    operation: Type.TUnion<Type.TLiteral<"contact_parent" | "steer" | "follow_up" | "prompt" | "abort" | "get_state" | "get_entries" | "session_facts" | "shutdown" | "task_result">[]>;
+    operation: Type.TUnion<Type.TLiteral<"contact_parent" | "prompt" | "steer" | "abort" | "get_state" | "get_entries" | "session_facts" | "shutdown" | "task_result">[]>;
     payload: Type.TOptional<Type.TUnknown>;
 }>;
 export declare const BridgeErrorSchema: Type.TObject<{
@@ -80,6 +78,8 @@ export declare const ContactReportPayloadSchema: Type.TObject<{
     reason: Type.TOptional<Type.TUnion<[Type.TLiteral<"success">, Type.TLiteral<"blocked">]>>;
     message: Type.TString;
     sessionId: Type.TOptional<Type.TString>;
+    /** The compaction this report belongs to, so it settles that operation and no other. */
+    controlId: Type.TOptional<Type.TString>;
 }>;
 export declare const ChildLifecyclePayloadSchema: Type.TObject<{
     type: Type.TLiteral<"child_lifecycle">;

package/dist/protocol.js

@@ -1,8 +1,7 @@
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { PROTOCOL_VERSION } from "./domain.js";
-export const DEFAULT_MAX_FRAME_BYTES = 1024 * 1024;
-export const DEFAULT_MAX_PENDING_REQUESTS = 128;
+/** How many queued child events a parent that stopped reading keeps before the oldest are dropped. */
 export const DEFAULT_MAX_BUFFERED_EVENTS = 256;
 /**
  * Every operation one end of the bridge may ask of the other. The parent drives the child with the
@@ -12,7 +11,6 @@ export const DEFAULT_MAX_BUFFERED_EVENTS = 256;
 export const BRIDGE_OPERATIONS = [
     "prompt",
     "steer",
-    "follow_up",
     "abort",
     "get_state",
     "get_entries",
@@ -45,7 +43,6 @@ const identityProperties = {
     subagentId: nonEmptyString,
     runtimeIdentity: nonEmptyString,
     endpoint: nonEmptyString,
-    token: nonEmptyString,
 };
 export const HelloFrameSchema = Type.Object({
     version: Type.Literal(PROTOCOL_VERSION),
@@ -88,6 +85,8 @@ export const ContactReportPayloadSchema = Type.Object({
     reason: Type.Optional(Type.Union([Type.Literal("success"), Type.Literal("blocked")])),
     message: nonEmptyString,
     sessionId: Type.Optional(nonEmptyString),
+    /** The compaction this report belongs to, so it settles that operation and no other. */
+    controlId: Type.Optional(nonEmptyString),
 }, { additionalProperties: false });
 export const ChildLifecyclePayloadSchema = Type.Object({
     type: Type.Literal("child_lifecycle"),