personal-bot 0.2.4 → 0.2.5

package/lib/storage/atomic-json.js

@@ -0,0 +1,101 @@
+import { constants, closeSync, fstatSync, fsyncSync, linkSync, lstatSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { canonical } from "../common/json.js";
+import { requireThat } from "../common/validation.js";
+/** The root must already exist. Never follow aliases inside internal storage. */
+export function internalPath(directory, relative) {
+    const parts = relative.split("/");
+    requireThat(parts.every(part => part && part !== "." && part !== ".." && !/[\\\x00-\x1f]/.test(part)), "内部状态路径无效。");
+    const info = lstatSync(directory);
+    requireThat(info.isDirectory() && !info.isSymbolicLink(), "内部状态必须使用普通目录。");
+    let path = realpathSync(directory);
+    for (const [index, part] of parts.entries()) {
+        path = join(path, part);
+        try {
+            const info = lstatSync(path);
+            requireThat(!info.isSymbolicLink() && (index === parts.length - 1 ? info.isFile() : info.isDirectory()), "内部状态不能使用符号链接或特殊文件。");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" || index !== parts.length - 1)
+                throw error;
+        }
+    }
+    return path;
+}
+export function syncDirectory(directory) {
+    const fd = openSync(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Validators return plain data and must reject incomplete contracts. */
+export function readJsonFile(directory, relative, validate) {
+    const path = internalPath(directory, relative);
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        requireThat(fstatSync(fd).isFile(), "内部状态必须是普通文件。");
+        let value;
+        try {
+            value = JSON.parse(readFileSync(fd, "utf8"));
+        }
+        catch (error) {
+            throw new Error("内部 JSON 文件不可读取：" + relative, { cause: error });
+        }
+        return validate(value);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * A failure after publication does not mean that the old value remains.
+ * Callers must stop writes/sends on I/O failure, even if a subsequent read succeeds.
+ * createOnly publishes by link, so an existing destination is never overwritten.
+ */
+export function writeJsonFile(directory, relative, value, validate, createOnly = false) {
+    const validated = validate(value);
+    // Check before touching disk: JSON.stringify alone silently drops unsupported values.
+    const expected = canonical(validated);
+    const content = JSON.stringify(validated, null, 2) + "\n";
+    requireThat(canonical(JSON.parse(content)) === expected, "JSON 序列化不能改变状态值。");
+    const path = internalPath(directory, relative), parent = dirname(path);
+    const temporary = join(parent, `.tmp-${randomUUID()}`);
+    const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        try {
+            writeFileSync(fd, content, "utf8");
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        requireThat(internalPath(directory, relative) === path, "内部状态路径已变化。");
+        if (createOnly) {
+            try {
+                linkSync(temporary, path);
+            }
+            catch (error) {
+                if (error.code === "EEXIST")
+                    return false;
+                throw error;
+            }
+        }
+        else
+            renameSync(temporary, path);
+        syncDirectory(parent);
+        return true;
+    }
+    finally {
+        try {
+            unlinkSync(temporary);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}

package/lib/storage/file-access.d.ts

@@ -0,0 +1,2 @@
+export declare function fileId(id: string): string;
+export declare function privateDirectory(root: string, relative: string): void;

package/lib/storage/file-access.js

@@ -0,0 +1,26 @@
+import { lstatSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { requireThat } from "../common/validation.js";
+import { syncDirectory } from "./atomic-json.js";
+export function fileId(id) {
+    requireThat(/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(id), "内部记录 ID 无效。");
+    return id;
+}
+export function privateDirectory(root, relative) {
+    const parts = relative.split("/");
+    let parent = root;
+    for (const part of parts) {
+        fileId(part);
+        const path = join(parent, part);
+        try {
+            mkdirSync(path, { mode: 0o700 });
+            syncDirectory(parent);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        requireThat(lstatSync(path).isDirectory() && !lstatSync(path).isSymbolicLink(), "内部状态目录无效。");
+        parent = path;
+    }
+}

package/lib/storage/history-files.d.ts

@@ -0,0 +1,10 @@
+import type { HistoryHost, HistoryRecord } from "../model/history.js";
+export declare class HistoryFiles {
+    readonly directory: string;
+    readonly host: HistoryHost;
+    constructor(directory: string, host?: HistoryHost);
+    list(workspace?: string): HistoryRecord[];
+    /** The callback is synchronous: no SDK reads or model work can hold this source's write lock. */
+    control<T>(operation: () => T): T;
+    save(value: HistoryRecord): void;
+}

package/lib/storage/history-files.js

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, readdirSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { object } from "../common/json.js";
+import { requireThat } from "../common/validation.js";
+import { readJsonFile, writeJsonFile } from "./atomic-json.js";
+import { fileId } from "./file-access.js";
+const strings = (value) => Array.isArray(value) && value.every(item => typeof item === "string");
+function record(value) {
+    requireThat(object(value) && typeof value.id === "string" && typeof value.sessionId === "string" &&
+        typeof value.name === "string" && Array.isArray(value.nodes), "历史索引无效。");
+    for (const node of value.nodes)
+        requireThat(object(node) && typeof node.id === "string" &&
+            ["session", "exchange", "summary"].includes(String(node.kind)) && Number.isInteger(node.level) &&
+            strings(node.entryIds) && strings(node.parents) && strings(node.children) && typeof node.text === "string" &&
+            typeof node.from === "string" && typeof node.to === "string" && typeof node.ready === "boolean" && typeof node.completed === "boolean", "历史节点无效。");
+    const result = value, ids = new Set(result.nodes.map(node => node.id));
+    requireThat(ids.size === result.nodes.length && result.nodes.some(node => node.id === result.id && node.kind === "session") &&
+        result.nodes.every(node => [...node.parents, ...node.children].every(id => ids.has(id))), "历史节点关系无效。");
+    return result;
+}
+export class HistoryFiles {
+    directory;
+    host;
+    constructor(directory, host = "pi") {
+        this.directory = directory;
+        this.host = host;
+    }
+    list(workspace) {
+        if (!existsSync(this.directory))
+            return [];
+        return readdirSync(this.directory).filter(name => name.endsWith(".json"))
+            .map(name => readJsonFile(this.directory, name, value => {
+            const result = record(value);
+            requireThat(this.host !== "dsh" || result.id.startsWith("dsh-"), "dsh 历史根 ID 缺少来源前缀。");
+            return result;
+        }))
+            .filter(value => workspace === undefined || ("workspace" in value && value.workspace === workspace));
+    }
+    /** The callback is synchronous: no SDK reads or model work can hold this source's write lock. */
+    control(operation) {
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        const lock = join(this.directory, ".write");
+        try {
+            mkdirSync(lock, { mode: 0o700 });
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                throw Object.assign(new Error("历史来源写锁被占用：" + this.host), { code: "PBOT_HISTORY_BUSY" });
+            throw error;
+        }
+        try {
+            return operation();
+        }
+        finally {
+            rmdirSync(lock);
+        }
+    }
+    save(value) {
+        requireThat(this.host !== "dsh" || value.id.startsWith("dsh-"), "dsh 历史根 ID 缺少来源前缀。");
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        writeJsonFile(this.directory, fileId(value.id) + ".json", value, record);
+    }
+}

package/lib/storage/team-files.d.ts

@@ -0,0 +1,16 @@
+import type { TeamRecord, TeamReady, TeamLink } from "../model/team.js";
+import { AgentFiles } from "./agent-files.js";
+export declare function teamReady(v: unknown): TeamReady;
+export declare function teamRecord(v: unknown): TeamRecord;
+export declare class TeamFiles {
+    readonly agents: AgentFiles;
+    readonly root: string;
+    constructor(agents: AgentFiles);
+    check(): void;
+    read(id: string): TeamRecord;
+    list(): TeamRecord[];
+    save(value: TeamRecord, create?: boolean): void;
+    ready(id: string): TeamReady | undefined;
+    setReady(id: string, generation: string, ready: boolean): void;
+    links(records?: TeamRecord[]): Map<string, TeamLink>;
+}

package/lib/storage/team-files.js

@@ -0,0 +1,111 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { object } from "../common/json.js";
+import { requireThat } from "../common/validation.js";
+import { AgentFiles } from "./agent-files.js";
+import { readJsonFile, writeJsonFile } from "./atomic-json.js";
+import { fileId, privateDirectory } from "./file-access.js";
+const text = (v) => typeof v === "string" && v.length > 0;
+const integer = (v, min = 0) => Number.isSafeInteger(v) && v >= min;
+export function teamReady(v) {
+    requireThat(object(v) && text(v.generation) && typeof v.ready === "boolean", "团队就绪标记无效。");
+    return v;
+}
+export function teamRecord(v) {
+    requireThat(object(v) && text(v.teamId) && text(v.release) && text(v.workspace) && text(v.parentSessionId) &&
+        (v.parentLeaf === null || text(v.parentLeaf)) && text(v.name) && text(v.brief) && typeof v.closed === "boolean" &&
+        Array.isArray(v.members) && v.members.length > 0 && v.members.length <= 50 && Array.isArray(v.runs) && Array.isArray(v.messages), "团队记录无效。");
+    fileId(v.teamId);
+    const members = new Set(), runs = new Set(), requests = new Map(), operations = new Set();
+    for (const m of v.members) {
+        requireThat(object(m) && text(m.agentId) && text(m.role) && !members.has(m.agentId), "团队成员无效或重复。");
+        fileId(m.agentId);
+        members.add(m.agentId);
+    }
+    let running = 0;
+    for (const r of v.runs) {
+        requireThat(object(r) && text(r.runId) && !runs.has(r.runId) && text(r.instruction) &&
+            ["roundRobin", "parallel"].includes(String(r.mode)) && integer(r.rounds, 1) && r.rounds <= 10 &&
+            integer(r.maxConcurrent, 1) && r.maxConcurrent <= members.size && (r.mode !== "roundRobin" || r.maxConcurrent === 1) &&
+            integer(r.deadlineAt, 1) && ["running", "paused", "finished"].includes(String(r.state)) &&
+            (r.reason === undefined || text(r.reason)) && object(r.generations) && Array.isArray(r.issued), "团队批次无效。");
+        fileId(r.runId);
+        runs.add(r.runId);
+        requireThat(Object.keys(r.generations).length === members.size && [...members].every(id => text(r.generations[id])), "团队代次无效。");
+        if (r.state === "running")
+            running++;
+        const turns = new Set();
+        for (const q of r.issued) {
+            requireThat(object(q) && text(q.requestId) && !requests.has(q.requestId) && text(q.agentId) && members.has(q.agentId) &&
+                q.generation === r.generations[q.agentId] && integer(q.round, 1) && q.round <= r.rounds &&
+                integer(q.throughSeq) && q.throughSeq <= v.messages.length && !turns.has(q.agentId + ":" + q.round), "团队请求关联无效。");
+            fileId(q.requestId);
+            requests.set(q.requestId, { agentId: q.agentId, runId: r.runId });
+            turns.add(q.agentId + ":" + q.round);
+        }
+    }
+    requireThat(running <= 1 && (!v.closed || running === 0), "团队运行状态冲突。");
+    for (const [i, m] of v.messages.entries()) {
+        requireThat(object(m) && m.seq === i + 1 && text(m.operationId) && !operations.has(m.operationId) && typeof m.text === "string" &&
+            object(m.author) && ["user", "coordinator", "member"].includes(String(m.author.kind)) && text(m.author.name) &&
+            (m.author.kind === "member" ? text(m.author.agentId) && members.has(m.author.agentId) : m.author.agentId === undefined) &&
+            (m.replyTo === undefined || (integer(m.replyTo, 1) && m.replyTo <= i)) &&
+            (m.runId === undefined || (text(m.runId) && runs.has(m.runId))), "团队消息无效。");
+        if (m.source !== undefined)
+            requireThat(object(m.source) && text(m.source.requestId) && text(m.source.cycleId) &&
+                requests.get(m.source.requestId)?.agentId === m.author.agentId && requests.get(m.source.requestId)?.runId === m.runId, "团队报告关联无效。");
+        operations.add(m.operationId);
+    }
+    return v;
+}
+export class TeamFiles {
+    agents;
+    root;
+    constructor(agents) {
+        this.agents = agents;
+        this.root = join(dirname(agents.root), "teams");
+    }
+    check() { this.agents.check(); }
+    read(id) {
+        const value = readJsonFile(this.root, fileId(id) + "/team.json", teamRecord);
+        requireThat(value.teamId === id, "团队路径与身份不匹配。");
+        return value;
+    }
+    list() {
+        if (!existsSync(this.root))
+            return [];
+        return readdirSync(this.root, { withFileTypes: true }).filter(e => !e.name.startsWith(".")).map(e => this.read(e.name));
+    }
+    save(value, create = false) {
+        this.check();
+        teamRecord(value);
+        let published;
+        try {
+            mkdirSync(this.root, { recursive: true, mode: 0o700 });
+            const directory = lstatSync(this.root);
+            requireThat(directory.isDirectory() && !directory.isSymbolicLink(), "团队状态必须使用普通目录。");
+            if (create)
+                privateDirectory(this.root, fileId(value.teamId));
+            published = writeJsonFile(this.root, fileId(value.teamId) + "/team.json", value, teamRecord, create);
+        }
+        catch (error) {
+            this.agents.fail(error);
+            throw error;
+        }
+        requireThat(published, "团队已存在。");
+    }
+    ready(id) { return this.agents.optional(id, "team-ready.json", teamReady); }
+    setReady(id, generation, ready) {
+        this.agents.write(id, "team-ready.json", { generation, ready }, teamReady);
+    }
+    links(records = this.list()) {
+        const result = new Map();
+        for (const team of records)
+            for (const run of team.runs)
+                for (const request of run.issued) {
+                    requireThat(!result.has(request.requestId), "团队请求 ID 重复。");
+                    result.set(request.requestId, { team, run, request });
+                }
+        return result;
+    }
+}

package/lib/tools/agents/actions.d.ts

@@ -0,0 +1,52 @@
+import type { Static } from "typebox";
+import type { AgentService } from "../../services/agents/agent-service.js";
+import type { AgentOptions, AgentOwner } from "../../model/agent.js";
+import type { agentParametersSchema } from "./contract.js";
+export type AgentInput = Omit<Static<typeof agentParametersSchema>, "thinking"> & {
+    thinking?: string;
+};
+export declare function executeAgent(service: AgentService, input: AgentInput, owner: AgentOwner, defaults?: AgentOptions): Promise<{
+    isError?: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: import("../../common/json.js").Json;
+    structuredContent: import("../../common/json.js").Json;
+} | {
+    details: {
+        agentReadKeys?: string[];
+        error?: string;
+        requestId?: string;
+        cycle?: {
+            error?: string;
+            finishedAt?: number;
+            state: "running" | "completed" | "failed" | "cancelled" | "interrupted";
+            startedAt: number;
+            cycleId: string;
+            requestIds: string[];
+            source: "parent" | "interactive" | "mixed";
+        };
+        report?: string;
+        messageStatus?: "queued";
+        cycles?: {
+            state: string;
+            cycleId: string;
+        }[];
+        totalLength?: number;
+        nextOffset?: number | null;
+        state: "starting" | "busy" | "idle" | "stopping" | "stopped" | "error";
+        agentId: string;
+        cwd: string;
+        createdAt: number;
+        name: string;
+        activity: string;
+        owned: boolean;
+    };
+    isError?: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: import("../../common/json.js").Json;
+}>;

package/lib/tools/agents/actions.js

@@ -0,0 +1,49 @@
+import { markdownResult } from "../result.js";
+function agentOutput(view) {
+    const c = view.cycle;
+    return {
+        agentId: view.agentId, name: view.name, cwd: view.cwd, createdAt: view.createdAt,
+        owned: view.owned, state: view.state, activity: view.activity,
+        ...(c ? { cycle: { cycleId: c.cycleId, startedAt: c.startedAt, state: c.state, requestIds: c.requestIds, source: c.source,
+                ...(c.finishedAt === undefined ? {} : { finishedAt: c.finishedAt }), ...(c.error === undefined ? {} : { error: c.error }) } } : {}),
+        ...(view.error === undefined ? {} : { error: view.error }),
+        ...(view.requestId === undefined ? {} : { requestId: view.requestId }),
+        ...(view.messageStatus === undefined ? {} : { messageStatus: view.messageStatus }),
+        ...(view.cycles === undefined ? {} : { cycles: view.cycles }),
+        ...(view.report === undefined ? {} : { report: view.report }),
+        ...(view.totalLength === undefined ? {} : { totalLength: view.totalLength }),
+        ...(view.nextOffset === undefined ? {} : { nextOffset: view.nextOffset }),
+    };
+}
+export async function executeAgent(service, input, owner, defaults = {}) {
+    let value;
+    switch (input.action) {
+        case "start": {
+            const { action: _action, ...supplied } = input;
+            value = await service.start({ ...defaults, ...supplied }, owner);
+            break;
+        }
+        case "list": return markdownResult({ agents: service.list(owner).map(agentOutput) }, "子会话列表");
+        case "send":
+            value = service.send(input.agentId, input.message, input.delivery ?? "steer", owner);
+            break;
+        case "rename":
+            value = service.rename(input.agentId, input.name, owner);
+            break;
+        case "resume":
+            value = await service.resume(input.agentId, input.message, owner);
+            break;
+        case "stop":
+            value = service.stop(input.agentId, owner);
+            break;
+        case "status":
+            value = service.status(input.agentId, owner);
+            break;
+        case "read": {
+            const page = await service.read(input.agentId, owner, input.cycleId, input.offset, input.limit);
+            const data = agentOutput(page), output = markdownResult(data, "子会话报告");
+            return { ...output, details: { ...data, ...(page.cycle && page.cycle.state !== "running" ? { agentReadKeys: [page.agentId + ":" + page.cycle.cycleId] } : {}) } };
+        }
+    }
+    return markdownResult(agentOutput(value), "子会话状态");
+}

package/lib/tools/agents/contract.d.ts

@@ -0,0 +1,163 @@
+import { Type } from "typebox";
+export declare const agentDescription = "\u72EC\u7ACB\u4E13\u5BB6\u4F1A\u8BDD\uFF0C\u4E0D\u7EE7\u627F\u7236\u804A\u5929\u5386\u53F2\u3002start \u5B8C\u6210\u542F\u52A8\u540E\u8FD4\u56DE\uFF0C\u4E0D\u7B49\u5F85\u5DE5\u4F5C\u5B8C\u6210\uFF1B\u672A\u63D0\u4F9B message/prompts/files \u65F6\u53EA\u542F\u52A8\u5F85\u547D\u4F1A\u8BDD\uFF0C\u4E0D\u8C03\u7528\u6A21\u578B\u3002\u5B8C\u6210\u81EA\u52A8\u901A\u77E5\uFF0C\u65E0\u9700\u8F6E\u8BE2\u3002\u56E2\u961F\u5360\u7528\u671F\u95F4\u4E0D\u80FD\u79C1\u4EBA send\u3002send \u7EE7\u7EED\u5BF9\u8BDD\uFF0Crename \u6539\u540D\uFF0Cstatus/list \u67E5\u770B\u72B6\u6001\uFF0Cstatus \u8FD4\u56DE\u6700\u8FD1\u5468\u671F\u4E14\u4E0D\u8BFB\u53D6\u62A5\u544A\u6B63\u6587\u3002read \u975E\u963B\u585E\u8BFB\u53D6\u62A5\u544A\uFF1B\u8BFB\u53D6\u5DF2\u7ED3\u675F\u5468\u671F\u4F1A\u9886\u53D6\u8BE5\u5468\u671F\u7684\u5B8C\u6210\u901A\u77E5\uFF08\u5305\u62EC\u90E8\u5206\u8BFB\u53D6\uFF09\uFF0C\u540E\u7EED\u4E0D\u518D\u91CD\u590D\u901A\u77E5\u3002nextOffset \u975E\u7A7A\u65F6\u4EE5\u8FD4\u56DE\u7684 cycle.cycleId \u56FA\u5B9A\u5468\u671F\u7EED\u8BFB\u3002state \u662F\u6267\u884C\u72B6\u6001\uFF0Ccycle.state \u662F\u5DE5\u4F5C\u7ED3\u679C\uFF0Cqueued \u4EC5\u8868\u793A\u5165\u961F\u3002stop \u505C\u6B62\u5E76\u4FDD\u7559\u5386\u53F2\uFF0Cresume \u643A\u65B0 message \u6062\u590D\uFF0C\u4E0D\u91CD\u653E\u65E7\u5DE5\u4F5C\u3002\u72EC\u7ACB\u590D\u6838\u987B start \u65B0\u4E0A\u4E0B\u6587\u3002\u5B50\u4F1A\u8BDD\u4F7F\u7528\u539F\u751F CLI/MCP\uFF0C\u6309\u59D4\u6D3E\u8303\u56F4\u5DE5\u4F5C\uFF0C\u4E0D\u9012\u5F52\u59D4\u6D3E\u3002\u6BCF\u4E2A\u7236\u4F1A\u8BDD\u6700\u591A 50 \u4E2A\u5B58\u6D3B\u5B50\u4F1A\u8BDD\uFF0C\u7A7A\u95F2\u4E5F\u8BA1\u5165\u3002";
+export declare const agentStartOptions: {
+    name: Type.TOptional<Type.TString>;
+    message: Type.TOptional<Type.TString>;
+    files: Type.TOptional<Type.TArray<Type.TString>>;
+    prompts: Type.TOptional<Type.TArray<Type.TString>>;
+    provider: Type.TOptional<Type.TString>;
+    model: Type.TOptional<Type.TString>;
+    thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">, Type.TLiteral<"max">]>>;
+    cwd: Type.TOptional<Type.TString>;
+    tools: Type.TOptional<Type.TArray<Type.TString>>;
+    noExtensions: Type.TOptional<Type.TBoolean>;
+    noSkills: Type.TOptional<Type.TBoolean>;
+    noPromptTemplates: Type.TOptional<Type.TBoolean>;
+    noContextFiles: Type.TOptional<Type.TBoolean>;
+};
+export declare const agentParametersSchema: Type.TObject<{
+    delivery: Type.TOptional<Type.TUnion<[Type.TLiteral<"steer">, Type.TLiteral<"followUp">]>>;
+    cycleId: Type.TOptional<Type.TString>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    name: Type.TOptional<Type.TString>;
+    message: Type.TOptional<Type.TString>;
+    files: Type.TOptional<Type.TArray<Type.TString>>;
+    prompts: Type.TOptional<Type.TArray<Type.TString>>;
+    provider: Type.TOptional<Type.TString>;
+    model: Type.TOptional<Type.TString>;
+    thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">, Type.TLiteral<"max">]>>;
+    cwd: Type.TOptional<Type.TString>;
+    tools: Type.TOptional<Type.TArray<Type.TString>>;
+    noExtensions: Type.TOptional<Type.TBoolean>;
+    noSkills: Type.TOptional<Type.TBoolean>;
+    noPromptTemplates: Type.TOptional<Type.TBoolean>;
+    noContextFiles: Type.TOptional<Type.TBoolean>;
+    action: Type.TUnion<[Type.TLiteral<"start">, Type.TLiteral<"send">, Type.TLiteral<"rename">, Type.TLiteral<"status">, Type.TLiteral<"list">, Type.TLiteral<"read">, Type.TLiteral<"stop">, Type.TLiteral<"resume">]>;
+    agentId: Type.TOptional<Type.TString>;
+}>;
+export declare const agentActionSchema: Type.TUnion<[Type.TObject<{
+    name: Type.TOptional<Type.TString>;
+    message: Type.TOptional<Type.TString>;
+    files: Type.TOptional<Type.TArray<Type.TString>>;
+    prompts: Type.TOptional<Type.TArray<Type.TString>>;
+    provider: Type.TOptional<Type.TString>;
+    model: Type.TOptional<Type.TString>;
+    thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">, Type.TLiteral<"max">]>>;
+    cwd: Type.TOptional<Type.TString>;
+    tools: Type.TOptional<Type.TArray<Type.TString>>;
+    noExtensions: Type.TOptional<Type.TBoolean>;
+    noSkills: Type.TOptional<Type.TBoolean>;
+    noPromptTemplates: Type.TOptional<Type.TBoolean>;
+    noContextFiles: Type.TOptional<Type.TBoolean>;
+    action: Type.TLiteral<"start">;
+}>, Type.TObject<{
+    action: Type.TLiteral<"send">;
+    agentId: Type.TString;
+    message: Type.TString;
+    delivery: Type.TOptional<Type.TUnion<[Type.TLiteral<"steer">, Type.TLiteral<"followUp">]>>;
+}>, Type.TObject<{
+    action: Type.TLiteral<"rename">;
+    agentId: Type.TString;
+    name: Type.TString;
+}>, Type.TObject<{
+    action: Type.TLiteral<"resume">;
+    agentId: Type.TString;
+    message: Type.TString;
+}>, Type.TObject<{
+    action: Type.TLiteral<"list">;
+}>, ...Type.TObject<{
+    action: Type.TLiteral<string>;
+    agentId: Type.TString;
+}>[], Type.TObject<{
+    cycleId: Type.TOptional<Type.TString>;
+    offset: Type.TOptional<Type.TInteger>;
+    limit: Type.TOptional<Type.TInteger>;
+    action: Type.TLiteral<"read">;
+    agentId: Type.TString;
+}>]>;
+export declare const agentViewSchema: Type.TObject<{
+    agentId: Type.TString;
+    name: Type.TString;
+    cwd: Type.TString;
+    createdAt: Type.TNumber;
+    owned: Type.TBoolean;
+    state: Type.TUnion<[Type.TLiteral<"starting">, Type.TLiteral<"busy">, Type.TLiteral<"idle">, Type.TLiteral<"stopping">, Type.TLiteral<"stopped">, Type.TLiteral<"error">]>;
+    activity: Type.TString;
+    cycle: Type.TOptional<Type.TObject<{
+        cycleId: Type.TString;
+        startedAt: Type.TNumber;
+        finishedAt: Type.TOptional<Type.TNumber>;
+        state: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"interrupted">]>;
+        requestIds: Type.TArray<Type.TString>;
+        source: Type.TUnion<[Type.TLiteral<"parent">, Type.TLiteral<"interactive">, Type.TLiteral<"mixed">]>;
+        error: Type.TOptional<Type.TString>;
+    }>>;
+    error: Type.TOptional<Type.TString>;
+    requestId: Type.TOptional<Type.TString>;
+    messageStatus: Type.TOptional<Type.TLiteral<"queued">>;
+    cycles: Type.TOptional<Type.TArray<Type.TObject<{
+        cycleId: Type.TString;
+        state: Type.TString;
+    }>>>;
+    report: Type.TOptional<Type.TString>;
+    totalLength: Type.TOptional<Type.TInteger>;
+    nextOffset: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+}>;
+export declare const agentResultSchema: Type.TUnion<[Type.TObject<{
+    agentId: Type.TString;
+    name: Type.TString;
+    cwd: Type.TString;
+    createdAt: Type.TNumber;
+    owned: Type.TBoolean;
+    state: Type.TUnion<[Type.TLiteral<"starting">, Type.TLiteral<"busy">, Type.TLiteral<"idle">, Type.TLiteral<"stopping">, Type.TLiteral<"stopped">, Type.TLiteral<"error">]>;
+    activity: Type.TString;
+    cycle: Type.TOptional<Type.TObject<{
+        cycleId: Type.TString;
+        startedAt: Type.TNumber;
+        finishedAt: Type.TOptional<Type.TNumber>;
+        state: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"interrupted">]>;
+        requestIds: Type.TArray<Type.TString>;
+        source: Type.TUnion<[Type.TLiteral<"parent">, Type.TLiteral<"interactive">, Type.TLiteral<"mixed">]>;
+        error: Type.TOptional<Type.TString>;
+    }>>;
+    error: Type.TOptional<Type.TString>;
+    requestId: Type.TOptional<Type.TString>;
+    messageStatus: Type.TOptional<Type.TLiteral<"queued">>;
+    cycles: Type.TOptional<Type.TArray<Type.TObject<{
+        cycleId: Type.TString;
+        state: Type.TString;
+    }>>>;
+    report: Type.TOptional<Type.TString>;
+    totalLength: Type.TOptional<Type.TInteger>;
+    nextOffset: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+}>, Type.TObject<{
+    agents: Type.TArray<Type.TObject<{
+        agentId: Type.TString;
+        name: Type.TString;
+        cwd: Type.TString;
+        createdAt: Type.TNumber;
+        owned: Type.TBoolean;
+        state: Type.TUnion<[Type.TLiteral<"starting">, Type.TLiteral<"busy">, Type.TLiteral<"idle">, Type.TLiteral<"stopping">, Type.TLiteral<"stopped">, Type.TLiteral<"error">]>;
+        activity: Type.TString;
+        cycle: Type.TOptional<Type.TObject<{
+            cycleId: Type.TString;
+            startedAt: Type.TNumber;
+            finishedAt: Type.TOptional<Type.TNumber>;
+            state: Type.TUnion<[Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"interrupted">]>;
+            requestIds: Type.TArray<Type.TString>;
+            source: Type.TUnion<[Type.TLiteral<"parent">, Type.TLiteral<"interactive">, Type.TLiteral<"mixed">]>;
+            error: Type.TOptional<Type.TString>;
+        }>>;
+        error: Type.TOptional<Type.TString>;
+        requestId: Type.TOptional<Type.TString>;
+        messageStatus: Type.TOptional<Type.TLiteral<"queued">>;
+        cycles: Type.TOptional<Type.TArray<Type.TObject<{
+            cycleId: Type.TString;
+            state: Type.TString;
+        }>>>;
+        report: Type.TOptional<Type.TString>;
+        totalLength: Type.TOptional<Type.TInteger>;
+        nextOffset: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
+    }>>;
+}>]>;