@poe-platform/safe-js 0.1.656 → 0.1.658

package/dist/agent-harness-tools/harness-dashboard.d.ts

@@ -0,0 +1,21 @@
+import { type dashboard } from "../toolcraft-design/index.js";
+import type { RunQueue } from "./run-queue.js";
+/** One view for an entire harness sequence, including work added while it runs. */
+export declare function createHarnessDashboard(options: {
+    title: string;
+    agent: string;
+    model?: string;
+    cwd: string;
+    queue: RunQueue;
+    validatePlan?: (path: string) => Promise<string>;
+}): {
+    dashboard: dashboard.Dashboard;
+    start(): void;
+    updateRun(update: Partial<dashboard.DashboardRunState>): void;
+    addUsage(usage: {
+        inputTokens: number;
+        outputTokens: number;
+    }): void;
+    dispose(): void;
+};
+export type HarnessDashboard = ReturnType<typeof createHarnessDashboard>;

package/dist/agent-harness-tools/index.d.ts

@@ -8,11 +8,15 @@ export { runWorkflowHook, type HookContext, type RunAgentFn, type RunAgentHooks,
 export { runWorkflowStage, type StageContext, type WorkflowStage } from "./stage.js";
 export { runDocumentWorkflow, type DocumentWorkflowOptions, type IterationResult, type WorkflowFileStat, type WorkflowFileSystem } from "./runner.js";
 export { runDocumentWorkflowSequence, type DocumentWorkflowSequenceOptions } from "./sequence.js";
+export { createRunQueue, type RunQueue, type RunQueueItem, type RunQueueItemStatus, type RunQueueOutcome, type RunQueueSnapshot } from "./run-queue.js";
 export { ensureSafeRunLogDir, makeRunLogFileName, resolveRunLogDir, slugifyPlanPath, type RunLogFileSystem, type ResolveRunLogDirOptions } from "./run-logs.js";
 export { streamLogFile, waitForExit, wrapForLogTee, type LogStreamEnv, type LogStreamFs } from "./log-stream.js";
 export { createPoeCommandSession, runPoeCommand, type PoeCommandSession } from "./run-poe-command.js";
 export { createBinaryExistsDetectors, type BinaryExistsDetector, type BinaryExistsDetectorResult } from "./binary-exists.js";
 export { applyRuntimeOverrides, resolvePoeCommandExecution, UnsupportedRuntimeCapabilityError, type RuntimeOverrideOptions } from "./poe-command-execution.js";
 export { skillPlanConfigSection } from "./skill-config.js";
+export { createHarnessDashboard, type HarnessDashboard } from "./harness-dashboard.js";
+export { mapSourcePathIntoWorktree } from "./worktree-path.js";
+export { formatRunQueueSummary } from "./run-queue-summary.js";
 export * from "./execution-env.js";
 export * from "./workspace-transfer.js";

package/dist/agent-harness-tools/plans.d.ts

@@ -31,5 +31,5 @@ export interface OpenPlanListOptions {
 }
 export declare function parsePlanReadiness(value: unknown): PlanReadiness;
 export declare function discoverPlans(options: DiscoverPlansOptions): Promise<PlanRef[]>;
-export declare const archivePlan: (options: ArchivePlanOptions) => Promise<void>;
+export declare const archivePlan: (options: ArchivePlanOptions) => Promise<string>;
 export declare function openPlanList(options: OpenPlanListOptions): Promise<TaskList>;

package/dist/agent-harness-tools/run-queue-summary.d.ts

@@ -0,0 +1,2 @@
+import type { RunQueueSnapshot } from "./run-queue.js";
+export declare function formatRunQueueSummary(snapshot: RunQueueSnapshot): string;

package/dist/agent-harness-tools/run-queue.d.ts

@@ -0,0 +1,38 @@
+export type RunQueueOutcome = "completed" | "failed" | "cancelled" | "paused";
+export type RunQueueItemStatus = "pending" | "running" | RunQueueOutcome;
+export type RunQueueItem = Readonly<{
+    id: string;
+    status: RunQueueItemStatus;
+} & ({
+    kind: "plan";
+    path: string;
+} | {
+    kind: "message";
+    text: string;
+    afterPlanId: string;
+})>;
+export type RunQueueSnapshot = Readonly<{
+    status: "idle" | "running" | RunQueueOutcome;
+    items: readonly RunQueueItem[];
+    activePlanId?: string;
+    activeItemId?: string;
+}>;
+export type RunQueue = ReturnType<typeof createRunQueue>;
+/** A live, ordered sequence shared by harness runtimes and their interactive views. */
+export declare function createRunQueue(options: {
+    plans: readonly string[];
+    afterEachPlan?: readonly string[];
+    cwd?: string;
+}): {
+    getSnapshot: () => RunQueueSnapshot;
+    enqueuePlan: (planPath: string) => string;
+    enqueueValidatedPlan: (planPath: string, validate: (path: string) => Promise<string>) => Promise<string>;
+    enqueueMessage: (text: string, afterPlanId?: string) => string;
+    onChange(listener: (snapshot: RunQueueSnapshot) => void): () => void;
+    run: (runtime: {
+        signal?: AbortSignal;
+        /** Stop between items, preserving already completed and still pending work. */
+        shouldPause?: () => boolean;
+        execute(item: RunQueueItem): Promise<RunQueueOutcome>;
+    }) => Promise<RunQueueSnapshot>;
+};

package/dist/agent-harness-tools/worktree-path.d.ts

@@ -0,0 +1,2 @@
+/** Keep repository-absolute paths inside the selected execution worktree. */
+export declare function mapSourcePathIntoWorktree(sourceCwd: string, sourcePath: string, worktreeCwd: string): string;

package/dist/agent-spawn/acp/middleware.d.ts

@@ -6,6 +6,7 @@ export interface SessionToolCall {
     title?: string;
     input?: unknown;
     path?: string;
+    status?: "completed" | "failed" | "cancelled";
 }
 export interface SessionResult {
     output: string;

package/dist/agent-spawn/acp/types.d.ts

@@ -16,6 +16,7 @@
  * TODO: Consider full ACP alignment (JSON-RPC, official discriminators, `execute` tool kind) if we need
  * interop with Zed/JetBrains/other ACP clients.
  */
+import type { Plan } from "../../poe-acp-client/index.js";
 export type ToolKind = "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
 /** ACP-compatible type - @see https://agentclientprotocol.com/ - no package dependency, structural compatibility only */
 export type ToolCallStatus = "pending" | "in_progress" | "completed" | "failed" | "cancelled";
@@ -118,6 +119,7 @@ export interface ToolStartEvent {
     kind: string;
     title: string;
     id?: string;
+    input?: unknown;
     _meta?: Record<string, unknown>;
 }
 /**
@@ -131,6 +133,7 @@ export interface ToolCompleteEvent {
     kind: string;
     path: string;
     id?: string;
+    status?: "completed" | "failed" | "cancelled";
     _meta?: Record<string, unknown>;
 }
 export interface ReasoningEvent {
@@ -138,6 +141,13 @@ export interface ReasoningEvent {
     text: string;
     _meta?: Record<string, unknown>;
 }
+/** An agent's own checklist, separate from harness tasks and queued plan files. */
+export interface PlanEvent {
+    event: "plan";
+    id?: string;
+    entries: Plan["entries"];
+    _meta?: Record<string, unknown>;
+}
 export interface UsageEvent {
     event: "usage";
     inputTokens: number;
@@ -173,7 +183,7 @@ export interface SpawnResultEvent {
     protocolVersion?: number;
     _meta?: Record<string, unknown>;
 }
-export type KnownAcpEvent = SessionStartEvent | AgentMessageEvent | ToolStartEvent | ToolCompleteEvent | ReasoningEvent | UsageEvent | ErrorEvent | PermissionRejectedEvent | SpawnResultEvent;
+export type KnownAcpEvent = SessionStartEvent | AgentMessageEvent | ToolStartEvent | ToolCompleteEvent | ReasoningEvent | PlanEvent | UsageEvent | ErrorEvent | PermissionRejectedEvent | SpawnResultEvent;
 export type UnknownAcpEvent = {
     event: string;
 } & Record<string, unknown>;

package/dist/poe-acp-client/acp-client.d.ts

@@ -0,0 +1,144 @@
+import { AcpTransport, type AcpTransportClosedEvent, type AcpTransportOptions } from "./acp-transport.js";
+import type { JsonRpcRequestOptions } from "./jsonrpc-message-layer.js";
+import { type AgentCapabilities, type AuthenticateResponse, type AuthMethod, type ClientCapabilities, type ContentBlock, type EnvVariable, type Implementation, type InitializeResponse, type LoadSessionResponse, type McpServer, type NewSessionResponse, type PermissionOption, type PromptResponse, type RequestId, type SessionConfigId, type SessionConfigOption, type SessionConfigValueId, type RequestPermissionOutcome, type ProtocolVersion, type SessionModeId, type SessionId, type SetSessionModeResponse, type SessionUpdateNotification, type ToolCallUpdate, type TerminalOutputResponse, type WaitForTerminalExitResponse } from "./types.js";
+export type AcpClientState = "uninitialized" | "initialized" | "ready";
+type ExtensionMethod = `_${string}`;
+export interface PromptTurn extends AsyncIterable<SessionUpdateNotification> {
+    response: Promise<PromptResponse>;
+}
+export interface AcpClientFsHandler {
+    readTextFile?: (args: {
+        sessionId: SessionId;
+        path: string;
+        line?: number | null;
+        limit?: number | null;
+    }) => string | Promise<string>;
+    writeTextFile?: (args: {
+        sessionId: SessionId;
+        path: string;
+        content: string;
+    }) => void | Promise<void>;
+}
+export interface AcpClientTerminalHandler {
+    create: (args: {
+        sessionId: SessionId;
+        command: string;
+        args?: string[];
+        cwd?: string | null;
+        env?: EnvVariable[];
+        outputByteLimit?: number | null;
+    }) => string | Promise<string>;
+    output: (args: {
+        sessionId: SessionId;
+        terminalId: string;
+    }) => TerminalOutputResponse | Promise<TerminalOutputResponse>;
+    waitForExit: (args: {
+        sessionId: SessionId;
+        terminalId: string;
+    }) => WaitForTerminalExitResponse | Promise<WaitForTerminalExitResponse>;
+    kill: (args: {
+        sessionId: SessionId;
+        terminalId: string;
+    }) => void | Promise<void>;
+    release: (args: {
+        sessionId: SessionId;
+        terminalId: string;
+    }) => void | Promise<void>;
+}
+type AcpClientPermissionHandler = (args: {
+    toolCall: ToolCallUpdate;
+    options: PermissionOption[];
+}) => RequestPermissionOutcome | Promise<RequestPermissionOutcome>;
+export interface AcpClientHandlers {
+    permission?: AcpClientPermissionHandler;
+    fs?: AcpClientFsHandler;
+    terminal?: AcpClientTerminalHandler;
+}
+type AcpClientTransport = Pick<AcpTransport, "sendRequest" | "sendNotification" | "onRequest" | "onNotification"> & Partial<Pick<AcpTransport, "dispose" | "closed">>;
+interface AcpClientSharedOptions {
+    protocolVersion?: ProtocolVersion;
+    clientCapabilities?: ClientCapabilities;
+    clientInfo?: Implementation | null;
+    handlers?: AcpClientHandlers;
+    permissionHandler?: AcpClientPermissionHandler;
+    fsHandler?: AcpClientFsHandler;
+    terminalHandler?: AcpClientTerminalHandler;
+    skipAuth?: boolean;
+    /**
+     * Automatically approve all permission requests (selects the first
+     * "allow_always" or "allow_once" option). Ignored when a custom
+     * `permissionHandler` is provided.
+     */
+    autoApprove?: boolean;
+}
+export interface AcpClientProcessOptions extends AcpClientSharedOptions {
+    command: string;
+    args?: readonly string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    firstRequestId?: number;
+    spawn?: AcpTransportOptions["spawn"];
+}
+export interface AcpClientInjectedTransportOptions extends AcpClientSharedOptions {
+    transport: AcpClientTransport;
+}
+export type AcpClientOptions = AcpClientProcessOptions | AcpClientInjectedTransportOptions;
+export declare class AcpClient {
+    private readonly transport;
+    private readonly clientProtocolVersion;
+    private clientCapabilities?;
+    private readonly clientInfo?;
+    private readonly skipAuth;
+    private readonly permissionHandler?;
+    private readonly fsHandler?;
+    private readonly terminalHandler?;
+    private readonly activePromptUpdates;
+    private readonly trackedTerminalIds;
+    private hasRegisteredFsReadHandler;
+    private hasRegisteredFsWriteHandler;
+    private hasRegisteredTerminalHandlers;
+    private disposed;
+    private transportDisposed;
+    private initializing;
+    private authenticating;
+    private lifecycleState;
+    private negotiatedVersion;
+    private availableAuthMethods;
+    private negotiatedAgentCapabilities;
+    private negotiatedAgentInfo;
+    constructor(options: AcpClientOptions);
+    get state(): AcpClientState;
+    get negotiatedProtocolVersion(): ProtocolVersion | null;
+    get authMethods(): AuthMethod[];
+    get agentCapabilities(): AgentCapabilities | undefined;
+    get agentInfo(): Implementation | null | undefined;
+    get closed(): Promise<AcpTransportClosedEvent> | undefined;
+    initialize(clientCapabilities?: ClientCapabilities): Promise<InitializeResponse>;
+    authenticate(methodId: string): Promise<AuthenticateResponse>;
+    newSession(cwd: string, mcpServers: McpServer[]): Promise<NewSessionResponse>;
+    loadSession(sessionId: SessionId, cwd: string, mcpServers: McpServer[]): Promise<LoadSessionResponse>;
+    cancelSession(sessionId: SessionId): Promise<void>;
+    setMode(sessionId: SessionId, modeId: SessionModeId): Promise<SetSessionModeResponse>;
+    setConfigOption(sessionId: SessionId, configId: SessionConfigId, value: SessionConfigValueId): Promise<SessionConfigOption[]>;
+    prompt(sessionId: SessionId, content: ContentBlock[]): PromptTurn;
+    sendExtRequest<TResult = unknown>(method: ExtensionMethod, params?: unknown, options?: JsonRpcRequestOptions): Promise<TResult>;
+    sendExtNotification(method: ExtensionMethod, params?: unknown): Promise<void>;
+    onExtRequest<TMethod extends ExtensionMethod>(method: TMethod, handler: (params: unknown, context: {
+        id: RequestId;
+        method: TMethod;
+    }) => unknown | Promise<unknown>): void;
+    onExtNotification<TMethod extends ExtensionMethod>(method: TMethod, handler: (params: unknown, context: {
+        method: TMethod;
+    }) => void | Promise<void>): void;
+    dispose(): Promise<void>;
+    assertReady(operation: string): void;
+    private assertNotDisposed;
+    private registerCapabilityHandlers;
+    private assertMcpServerCapabilitySupport;
+    private handleSessionUpdateNotification;
+    private trackTerminal;
+    private assertKnownTerminal;
+    private untrackTerminal;
+    private assertPromptContentCapabilitySupport;
+}
+export {};

package/dist/poe-acp-client/acp-transport.d.ts

@@ -0,0 +1,93 @@
+import { type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from "node:child_process";
+import { type JsonRpcNotificationHandler, type JsonRpcRequestHandler, type JsonRpcRequestOptions } from "./jsonrpc-message-layer.js";
+import type { AuthenticateRequest, AuthenticateResponse, CancelNotification, CreateTerminalRequest, CreateTerminalResponse, InitializeRequest, InitializeResponse, KillTerminalCommandRequest, KillTerminalCommandResponse, LoadSessionRequest, LoadSessionResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ReadTextFileRequest, ReadTextFileResponse, ReleaseTerminalRequest, ReleaseTerminalResponse, RequestId, RequestPermissionRequest, RequestPermissionResponse, SessionNotification, SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, SetSessionModeRequest, SetSessionModeResponse, TerminalOutputRequest, TerminalOutputResponse, WaitForTerminalExitRequest, WaitForTerminalExitResponse, WriteTextFileRequest, WriteTextFileResponse } from "./types.js";
+interface AcpRequestShape<TParams, TResult> {
+    params: TParams;
+    result: TResult;
+}
+export interface AcpAgentRequestMap {
+    initialize: AcpRequestShape<InitializeRequest, InitializeResponse>;
+    authenticate: AcpRequestShape<AuthenticateRequest, AuthenticateResponse>;
+    "session/new": AcpRequestShape<NewSessionRequest, NewSessionResponse>;
+    "session/load": AcpRequestShape<LoadSessionRequest, LoadSessionResponse>;
+    "session/prompt": AcpRequestShape<PromptRequest, PromptResponse>;
+    "session/set_mode": AcpRequestShape<SetSessionModeRequest, SetSessionModeResponse>;
+    "session/set_config_option": AcpRequestShape<SetSessionConfigOptionRequest, SetSessionConfigOptionResponse>;
+}
+export interface AcpAgentNotificationMap {
+    "session/cancel": CancelNotification;
+}
+export interface AcpClientRequestMap {
+    "session/request_permission": AcpRequestShape<RequestPermissionRequest, RequestPermissionResponse>;
+    "fs/read_text_file": AcpRequestShape<ReadTextFileRequest, ReadTextFileResponse>;
+    "fs/write_text_file": AcpRequestShape<WriteTextFileRequest, WriteTextFileResponse>;
+    "terminal/create": AcpRequestShape<CreateTerminalRequest, CreateTerminalResponse>;
+    "terminal/output": AcpRequestShape<TerminalOutputRequest, TerminalOutputResponse>;
+    "terminal/wait_for_exit": AcpRequestShape<WaitForTerminalExitRequest, WaitForTerminalExitResponse>;
+    "terminal/kill": AcpRequestShape<KillTerminalCommandRequest, KillTerminalCommandResponse>;
+    "terminal/release": AcpRequestShape<ReleaseTerminalRequest, ReleaseTerminalResponse>;
+}
+export interface AcpClientNotificationMap {
+    "session/update": SessionNotification;
+}
+type ExtensionMethod = `_${string}`;
+type SpawnFunction = (command: string, args?: ReadonlyArray<string>, options?: SpawnOptionsWithoutStdio) => ChildProcessWithoutNullStreams;
+export interface AcpTransportOptions {
+    command: string;
+    args?: readonly string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    firstRequestId?: number;
+    spawn?: SpawnFunction;
+}
+export interface AcpTransportClosedEvent {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    reason: Error;
+    stderr: string;
+}
+export declare class AcpTransport {
+    readonly closed: Promise<AcpTransportClosedEvent>;
+    private readonly command;
+    private readonly child;
+    private readonly layer;
+    private stderrOutput;
+    private static readonly STDERR_MAX_LENGTH;
+    private resolveClosed;
+    private closeEvent;
+    private closeReason;
+    private disposeStarted;
+    private disposeEscalationTimer;
+    private disposeForcedCloseTimer;
+    constructor(options: AcpTransportOptions);
+    sendRequest<TMethod extends keyof AcpAgentRequestMap>(method: TMethod, params: AcpAgentRequestMap[TMethod]["params"], options?: JsonRpcRequestOptions): Promise<AcpAgentRequestMap[TMethod]["result"]>;
+    sendRequest<TResult = unknown>(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<TResult>;
+    sendExtRequest<TResult = unknown>(method: ExtensionMethod, params?: unknown, options?: JsonRpcRequestOptions): Promise<TResult>;
+    sendNotification<TMethod extends keyof AcpAgentNotificationMap>(method: TMethod, params: AcpAgentNotificationMap[TMethod]): void;
+    sendNotification(method: string, params?: unknown): void;
+    sendExtNotification(method: ExtensionMethod, params?: unknown): void;
+    sendExtNotification(method: string, params?: unknown): void;
+    onRequest<TMethod extends keyof AcpClientRequestMap>(method: TMethod, handler: (params: AcpClientRequestMap[TMethod]["params"], context: {
+        id: RequestId;
+        method: TMethod;
+    }) => AcpClientRequestMap[TMethod]["result"] | Promise<AcpClientRequestMap[TMethod]["result"]>): void;
+    onRequest(method: string, handler: JsonRpcRequestHandler): void;
+    onExtRequest<TMethod extends ExtensionMethod>(method: TMethod, handler: (params: unknown, context: {
+        id: RequestId;
+        method: TMethod;
+    }) => unknown | Promise<unknown>): void;
+    onExtRequest(method: string, handler: JsonRpcRequestHandler): void;
+    onNotification<TMethod extends keyof AcpClientNotificationMap>(method: TMethod, handler: (params: AcpClientNotificationMap[TMethod], context: {
+        method: TMethod;
+    }) => void | Promise<void>): void;
+    onNotification(method: string, handler: JsonRpcNotificationHandler): void;
+    onExtNotification<TMethod extends ExtensionMethod>(method: TMethod, handler: (params: unknown, context: {
+        method: TMethod;
+    }) => void | Promise<void>): void;
+    onExtNotification(method: string, handler: JsonRpcNotificationHandler): void;
+    getStderrOutput(): string;
+    pendingRequestCount(): number;
+    dispose(reason?: Error): void;
+    private close;
+}
+export {};

package/dist/poe-acp-client/index.d.ts

@@ -0,0 +1,13 @@
+export { AcpClient } from "./acp-client.js";
+export { AcpTransport } from "./acp-transport.js";
+export { ACP_ERROR_CODE_AUTH_REQUIRED, ACP_ERROR_CODE_INTERNAL, ACP_ERROR_CODE_INVALID_PARAMS, ACP_ERROR_CODE_INVALID_REQUEST, ACP_ERROR_CODE_METHOD_NOT_FOUND, ACP_ERROR_CODE_PARSE, ACP_ERROR_CODE_RESOURCE_NOT_FOUND, AcpError, isAcpError, isAcpErrorCode, } from "./types.js";
+export { createJsonRpcErrorResponse, JsonRpcMessageLayer, parseJsonRpcMessage, serializeJsonRpcMessage, } from "./jsonrpc-message-layer.js";
+export { formatSessionUpdate, parseSessionUpdate } from "./jsonrpc.js";
+export { formatRunReportSummary, generateRunReportFromSessionUpdateStream, saveRunReport, } from "./run-report.js";
+export { extractMessagesFromSessionUpdateStream, extractToolCallSummariesFromSessionUpdateStream, extractUsageFromSessionUpdateStream, mapLegacyEventToSessionUpdates, } from "./stream-helpers.js";
+export type { AcpClientFsHandler, AcpClientHandlers, AcpClientInjectedTransportOptions, AcpClientOptions, AcpClientProcessOptions, AcpClientState, AcpClientTerminalHandler, PromptTurn, } from "./acp-client.js";
+export type { AcpAgentNotificationMap, AcpAgentRequestMap, AcpClientNotificationMap, AcpClientRequestMap, AcpTransportClosedEvent, AcpTransportOptions, } from "./acp-transport.js";
+export type { JsonRpcErrorObject, JsonRpcErrorResponseMessage, JsonRpcMessageLayerOptions, JsonRpcNotificationHandler, JsonRpcNotificationMessage, JsonRpcOutgoingMessage, JsonRpcRequestHandler, JsonRpcRequestMessage, JsonRpcRequestOptions, JsonRpcResponseMessage, JsonRpcSuccessResponseMessage, ParsedJsonRpcMessage, } from "./jsonrpc-message-layer.js";
+export type { GenerateRunReportOptions, RunExitStatus, RunReport, RunReportError, RunReportFileSystem, RunReportUsage, SaveRunReportOptions, SavedRunReportPaths, } from "./run-report.js";
+export type { LegacyInternalEvent, ToolCallSummary } from "./stream-helpers.js";
+export type * from "./types.js";

package/dist/poe-acp-client/jsonrpc-message-layer.d.ts

@@ -0,0 +1,85 @@
+import type { Readable, Writable } from "node:stream";
+import { AcpError, type RequestId } from "./types.js";
+export interface JsonRpcRequestMessage {
+    jsonrpc: "2.0";
+    id: RequestId;
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcNotificationMessage {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}
+export interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcSuccessResponseMessage {
+    jsonrpc: "2.0";
+    id: RequestId;
+    result: unknown;
+}
+export interface JsonRpcErrorResponseMessage {
+    jsonrpc: "2.0";
+    id: RequestId;
+    error: JsonRpcErrorObject;
+}
+export type JsonRpcResponseMessage = JsonRpcSuccessResponseMessage | JsonRpcErrorResponseMessage;
+export type JsonRpcOutgoingMessage = JsonRpcRequestMessage | JsonRpcNotificationMessage | JsonRpcResponseMessage;
+export type ParsedJsonRpcMessage = {
+    type: "request";
+    message: JsonRpcRequestMessage;
+} | {
+    type: "notification";
+    message: JsonRpcNotificationMessage;
+} | {
+    type: "response";
+    message: JsonRpcResponseMessage;
+} | {
+    type: "invalid";
+    id: RequestId;
+    error: AcpError;
+};
+export interface JsonRpcRequestOptions {
+    id?: RequestId;
+}
+export interface JsonRpcMessageLayerOptions {
+    input: Readable;
+    output: Writable;
+    firstRequestId?: number;
+}
+export type JsonRpcRequestHandler = (params: unknown, context: {
+    id: RequestId;
+    method: string;
+}) => Promise<unknown> | unknown;
+export type JsonRpcNotificationHandler = (params: unknown, context: {
+    method: string;
+}) => Promise<void> | void;
+export declare function createJsonRpcErrorResponse(id: RequestId, error: AcpError): JsonRpcErrorResponseMessage;
+export declare function serializeJsonRpcMessage(message: JsonRpcOutgoingMessage): string;
+export declare function parseJsonRpcMessage(line: string): ParsedJsonRpcMessage;
+export declare class JsonRpcMessageLayer {
+    private readonly input;
+    private readonly output;
+    private readonly requestHandlers;
+    private readonly notificationHandlers;
+    private readonly pending;
+    private nextRequestId;
+    private disposed;
+    constructor(options: JsonRpcMessageLayerOptions);
+    onRequest(method: string, handler: JsonRpcRequestHandler): void;
+    onNotification(method: string, handler: JsonRpcNotificationHandler): void;
+    pendingRequestCount(): number;
+    sendNotification(method: string, params?: unknown): void;
+    sendRequest(method: string, params?: unknown, options?: JsonRpcRequestOptions): Promise<unknown>;
+    dispose(reason?: Error): void;
+    private consumeInput;
+    private handleIncomingLine;
+    private handleResponse;
+    private handleRequest;
+    private handleNotification;
+    private sendMessage;
+    private rejectAllPending;
+}

package/dist/poe-acp-client/jsonrpc.d.ts

@@ -0,0 +1,5 @@
+import type { AcpMeta, Plan, SessionNotification, SessionUpdate, SessionUpdateNotification } from "./types.js";
+export declare function isPlan(value: unknown): value is Plan;
+export declare function isSessionNotification(value: unknown): value is SessionNotification;
+export declare function formatSessionUpdate(sessionId: string, update: SessionUpdate, meta?: AcpMeta): string;
+export declare function parseSessionUpdate(notificationLine: string): SessionUpdateNotification | null;

package/dist/poe-acp-client/run-report.d.ts

@@ -0,0 +1,60 @@
+import { type ToolCallSummary } from "./stream-helpers.js";
+import type { Cost, SessionUpdate, SessionUpdateNotification } from "./types.js";
+type SessionUpdateStreamItem = SessionUpdateNotification | SessionUpdate;
+export type RunExitStatus = "success" | "failed";
+export interface RunReportUsage {
+    used: number;
+    size: number;
+    updates: number;
+    cost?: Cost | null;
+}
+export interface RunReportError {
+    message: string;
+    toolCallId?: string;
+}
+export interface RunReport {
+    runId: string;
+    startTime: string;
+    endTime: string;
+    exitStatus: RunExitStatus;
+    toolCalls: ToolCallSummary[];
+    usage: RunReportUsage;
+    errors: RunReportError[];
+}
+export interface GenerateRunReportOptions {
+    runId?: string;
+    startTime?: string | Date;
+    endTime?: string | Date;
+    exitStatus?: RunExitStatus;
+    errors?: string[];
+    now?: () => Date;
+}
+export type RunReportFileSystem = {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<unknown>;
+    writeFile(path: string, data: string, options?: {
+        encoding?: BufferEncoding;
+        flag?: string;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    rename?(oldPath: string, newPath: string): Promise<void>;
+    realpath?(path: string): Promise<string>;
+};
+export interface SaveRunReportOptions {
+    fs?: RunReportFileSystem;
+    homeDir?: string;
+    includeRawContent?: boolean;
+    now?: () => Date;
+}
+export interface SavedRunReportPaths {
+    reportsDir: string;
+    jsonPath: string;
+    summaryPath: string;
+}
+export declare function generateRunReportFromSessionUpdateStream(stream: AsyncIterable<SessionUpdateStreamItem> | Iterable<SessionUpdateStreamItem>, options?: GenerateRunReportOptions): Promise<RunReport>;
+export declare function formatRunReportSummary(report: RunReport): string;
+export declare function saveRunReport(report: RunReport, options?: SaveRunReportOptions): Promise<SavedRunReportPaths>;
+export {};

package/dist/poe-acp-client/stream-helpers.d.ts

@@ -0,0 +1,19 @@
+import type { AgentMessageChunk, AgentThoughtChunk, SessionUpdate, SessionUpdateNotification, ToolCallStatus, ToolKind, UsageUpdate, UserMessageChunk } from "./types.js";
+type SessionUpdateStreamItem = SessionUpdateNotification | SessionUpdate;
+type MessageUpdate = UserMessageChunk | AgentMessageChunk | AgentThoughtChunk;
+export interface ToolCallSummary {
+    toolCallId: string;
+    title: string;
+    kind?: ToolKind;
+    status?: ToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+}
+export type LegacyInternalEvent = {
+    event: string;
+} & Record<string, unknown>;
+export declare function extractMessagesFromSessionUpdateStream(stream: AsyncIterable<SessionUpdateStreamItem> | Iterable<SessionUpdateStreamItem>): Promise<MessageUpdate[]>;
+export declare function extractUsageFromSessionUpdateStream(stream: AsyncIterable<SessionUpdateStreamItem> | Iterable<SessionUpdateStreamItem>): Promise<UsageUpdate[]>;
+export declare function extractToolCallSummariesFromSessionUpdateStream(stream: AsyncIterable<SessionUpdateStreamItem> | Iterable<SessionUpdateStreamItem>): Promise<ToolCallSummary[]>;
+export declare function mapLegacyEventToSessionUpdates(event: LegacyInternalEvent): SessionUpdate[];
+export {};

package/dist/poe-acp-client/types.d.ts

@@ -0,0 +1,443 @@
+export type AcpMeta = Record<string, unknown> | null;
+export interface AcpExtensible {
+    _meta?: AcpMeta;
+}
+export type Role = "assistant" | "user";
+export interface Annotations extends AcpExtensible {
+    audience?: Role[] | null;
+    lastModified?: string | null;
+    priority?: number | null;
+}
+export interface TextContent extends AcpExtensible {
+    type: "text";
+    text: string;
+    annotations?: Annotations | null;
+}
+export interface ImageContent extends AcpExtensible {
+    type: "image";
+    data: string;
+    mimeType: string;
+    uri?: string | null;
+    annotations?: Annotations | null;
+}
+export interface AudioContent extends AcpExtensible {
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: Annotations | null;
+}
+export interface ResourceLink extends AcpExtensible {
+    type: "resource_link";
+    name: string;
+    uri: string;
+    description?: string | null;
+    mimeType?: string | null;
+    size?: number | null;
+    title?: string | null;
+    annotations?: Annotations | null;
+}
+export interface TextResourceContents extends AcpExtensible {
+    text: string;
+    uri: string;
+    mimeType?: string | null;
+}
+export interface BlobResourceContents extends AcpExtensible {
+    blob: string;
+    uri: string;
+    mimeType?: string | null;
+}
+export type EmbeddedResourceResource = TextResourceContents | BlobResourceContents;
+export interface EmbeddedResource extends AcpExtensible {
+    type: "resource";
+    resource: EmbeddedResourceResource;
+    annotations?: Annotations | null;
+}
+export type ContentBlock = TextContent | ImageContent | AudioContent | ResourceLink | EmbeddedResource;
+export interface ContentChunk extends AcpExtensible {
+    content: ContentBlock;
+}
+export interface UserMessageChunk extends ContentChunk {
+    sessionUpdate: "user_message_chunk";
+}
+export interface AgentMessageChunk extends ContentChunk {
+    sessionUpdate: "agent_message_chunk";
+}
+export interface AgentThoughtChunk extends ContentChunk {
+    sessionUpdate: "agent_thought_chunk";
+}
+export type ToolKind = "read" | "write" | "execute" | "other";
+export type ToolCallStatus = "pending" | "in_progress" | "completed" | "failed" | "cancelled";
+export interface Diff extends AcpExtensible {
+    path: string;
+    newText: string;
+    oldText?: string | null;
+}
+export interface Terminal extends AcpExtensible {
+    terminalId: string;
+}
+export interface ToolCallTextContent extends TextContent {
+    type: "text";
+}
+export interface ToolCallDiffContent extends Diff {
+    type: "diff";
+}
+export interface ToolCallImageContent extends ImageContent {
+    type: "image";
+}
+export interface ToolCallResourceLinkContent extends ResourceLink {
+    type: "resource_link";
+}
+export interface ToolCallResourceContent extends EmbeddedResource {
+    type: "resource";
+}
+export interface ToolCallTerminalContent extends Terminal {
+    type: "terminal";
+}
+export type ToolCallContent = ToolCallTextContent | ToolCallDiffContent | ToolCallImageContent | ToolCallResourceLinkContent | ToolCallResourceContent | ToolCallTerminalContent;
+export interface ToolCallLocation extends AcpExtensible {
+    path: string;
+    lineNumber?: number | null;
+}
+export interface ToolCall extends AcpExtensible {
+    sessionUpdate: "tool_call";
+    toolCallId: string;
+    title: string;
+    content?: ToolCallContent[];
+    kind?: ToolKind;
+    locations?: ToolCallLocation[];
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    status?: ToolCallStatus;
+}
+export interface ToolCallUpdate extends AcpExtensible {
+    sessionUpdate: "tool_call_update";
+    toolCallId: string;
+    content?: ToolCallContent[] | null;
+    kind?: ToolKind | null;
+    locations?: ToolCallLocation[] | null;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    status?: ToolCallStatus | null;
+    title?: string | null;
+}
+export type PlanEntryPriority = "high" | "medium" | "low";
+export type PlanEntryStatus = "pending" | "in_progress" | "completed";
+export interface PlanEntry extends AcpExtensible {
+    content: string;
+    priority: PlanEntryPriority;
+    status: PlanEntryStatus;
+}
+export interface Plan extends AcpExtensible {
+    sessionUpdate: "plan";
+    entries: PlanEntry[];
+}
+export interface UnstructuredCommandInput extends AcpExtensible {
+    hint: string;
+}
+export type AvailableCommandInput = UnstructuredCommandInput;
+export interface AvailableCommand extends AcpExtensible {
+    name: string;
+    description: string;
+    input?: AvailableCommandInput | null;
+}
+export interface AvailableCommandsUpdate extends AcpExtensible {
+    sessionUpdate: "available_commands_update";
+    availableCommands: AvailableCommand[];
+}
+export type SessionModeId = string;
+export interface CurrentModeUpdate extends AcpExtensible {
+    sessionUpdate: "current_mode_update";
+    currentModeId: SessionModeId;
+}
+export type SessionConfigId = string;
+export type SessionConfigGroupId = string;
+export type SessionConfigValueId = string;
+export type SessionConfigOptionCategory = "mode" | "model" | "thought_level" | string;
+export interface SessionConfigSelectOption extends AcpExtensible {
+    value: SessionConfigValueId;
+    name: string;
+    description?: string | null;
+}
+export interface SessionConfigSelectGroup extends AcpExtensible {
+    group: SessionConfigGroupId;
+    name: string;
+    options: SessionConfigSelectOption[];
+}
+export type SessionConfigSelectOptions = SessionConfigSelectOption[] | SessionConfigSelectGroup[];
+export interface SessionConfigSelect {
+    currentValue: SessionConfigValueId;
+    options: SessionConfigSelectOptions;
+}
+export interface SessionConfigOption extends AcpExtensible, SessionConfigSelect {
+    type: "select";
+    id: SessionConfigId;
+    name: string;
+    category?: SessionConfigOptionCategory | null;
+    description?: string | null;
+}
+export interface ConfigOptionUpdate extends AcpExtensible {
+    sessionUpdate: "config_option_update";
+    configOptions: SessionConfigOption[];
+}
+export interface SessionInfoUpdate extends AcpExtensible {
+    sessionUpdate: "session_info_update";
+    title?: string | null;
+    updatedAt?: string | null;
+}
+export interface Cost {
+    amount: number;
+    currency: string;
+}
+export interface UsageUpdate extends AcpExtensible {
+    sessionUpdate: "usage_update";
+    used: number;
+    size: number;
+    cost?: Cost | null;
+}
+export type StableSessionUpdate = UserMessageChunk | AgentMessageChunk | AgentThoughtChunk | ToolCall | ToolCallUpdate | Plan | AvailableCommandsUpdate | CurrentModeUpdate | ConfigOptionUpdate;
+export type UnstableSessionUpdate = SessionInfoUpdate | UsageUpdate;
+export type SessionUpdate = StableSessionUpdate | UnstableSessionUpdate;
+export type SessionUpdateKind = SessionUpdate["sessionUpdate"];
+export type SessionId = string;
+export interface SessionNotification extends AcpExtensible {
+    sessionId: SessionId;
+    update: SessionUpdate;
+}
+export interface SessionUpdateNotification {
+    jsonrpc: "2.0";
+    method: "session/update";
+    params: SessionNotification;
+}
+export type ProtocolVersion = number;
+export type RequestId = null | number | string;
+export type StopReason = "completed" | "end_turn" | "cancelled" | "max_tokens";
+export interface Implementation extends AcpExtensible {
+    name: string;
+    version: string;
+    title?: string | null;
+}
+export interface AuthMethod extends AcpExtensible {
+    id: string;
+    name: string;
+    description?: string | null;
+}
+export interface FileSystemCapability extends AcpExtensible {
+    readTextFile?: boolean;
+    writeTextFile?: boolean;
+}
+export interface ClientCapabilities extends AcpExtensible {
+    fs?: FileSystemCapability;
+    terminal?: boolean;
+}
+export interface McpCapabilities extends AcpExtensible {
+    http?: boolean;
+    sse?: boolean;
+}
+export interface PromptCapabilities extends AcpExtensible {
+    image?: boolean;
+    audio?: boolean;
+    embeddedContext?: boolean;
+}
+export type SessionCapabilities = AcpExtensible;
+export interface AgentCapabilities extends AcpExtensible {
+    loadSession?: boolean;
+    mcpCapabilities?: McpCapabilities;
+    promptCapabilities?: PromptCapabilities;
+    sessionCapabilities?: SessionCapabilities;
+}
+export interface SessionMode extends AcpExtensible {
+    id: SessionModeId;
+    name: string;
+    description?: string | null;
+}
+export interface SessionModeState extends AcpExtensible {
+    availableModes: SessionMode[];
+    currentModeId: SessionModeId;
+}
+export interface HttpHeader extends AcpExtensible {
+    name: string;
+    value: string;
+}
+export interface EnvVariable extends AcpExtensible {
+    name: string;
+    value: string;
+}
+export interface McpServerStdio extends AcpExtensible {
+    name: string;
+    command: string;
+    args: string[];
+    env: EnvVariable[];
+}
+export interface McpServerHttp extends AcpExtensible {
+    type: "http";
+    name: string;
+    url: string;
+    headers: HttpHeader[];
+}
+export interface McpServerSse extends AcpExtensible {
+    type: "sse";
+    name: string;
+    url: string;
+    headers: HttpHeader[];
+}
+export type McpServer = McpServerStdio | McpServerHttp | McpServerSse;
+export type PermissionOptionId = string;
+export type PermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
+export interface PermissionOption extends AcpExtensible {
+    optionId: PermissionOptionId;
+    kind: PermissionOptionKind;
+    name: string;
+}
+export interface RequestPermissionCancelledOutcome extends AcpExtensible {
+    outcome: "cancelled";
+}
+export interface RequestPermissionSelectedOutcome extends AcpExtensible {
+    outcome: "selected";
+    optionId: PermissionOptionId;
+}
+export type RequestPermissionOutcome = RequestPermissionCancelledOutcome | RequestPermissionSelectedOutcome;
+export interface TerminalExitStatus extends AcpExtensible {
+    exitCode?: number | null;
+    signal?: string | null;
+}
+export declare const ACP_ERROR_CODE_PARSE = -32700;
+export declare const ACP_ERROR_CODE_INVALID_REQUEST = -32600;
+export declare const ACP_ERROR_CODE_METHOD_NOT_FOUND = -32601;
+export declare const ACP_ERROR_CODE_INVALID_PARAMS = -32602;
+export declare const ACP_ERROR_CODE_INTERNAL = -32603;
+export declare const ACP_ERROR_CODE_AUTH_REQUIRED = -32000;
+export declare const ACP_ERROR_CODE_RESOURCE_NOT_FOUND = -32002;
+export type StandardAcpErrorCode = typeof ACP_ERROR_CODE_PARSE | typeof ACP_ERROR_CODE_INVALID_REQUEST | typeof ACP_ERROR_CODE_METHOD_NOT_FOUND | typeof ACP_ERROR_CODE_INVALID_PARAMS | typeof ACP_ERROR_CODE_INTERNAL | typeof ACP_ERROR_CODE_AUTH_REQUIRED | typeof ACP_ERROR_CODE_RESOURCE_NOT_FOUND;
+export type AcpErrorCode = StandardAcpErrorCode | number;
+export declare function isAcpErrorCode(value: unknown): value is AcpErrorCode;
+export declare class AcpError extends Error {
+    readonly code: AcpErrorCode;
+    readonly data?: unknown;
+    constructor(code: AcpErrorCode, message: string, data?: unknown);
+}
+export declare function isAcpError(value: unknown): value is AcpError;
+export interface InitializeRequest extends AcpExtensible {
+    protocolVersion: ProtocolVersion;
+    clientCapabilities?: ClientCapabilities;
+    clientInfo?: Implementation | null;
+}
+export interface InitializeResponse extends AcpExtensible {
+    protocolVersion: ProtocolVersion;
+    agentCapabilities?: AgentCapabilities;
+    agentInfo?: Implementation | null;
+    authMethods?: AuthMethod[];
+}
+export interface AuthenticateRequest extends AcpExtensible {
+    methodId: string;
+}
+export type AuthenticateResponse = AcpExtensible;
+export interface NewSessionRequest extends AcpExtensible {
+    cwd: string;
+    mcpServers: McpServer[];
+}
+export interface NewSessionResponse extends AcpExtensible {
+    sessionId: SessionId;
+    configOptions?: SessionConfigOption[] | null;
+    modes?: SessionModeState | null;
+}
+export interface LoadSessionRequest extends AcpExtensible {
+    sessionId: SessionId;
+    cwd: string;
+    mcpServers: McpServer[];
+}
+export interface LoadSessionResponse extends AcpExtensible {
+    configOptions?: SessionConfigOption[] | null;
+    modes?: SessionModeState | null;
+}
+export interface PromptRequest extends AcpExtensible {
+    sessionId: SessionId;
+    prompt: ContentBlock[];
+}
+export interface PromptResponse extends AcpExtensible {
+    stopReason: StopReason;
+}
+export interface SetSessionModeRequest extends AcpExtensible {
+    sessionId: SessionId;
+    modeId: SessionModeId;
+}
+export type SetSessionModeResponse = AcpExtensible;
+export interface SetSessionConfigOptionRequest extends AcpExtensible {
+    sessionId: SessionId;
+    configId: SessionConfigId;
+    value: SessionConfigValueId;
+}
+export interface SetSessionConfigOptionResponse extends AcpExtensible {
+    configOptions: SessionConfigOption[];
+}
+export interface CancelNotification extends AcpExtensible {
+    sessionId: SessionId;
+}
+export interface RequestPermissionRequest extends AcpExtensible {
+    sessionId: SessionId;
+    toolCall: ToolCallUpdate;
+    options: PermissionOption[];
+}
+export interface RequestPermissionResponse extends AcpExtensible {
+    outcome: RequestPermissionOutcome;
+}
+export interface ReadTextFileRequest extends AcpExtensible {
+    sessionId: SessionId;
+    path: string;
+    line?: number | null;
+    limit?: number | null;
+}
+export interface ReadTextFileResponse extends AcpExtensible {
+    content: string;
+}
+export interface WriteTextFileRequest extends AcpExtensible {
+    sessionId: SessionId;
+    path: string;
+    content: string;
+}
+export type WriteTextFileResponse = AcpExtensible;
+export interface CreateTerminalRequest extends AcpExtensible {
+    sessionId: SessionId;
+    command: string;
+    args?: string[];
+    cwd?: string | null;
+    env?: EnvVariable[];
+    outputByteLimit?: number | null;
+}
+export interface CreateTerminalResponse extends AcpExtensible {
+    terminalId: string;
+}
+export interface TerminalOutputRequest extends AcpExtensible {
+    sessionId: SessionId;
+    terminalId: string;
+}
+export interface TerminalOutputResponse extends AcpExtensible {
+    output: string;
+    truncated: boolean;
+    exitStatus?: TerminalExitStatus | null;
+}
+export interface WaitForTerminalExitRequest extends AcpExtensible {
+    sessionId: SessionId;
+    terminalId: string;
+}
+export interface WaitForTerminalExitResponse extends AcpExtensible {
+    exitCode?: number | null;
+    signal?: string | null;
+}
+export interface KillTerminalCommandRequest extends AcpExtensible {
+    sessionId: SessionId;
+    terminalId: string;
+}
+export type KillTerminalCommandResponse = AcpExtensible;
+export interface ReleaseTerminalRequest extends AcpExtensible {
+    sessionId: SessionId;
+    terminalId: string;
+}
+export type ReleaseTerminalResponse = AcpExtensible;
+export interface ExtMethodRequest extends AcpExtensible {
+    method: `_${string}`;
+    params?: unknown;
+}
+export interface ExtNotification extends AcpExtensible {
+    method: `_${string}`;
+    params?: unknown;
+}

package/dist/toolcraft-design/acp/index.d.ts

@@ -2,3 +2,5 @@ export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasonin
 export type { AcpOutputState } from "./components.js";
 export { getAcpWriter, withAcpWriter } from "./writer.js";
 export type { AcpLineWriter } from "./writer.js";
+export { formatAgentPlan, renderAgentPlan } from "./plan.js";
+export type { AgentPlanEntry } from "./plan.js";

package/dist/toolcraft-design/acp/plan.d.ts

@@ -0,0 +1,10 @@
+export type AgentPlanEntry = {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+};
+/** A compact preview of an agent's checklist; the complete list stays in details. */
+export declare function formatAgentPlan(entries: readonly AgentPlanEntry[]): {
+    text: string;
+    detail?: string;
+};
+export declare function renderAgentPlan(entries: readonly AgentPlanEntry[]): void;

package/dist/toolcraft-design/dashboard/composer.d.ts

@@ -0,0 +1,24 @@
+import type { KeypressEvent } from "./terminal.js";
+export type DashboardSubmission = {
+    kind: "message" | "plan";
+    text: string;
+    afterPlanId?: string;
+};
+export type ComposerState = {
+    kind: DashboardSubmission["kind"];
+    text: string;
+    /** UTF-16 offset at a grapheme boundary. */
+    cursor: number;
+    focused: boolean;
+    afterPlanId?: string;
+    error?: string;
+    /** Preserve the intended display column across shorter rows during vertical movement. */
+    preferredColumn?: number;
+    preferredWidth?: number;
+};
+export declare function createComposerState(kind: DashboardSubmission["kind"], afterPlanId?: string): ComposerState;
+export declare function editComposer(state: ComposerState, event: KeypressEvent, width?: number): {
+    state: ComposerState;
+    handled: boolean;
+    submit?: DashboardSubmission;
+};

package/dist/toolcraft-design/dashboard/dashboard.d.ts

@@ -1,5 +1,6 @@
 import { type RenderPerformanceSnapshot } from "../render-performance.js";
 import type { FooterHint } from "./components/footer.js";
+import { type DashboardSubmission } from "./composer.js";
 import type { Command, DashboardStats, OutputItem } from "./types.js";
 export type DashboardOptions = {
     title?: string;
@@ -9,6 +10,9 @@ export type DashboardOptions = {
     hints?: FooterHint[];
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
+    appearance?: "panels" | "conversation";
+    /** Resolves once the runtime accepts the input; rejection keeps the draft editable. */
+    onSubmit?: (submission: DashboardSubmission) => void | Promise<void>;
     /** Observe bounded performance snapshots without forcing idle repaints. */
     onPerformance?: (stats: RenderPerformanceSnapshot) => void;
 };

package/dist/toolcraft-design/dashboard/index.d.ts

@@ -3,8 +3,9 @@ export { createDashboardLineBuffer, createStreamingDashboardLineBuffer } from ".
 export { limitOutputPreview, createOutputPreviewBuffer } from "./output-preview.js";
 export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
 export type { Dashboard, DashboardOptions } from "./dashboard.js";
+export type { DashboardSubmission } from "./composer.js";
 export { renderDashboardSnapshot } from "./snapshot.js";
 export type { SnapshotOptions } from "./snapshot.js";
-export type { OutputItem, OutputItemKind, DashboardStats, Command, DashboardState } from "./types.js";
+export type { OutputItem, OutputItemKind, DashboardStats, DashboardTask, DashboardRunState, DashboardQueueItem, DashboardWorkStatus, Command, DashboardState } from "./types.js";
 export { defaultHints } from "./components/footer.js";
 export type { FooterHint } from "./components/footer.js";

package/dist/toolcraft-design/dashboard/types.d.ts

@@ -5,6 +5,41 @@ export type OutputItem = {
     kind: OutputItemKind;
     text: string;
     ts: number;
+    role?: "agent" | "reasoning" | "action" | "user" | "plan";
+    detail?: string;
+};
+export type DashboardWorkStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "paused";
+export type DashboardQueueItem = Readonly<{
+    id: string;
+    status: DashboardWorkStatus;
+} & ({
+    kind: "plan";
+    path: string;
+} | {
+    kind: "message";
+    text: string;
+    afterPlanId: string;
+})>;
+export type DashboardTask = {
+    id: string;
+    title: string;
+    status: DashboardWorkStatus;
+    steps?: Array<{
+        name: string;
+        status: DashboardWorkStatus;
+    }>;
+};
+export type DashboardRunState = {
+    agent?: string;
+    model?: string;
+    cwd?: string;
+    phase?: string;
+    activity?: string;
+    activePlanId?: string;
+    activeTaskId?: string;
+    activeStep?: string;
+    queue?: readonly DashboardQueueItem[];
+    tasks?: readonly DashboardTask[];
 };
 export type DashboardStats = {
     status: "idle" | "running" | "paused" | "done" | "error";
@@ -21,6 +56,8 @@ export type DashboardStats = {
         agent: string;
         model?: string;
     };
+    usageAvailable?: boolean;
+    run?: DashboardRunState;
 };
 export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log" | "scroll-up" | "scroll-down" | "page-up" | "page-down" | "follow" | "render-stats";
 export type DashboardState = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-js",
-  "version": "0.1.656",
+  "version": "0.1.658",
   "description": "Budgeted JavaScript interpreter with explicit host capabilities and resumable execution",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.656",
+    "@poe-platform/safe-fs": "0.1.658",
     "temporal-polyfill": "1.0.4",
     "@petamoriken/float16": "^3.9.3",
     "@formatjs/intl-localematcher": "0.8.13",