@enter-pro/enter-cli 0.4.1 → 0.4.3

package/dist/commands/whoami.js

@@ -6,7 +6,7 @@ export const whoamiCmd = new Command("whoami")
     .description("Show current user info")
     .action(async (_opts, cmd) => {
     if (!isAuthenticated()) {
-        throw new Error("Not authenticated. Run `enter login` or set ENTER_API_KEY environment variable.");
+        throw new Error("Not authenticated. Run `enter-cli login` or set ENTER_API_KEY environment variable.");
     }
     const data = await client.get("/v1/users/info");
     const format = cmd.optsWithGlobals().output || "json";

package/dist/commands/workspace.js

@@ -1,12 +1,9 @@
 import { Command } from "commander";
 import * as client from "../client.js";
-import { print, printMessage, printTable, pickList } from "../output.js";
+import { print, printResult, printTable, pickList, getFormat } from "../output.js";
 export const workspaceCmd = new Command("workspace")
     .alias("ws")
     .description("Manage workspaces");
-function getFormat(cmd) {
-    return cmd.optsWithGlobals().output || "json";
-}
 workspaceCmd
     .command("list")
     .description("List workspaces")
@@ -68,9 +65,9 @@ workspaceCmd
 workspaceCmd
     .command("delete <workspace_id>")
     .description("Delete a workspace")
-    .action(async (id) => {
+    .action(async (id, _opts, cmd) => {
     await client.del(`/v1/workspaces/${id}`);
-    printMessage("Workspace deleted successfully.");
+    printResult(getFormat(cmd), { deleted: true, workspace_id: id }, "Workspace deleted successfully.");
 });
 // Members subcommand group
 const membersCmd = new Command("members").description("Manage workspace members");
@@ -118,7 +115,7 @@ membersCmd
     .description("Remove a member from workspace")
     .option("--email <email>", "Member email")
     .option("--user-id <id>", "Member user ID")
-    .action(async (id, opts) => {
+    .action(async (id, opts, cmd) => {
     if (!opts.email && !opts.userId) {
         throw new Error("--email or --user-id is required");
     }
@@ -128,7 +125,7 @@ membersCmd
     if (opts.userId)
         body.user_id = Number(opts.userId);
     await client.post(`/v1/workspaces/${id}/members/remove`, body);
-    printMessage("Member removed successfully.");
+    printResult(getFormat(cmd), { removed: true, workspace_id: id }, "Member removed successfully.");
 });
 membersCmd
     .command("update-role <workspace_id>")
@@ -155,9 +152,9 @@ membersCmd
 membersCmd
     .command("leave <workspace_id>")
     .description("Leave a workspace")
-    .action(async (id) => {
+    .action(async (id, _opts, cmd) => {
     await client.post(`/v1/workspaces/${id}/leave`);
-    printMessage("Left workspace successfully.");
+    printResult(getFormat(cmd), { left: true, workspace_id: id }, "Left workspace successfully.");
 });
 workspaceCmd.addCommand(membersCmd);
 // Credits subcommand group

package/dist/config.d.ts

@@ -2,7 +2,6 @@ export interface Config {
     api_url: string;
     base_path: string;
     output: string;
-    default_workspace: string;
 }
 export declare function configDir(): string;
 export declare function loadConfig(): Config;

package/dist/config.js

@@ -8,7 +8,6 @@ const defaults = {
     api_url: "https://api.enter.pro",
     base_path: "/code/api",
     output: "json",
-    default_workspace: "",
 };
 function ensureConfigDir() {
     if (!existsSync(CONFIG_DIR)) {
@@ -32,8 +31,6 @@ function getEnvOverrides() {
         overrides.base_path = process.env.ENTER_BASE_PATH;
     if (process.env.ENTER_OUTPUT)
         overrides.output = process.env.ENTER_OUTPUT;
-    if (process.env.ENTER_DEFAULT_WORKSPACE)
-        overrides.default_workspace = process.env.ENTER_DEFAULT_WORKSPACE;
     return overrides;
 }
 export function configDir() {
@@ -42,15 +39,24 @@ export function configDir() {
 export function loadConfig() {
     const fileConfig = loadFromFile();
     const envOverrides = getEnvOverrides();
-    return { ...defaults, ...fileConfig, ...envOverrides };
+    const merged = { ...defaults, ...fileConfig, ...envOverrides };
+    return Object.fromEntries(Object.keys(defaults).map(key => [key, merged[key]]));
 }
 export function setConfig(key, value) {
+    validateKey(key);
+    if (key === "output" && !["json", "yaml", "table"].includes(value))
+        throw new Error("output must be json, yaml or table");
     ensureConfigDir();
     const current = loadFromFile();
     current[key] = value;
     writeFileSync(CONFIG_FILE, yaml.dump(current), "utf-8");
 }
+function validateKey(key) {
+    if (!Object.hasOwn(defaults, key))
+        throw new Error(`Unsupported setting "${key}". Supported settings: ${Object.keys(defaults).join(", ")}. Pass workspace IDs explicitly to project commands.`);
+}
 export function getConfig(key) {
+    validateKey(key);
     const cfg = loadConfig();
     return cfg[key] || "";
 }

package/dist/errors.d.ts

@@ -1,3 +1,11 @@
+export declare class RequestError extends Error {
+    code: string;
+    retryable: boolean;
+    outcomeUnknown: boolean;
+    causeCode?: string | undefined;
+    constructor(code: string, message: string, retryable?: boolean, outcomeUnknown?: boolean, causeCode?: string | undefined);
+}
+export declare function errorEnvelope(error: unknown): Record<string, unknown>;
 export declare class APIError extends Error {
     code: number | string;
     detail: string;

package/dist/errors.js

@@ -1,3 +1,32 @@
+import { redactText } from "./safe-output.js";
+export class RequestError extends Error {
+    code;
+    retryable;
+    outcomeUnknown;
+    causeCode;
+    constructor(code, message, retryable = false, outcomeUnknown = false, causeCode) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.outcomeUnknown = outcomeUnknown;
+        this.causeCode = causeCode;
+        this.name = "RequestError";
+    }
+}
+export function errorEnvelope(error) {
+    const e = error instanceof Error ? error : new Error(String(error));
+    const request = e instanceof RequestError ? e : undefined;
+    const api = e instanceof APIError ? e : undefined;
+    return { error: {
+            code: request?.code ?? api?.code ?? "CLI_ERROR",
+            message: redactText(e.message),
+            retryable: request?.retryable ?? api?.retryable ?? false,
+            outcome_unknown: request?.outcomeUnknown ?? false,
+            ...(request?.causeCode ? { cause_code: request.causeCode } : {}),
+            ...(request?.outcomeUnknown ? { hint: "The write may have reached Enter. Inspect task/action state before retrying; do not resubmit blindly." }
+                : api?.hint ? { hint: api.hint } : {}),
+        } };
+}
 export class APIError extends Error {
     code;
     detail;

package/dist/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { createRequire } from "module";
-import { setVerbose } from "./client.js";
+import { setVerbose, setRequestTimeout } from "./client.js";
 import { loadConfig } from "./config.js";
+import { errorEnvelope } from "./errors.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 import { loginCmd } from "./commands/login.js";
@@ -21,10 +22,13 @@ program
     .version(version)
     .option("-o, --output <format>", "Output format: table, json, yaml")
     .option("-v, --verbose", "Verbose output (show HTTP requests)")
+    .option("--request-timeout <seconds>", "Optional HTTP deadline including observation read retries")
     .hook("preAction", () => {
     const opts = program.opts();
     if (opts.verbose)
         setVerbose(true);
+    if (opts.requestTimeout !== undefined)
+        setRequestTimeout(Number(opts.requestTimeout));
     if (!opts.output) {
         const cfg = loadConfig();
         program.setOptionValue("output", cfg.output);
@@ -40,6 +44,9 @@ program.addCommand(threadCmd);
 program.addCommand(domainCmd);
 program.addCommand(modelsCmd);
 program.parseAsync().catch((err) => {
-    console.error(`Error: ${err.message}`);
+    if ((program.opts().output ?? loadConfig().output) === "json")
+        console.error(JSON.stringify(errorEnvelope(err)));
+    else
+        console.error(`Error: ${err.message}`);
     process.exit(1);
 });

package/dist/output.d.ts

@@ -6,21 +6,5 @@ export declare function printMessage(msg: string): void;
 export declare function printResult(format: string, structured: unknown, message: string): void;
 import type { Command } from "commander";
 export declare function getFormat(cmd: Command): string;
-export declare function printError(err: Error | string): void;
 export declare function pick<T extends Record<string, unknown>>(obj: T, keys: string[]): Record<string, unknown>;
 export declare function pickList(items: Record<string, unknown>[], keys: string[]): Record<string, unknown>[];
-export interface ListEnvelope {
-    items: unknown[];
-    total?: number;
-    page?: number;
-    page_size?: number;
-}
-export interface TableConfig {
-    headers: string[];
-    rowMapper: (item: Record<string, unknown>) => string[];
-}
-export declare function printList(format: string, data: ListEnvelope, tableConfig?: TableConfig): void;
-export declare function printSingle(format: string, data: unknown, tableConfig?: {
-    headers: string[];
-    rowMapper: (item: Record<string, unknown>) => string[];
-}): void;

package/dist/output.js

@@ -59,9 +59,6 @@ export function printResult(format, structured, message) {
 export function getFormat(cmd) {
     return cmd.optsWithGlobals().output || "json";
 }
-export function printError(err) {
-    console.error(`Error: ${typeof err === "string" ? err : err.message}`);
-}
 export function pick(obj, keys) {
     const result = {};
     for (const key of keys) {
@@ -72,18 +69,3 @@ export function pick(obj, keys) {
 export function pickList(items, keys) {
     return items.map((item) => pick(item, keys));
 }
-export function printList(format, data, tableConfig) {
-    if (format === "table" && tableConfig) {
-        const rows = data.items.map(tableConfig.rowMapper);
-        printTable(tableConfig.headers, rows);
-        return;
-    }
-    print(format, data);
-}
-export function printSingle(format, data, tableConfig) {
-    if (format === "table" && tableConfig) {
-        printTable(tableConfig.headers, [tableConfig.rowMapper(data)]);
-        return;
-    }
-    print(format, data);
-}

package/dist/poll.d.ts

@@ -2,6 +2,7 @@ export declare class TimeoutError extends Error {
     constructor(elapsedMs: number);
 }
 export interface PollOptions {
+    signal?: AbortSignal;
     intervalMs?: number;
     timeoutMs?: number;
     onTick?: (elapsed: number, data: unknown) => void;

package/dist/poll.js

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from "node:timers/promises";
 export class TimeoutError extends Error {
     constructor(elapsedMs) {
         super(`Timed out after ${Math.round(elapsedMs / 1000)}s`);
@@ -10,6 +11,7 @@ export async function pollUntil(fetcher, predicate, options) {
     const onTick = options?.onTick;
     const start = Date.now();
     while (true) {
+        options?.signal?.throwIfAborted();
         const data = await fetcher();
         const elapsed = Date.now() - start;
         if (predicate(data)) {
@@ -19,6 +21,6 @@ export async function pollUntil(fetcher, predicate, options) {
             throw new TimeoutError(elapsed);
         }
         onTick?.(elapsed, data);
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        await delay(Math.min(intervalMs, Math.max(0, timeoutMs - elapsed)), undefined, { signal: options?.signal });
     }
 }

package/dist/safe-output.d.ts

@@ -0,0 +1,6 @@
+export declare function redactText(value: string): string;
+type OutputOptions = {
+    redactIdentifiers?: boolean;
+};
+export declare function safeOutput(value: unknown, options?: OutputOptions): unknown;
+export {};

package/dist/safe-output.js

@@ -0,0 +1,29 @@
+// Applied at output boundaries, never to requests or data used for execution.
+const credentialField = /^(?:.*[_-])?(?:access_token|refresh_token|id_token|token|password|secret|secret_value|secret_key|api_key|anon_key|service_role_key|private_key|client_secret|app_secret|authorization|credentials?)$/i;
+export function redactText(value) {
+    return value
+        .replace(/\bBearer\s+[^\s"'<>]+/gi, "Bearer [REDACTED]")
+        .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, "[REDACTED]")
+        .replace(/\b(?:epk_|sk-)[A-Za-z0-9_-]+/g, "[REDACTED]")
+        .replace(/([?&](?:token|api_key|access_token)=)[^&\s"']+/gi, "$1[REDACTED]");
+}
+export function safeOutput(value, options = {}) {
+    if (Array.isArray(value))
+        return value.map(item => safeOutput(item, options));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key, credentialField.test(key.replace(/([a-z])([A-Z])/g, "$1_$2")) || (options.redactIdentifiers && /^(client_ids?|app_id)$/i.test(key)) ? "[REDACTED]" : safeField(key, item, options),
+        ]));
+    }
+    return typeof value === "string" ? redactText(value) : value;
+}
+function safeField(key, value, options) {
+    // Only decode known JSON-encoded tool fields, never arbitrary user content.
+    if (["full_arguments", "tool_call_args", "tool_result", "accumulated_arguments", "arguments"].includes(key) && typeof value === "string") {
+        try {
+            return JSON.stringify(safeOutput(JSON.parse(value), options));
+        }
+        catch { /* partial JSON */ }
+    }
+    return safeOutput(value, options);
+}

package/dist/thread-events.d.ts

@@ -0,0 +1,37 @@
+import { RequestError } from "./errors.js";
+export type ThreadEvent = Record<string, unknown>;
+export type StreamMode = "connecting" | "websocket" | "reconnecting" | "polling";
+export interface StreamOptions {
+    turn?: number;
+    chatId?: string;
+    cursor?: string;
+    stateOnly?: boolean;
+    signal: AbortSignal;
+    onEvent?: (event: ThreadEvent) => void;
+    onMode?: (mode: StreamMode) => void;
+}
+export declare function streamURL(base: string, projectId: string, options: Omit<StreamOptions, "signal">): URL;
+export declare class ThreadEvents {
+    private projectId;
+    private options;
+    mode: StreamMode;
+    cursor?: string;
+    reason?: string;
+    failure?: RequestError;
+    revision: number;
+    private socket?;
+    private retry?;
+    private stopped;
+    private failures;
+    private listeners;
+    private seen;
+    private abort;
+    constructor(projectId: string, options: StreamOptions);
+    private wake;
+    private setMode;
+    private connect;
+    private connectAuthenticated;
+    wait(afterRevision: number, timeoutMs: number): Promise<void>;
+    close(): void;
+}
+export declare function isStateEvent(event: ThreadEvent): boolean;

package/dist/thread-events.js

@@ -0,0 +1,196 @@
+import WebSocket from "ws";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { getProxyForUrl } from "proxy-from-env";
+import { baseURL } from "./config.js";
+import { getValidToken } from "./auth.js";
+import { RequestError } from "./errors.js";
+export function streamURL(base, projectId, options) {
+    const url = new URL(`${base.replace(/\/$/, "")}/v1/projects/${encodeURIComponent(projectId)}/thread/stream`);
+    if (url.protocol === "https:")
+        url.protocol = "wss:";
+    else if (url.protocol === "http:")
+        url.protocol = "ws:";
+    else
+        throw new Error("Enter API URL must use HTTP or HTTPS");
+    if (options.turn)
+        url.searchParams.set("turn", String(options.turn));
+    if (options.chatId)
+        url.searchParams.set("chat_id", options.chatId);
+    if (options.cursor)
+        url.searchParams.set("last_event_id", options.cursor);
+    return url;
+}
+function laterCursor(current, next) {
+    if (typeof next !== "string" || !/^\d+-\d+$/.test(next))
+        return current;
+    if (!current || !/^\d+-\d+$/.test(current))
+        return next;
+    const a = current.split("-").map(BigInt), b = next.split("-").map(BigInt);
+    return b[0] > a[0] || (b[0] === a[0] && b[1] > a[1]) ? next : current;
+}
+// A socket is only a wake-up source. Callers still read authoritative action
+// state: a tool-start event can precede persistence of its approval card.
+export class ThreadEvents {
+    projectId;
+    options;
+    mode = "connecting";
+    cursor;
+    reason;
+    failure;
+    revision = 0;
+    socket;
+    retry;
+    stopped = false;
+    failures = 0;
+    listeners = new Set();
+    seen = new Set();
+    abort = () => this.close();
+    constructor(projectId, options) {
+        this.projectId = projectId;
+        this.options = options;
+        this.cursor = options.cursor;
+        options.signal.addEventListener("abort", this.abort, { once: true });
+        if (options.signal.aborted)
+            this.close();
+        else {
+            try {
+                this.connect();
+            }
+            catch (error) {
+                this.close();
+                throw error;
+            }
+        }
+    }
+    wake() {
+        this.revision++;
+        for (const listener of this.listeners)
+            listener();
+        this.listeners.clear();
+    }
+    setMode(mode, reason) {
+        if (this.mode === mode && this.reason === reason)
+            return;
+        this.mode = mode;
+        this.reason = reason;
+        this.options.onMode?.(mode);
+        this.wake();
+    }
+    connect() {
+        void this.connectAuthenticated().catch(error => {
+            if (this.stopped)
+                return;
+            this.failure = new RequestError("STREAM_SETUP_ERROR", error instanceof Error ? error.message : "Could not initialize Enter event stream.");
+            this.setMode("polling", "stream_setup_failed");
+        });
+    }
+    async connectAuthenticated() {
+        if (this.stopped)
+            return;
+        const url = streamURL(baseURL(), this.projectId, { ...this.options, cursor: this.cursor });
+        const token = await getValidToken(this.options.signal);
+        if (this.stopped)
+            return;
+        // proxy-from-env honors NO_PROXY, including loopback fixture servers.
+        const proxy = process.env.NODE_USE_ENV_PROXY === "0" ? "" : getProxyForUrl(url.toString().replace(/^ws/, "http"));
+        const socket = new WebSocket(url, {
+            headers: token ? { Authorization: `Bearer ${token}` } : {},
+            ...(proxy ? { agent: new HttpsProxyAgent(proxy) } : {}),
+            handshakeTimeout: 1500,
+            maxPayload: 8 * 1024 * 1024,
+            followRedirects: false,
+        });
+        this.socket = socket;
+        let opened = false;
+        let retryable = true;
+        let reason = "connection_lost";
+        socket.on("unexpected-response", (_request, response) => {
+            const status = response.statusCode ?? 0;
+            response.resume();
+            if ([401, 403].includes(status)) {
+                retryable = false;
+                reason = status === 401 ? "authentication_required" : "permission_denied";
+                this.failure = new RequestError("STREAM_AUTH_ERROR", "Enter event stream rejected access. Check authentication and project permissions.");
+            }
+            else if ([404, 405, 426, 501].includes(status)) {
+                retryable = false;
+                reason = "stream_unavailable";
+            }
+            else
+                reason = `stream_http_${status}`;
+            socket.terminate();
+        });
+        socket.on("open", () => { opened = true; this.setMode("websocket"); });
+        socket.on("message", raw => {
+            let event;
+            try {
+                const parsed = JSON.parse(raw.toString());
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                    return;
+                event = parsed;
+            }
+            catch {
+                retryable = false;
+                reason = "invalid_event";
+                socket.close();
+                return;
+            }
+            if (this.options.chatId && event.chat_id && event.chat_id !== this.options.chatId)
+                return;
+            const key = typeof event.event_id === "string" ? event.event_id : JSON.stringify(event);
+            if (this.seen.has(key))
+                return;
+            this.seen.add(key);
+            if (this.seen.size > 1024)
+                this.seen.delete(this.seen.values().next().value);
+            this.cursor = laterCursor(this.cursor, event.event_id);
+            this.failures = 0;
+            this.options.onEvent?.(event);
+            if (!this.options.stateOnly || isStateEvent(event))
+                this.wake();
+        });
+        // Do not expose raw URLs/errors (proxies and credentials can be embedded).
+        socket.on("error", () => { if (reason === "connection_lost" && !opened)
+            reason = "connection_failed"; });
+        socket.on("close", () => {
+            if (this.stopped)
+                return;
+            this.failures++;
+            this.setMode(opened && retryable ? "reconnecting" : "polling", reason);
+            if (!retryable)
+                return;
+            this.retry = setTimeout(() => this.connect(), Math.min(1000 * 2 ** Math.min(this.failures - 1, 4), 15000));
+        });
+    }
+    wait(afterRevision, timeoutMs) {
+        if (this.stopped || this.revision !== afterRevision)
+            return Promise.resolve();
+        return new Promise(resolve => {
+            const done = () => { clearTimeout(timer); this.listeners.delete(done); resolve(); };
+            const timer = setTimeout(done, timeoutMs);
+            this.listeners.add(done);
+        });
+    }
+    close() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        clearTimeout(this.retry);
+        this.options.signal.removeEventListener("abort", this.abort);
+        this.socket?.terminate();
+        this.wake();
+    }
+}
+export function isStateEvent(event) {
+    const type = String(event.message_type ?? "");
+    if (/^(turn_|build_|sync_|agent_stopped|insufficient_credits)/.test(type))
+        return true;
+    const detail = event.detail;
+    const tool = detail?.[type];
+    // Legacy argument chunks carry tool_name too; they are not new card state.
+    if (["tool_call_arguments", "tool_call_arguments_delta", "tool_call_arguments_start"].includes(type))
+        return false;
+    if (tool?.tool_action_id)
+        return true;
+    return (type.startsWith("tool_call_") && /^(ask_user_question|confirm_plan_mode|supabase_|stripe_|enable_|i18n_enable)/.test(String(tool?.tool_name ?? "")));
+}

package/dist/workflow.d.ts

@@ -0,0 +1,44 @@
+export type ThreadStatus = 'idle' | 'running' | 'queued' | 'pending' | 'blocked' | 'completed' | 'failed' | 'unknown';
+export type InputKind = 'none' | 'secret' | 'questions' | 'auth_provider';
+export interface WorkflowSnapshot {
+    status: ThreadStatus;
+    task_id?: unknown;
+    turn?: Record<string, unknown> | null;
+    actions?: Record<string, unknown>[];
+    project?: Record<string, unknown>;
+    reason?: string;
+    interrupted?: boolean;
+    wait_timed_out?: boolean;
+    observation_retrying?: boolean;
+    error?: {
+        retryable?: boolean;
+    };
+}
+/** Host-facing workflow decisions, independent of transport and backend phases. */
+export declare function workflowResult(snapshot: WorkflowSnapshot): {
+    actions?: {
+        id: unknown;
+        kind: unknown;
+        decision: string;
+        required_fields: {};
+        submit_command: unknown;
+    }[] | undefined;
+    build?: {
+        commit: {} | null;
+        matches_task: boolean;
+        success: {} | null;
+    } | undefined;
+    observation: {
+        timed_out: boolean;
+        retrying: boolean;
+        interrupted: boolean;
+    };
+    reason?: string | undefined;
+    state: string;
+    task: {
+        id: {} | null;
+        turn: {} | null;
+        chat_id: {} | null;
+    };
+    next_action: string;
+};

package/dist/workflow.js

@@ -0,0 +1,34 @@
+/** Host-facing workflow decisions, independent of transport and backend phases. */
+export function workflowResult(snapshot) {
+    const turn = snapshot.turn;
+    const actions = snapshot.actions ?? [];
+    const build = snapshot.project?.build_status;
+    const state = snapshot.status === 'blocked' ? 'needs_input'
+        : snapshot.status === 'queued' || snapshot.status === 'pending' ? 'running' : snapshot.status;
+    const next = snapshot.interrupted ? 'resume_when_requested'
+        : snapshot.error && !snapshot.error.retryable ? 'resolve_error'
+            : state === 'needs_input' ? 'handle_actions'
+                : state === 'completed' ? 'read_delivery'
+                    : state === 'failed' ? 'report_failure'
+                        : state === 'idle' ? 'none'
+                            : 'observe';
+    return {
+        state,
+        task: { id: snapshot.task_id ?? turn?.task_id ?? turn?.id ?? null, turn: turn?.turn ?? null, chat_id: turn?.chat_id ?? null },
+        next_action: next,
+        ...(snapshot.reason ? { reason: snapshot.reason } : {}),
+        observation: { timed_out: Boolean(snapshot.wait_timed_out), retrying: Boolean(snapshot.observation_retrying), interrupted: Boolean(snapshot.interrupted) },
+        ...(snapshot.project ? { build: {
+                commit: build?.commit_id ?? null,
+                matches_task: Boolean(turn?.commit_id && build?.commit_id === turn.commit_id),
+                success: build?.success ?? null,
+            } } : {}),
+        ...(actions.length ? { actions: actions.map(action => ({
+                id: action.action_id,
+                kind: action.tool_name === 'confirm_plan_mode' ? 'plan' : action.input_kind === 'none' ? 'confirmation' : action.input_kind,
+                decision: action.tool_name === 'confirm_plan_mode' || action.input_kind === 'questions' ? 'ask_user' : 'use_existing_authorization',
+                required_fields: action.configuration?.fields ?? (action.input_kind === 'secret' ? (action.tool_name === 'supabase_add_secret' ? ['secret_name', 'secret_value'] : ['secret_value']) : []),
+                submit_command: action.approve_command,
+            })) } : {}),
+    };
+}