@maudecode/talaria-web-contracts 1.14.0 → 1.16.1

package/dist/sidecar/namespaces.d.ts

@@ -176,11 +176,22 @@ export declare const CommandSchema: z.ZodObject<{
     cli_only: z.ZodBoolean;
     gateway_only: z.ZodBoolean;
 }, z.core.$strip>;
+/**
+ * A model-provider plugin installed and enabled in the profile (TAL-288); bundled providers are built-ins. `setup` is the Agent's
+ * own verdict without spawning the plugin's CLI: `not_loaded` means the installed plugin could not be loaded (import failure, or its
+ * provider id or directory name is taken by another profile's plugin in this process-wide registry).
+ */
 export declare const PluginProviderSchema: z.ZodObject<{
     name: z.ZodString;
     display_name: z.ZodString;
-    env_vars: z.ZodArray<z.ZodString>;
-    api_key_env: z.ZodNullable<z.ZodString>;
+    auth_type: z.ZodString;
+    setup: z.ZodEnum<{
+        ready: "ready";
+        missing_cli: "missing_cli";
+        needs_setup: "needs_setup";
+        not_loaded: "not_loaded";
+        unavailable: "unavailable";
+    }>;
 }, z.core.$strip>;
 export declare const COMMANDS_METHODS: {
     readonly 'commands.registry': {
@@ -230,8 +241,14 @@ export declare const COMMANDS_METHODS: {
             providers: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 display_name: z.ZodString;
-                env_vars: z.ZodArray<z.ZodString>;
-                api_key_env: z.ZodNullable<z.ZodString>;
+                auth_type: z.ZodString;
+                setup: z.ZodEnum<{
+                    ready: "ready";
+                    missing_cli: "missing_cli";
+                    needs_setup: "needs_setup";
+                    not_loaded: "not_loaded";
+                    unavailable: "unavailable";
+                }>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
     };
@@ -1232,6 +1249,75 @@ export declare const PROVIDERS_METHODS: {
         }, z.core.$strip>;
     };
 };
+/**
+ * TAL-398: an Agent device-code sign-in (Nous Portal, OpenAI Codex, xAI, MiniMax) the sidecar runs for one profile home.
+ * `oauth.start` answers the code to show; a sidecar thread polls the provider and writes the credential through the
+ * Agent's own auth store. A flow belongs to the profile home that started it: poll and cancel from another home do not
+ * find it. `error` is the Agent's reason for a flow that ended without a credential.
+ */
+export declare const OAuthFlowStatusSchema: z.ZodEnum<{
+    error: "error";
+    cancelled: "cancelled";
+    pending: "pending";
+    approved: "approved";
+    denied: "denied";
+    expired: "expired";
+}>;
+export declare const OAUTH_METHODS: {
+    readonly 'oauth.start': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            provider: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            flow_id: z.ZodString;
+            provider: z.ZodString;
+            status: z.ZodLiteral<"pending">;
+            user_code: z.ZodString;
+            verification_url: z.ZodString;
+            expires_in: z.ZodNumber;
+            interval: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly 'oauth.poll': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            flow_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            flow_id: z.ZodString;
+            provider: z.ZodString;
+            status: z.ZodEnum<{
+                error: "error";
+                cancelled: "cancelled";
+                pending: "pending";
+                approved: "approved";
+                denied: "denied";
+                expired: "expired";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly 'oauth.cancel': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            flow_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            flow_id: z.ZodString;
+            provider: z.ZodString;
+            status: z.ZodEnum<{
+                error: "error";
+                cancelled: "cancelled";
+                pending: "pending";
+                approved: "approved";
+                denied: "denied";
+                expired: "expired";
+            }>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
 export declare const AuxUsageSchema: z.ZodObject<{
     prompt_tokens: z.ZodOptional<z.ZodNumber>;
     completion_tokens: z.ZodOptional<z.ZodNumber>;
@@ -1278,15 +1364,6 @@ export declare const AUX_METHODS: {
     };
 };
 export declare const TEXT_METHODS: {
-    readonly 'text.redact': {
-        readonly params: z.ZodObject<{
-            text: z.ZodString;
-            force: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>;
-        readonly result: z.ZodObject<{
-            text: z.ZodString;
-        }, z.core.$strip>;
-    };
     readonly 'text.image_mode': {
         readonly params: z.ZodObject<{
             profile_home: z.ZodString;
@@ -1354,6 +1431,48 @@ export declare const PROCESS_METHODS: {
             ok: z.ZodBoolean;
         }, z.core.$strip>;
     };
+    /** TAL-459: the Agent's durable delivery ledger. A null claim means another consumer delivered (or holds) it; "" means nothing durable to acknowledge. */
+    readonly 'process.claim_delivery': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            consumer: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            claim_id: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly 'process.complete_delivery': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            claim_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly 'process.release_delivery': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            claim_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    /** Hands back a claim the busy target never admitted, without spending one of the Agent's delivery attempts. */
+    readonly 'process.defer_delivery': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            claim_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
     readonly 'process.format_notification': {
         readonly params: z.ZodObject<{
             event: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -1370,6 +1489,52 @@ export declare const PROCESS_METHODS: {
             sessions: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
     };
+    /** TAL-372: the Agent's view of these WebUI sessions' background work: ledger delegations (with live status) and notified processes. */
+    readonly 'process.background_list': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            session_ids: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            delegations: z.ZodArray<z.ZodObject<{
+                delegation_id: z.ZodString;
+                origin_ui_session_id: z.ZodString;
+                state: z.ZodString;
+                dispatched_at: z.ZodNullable<z.ZodNumber>;
+                completed_at: z.ZodNullable<z.ZodNumber>;
+                updated_at: z.ZodNullable<z.ZodNumber>;
+                goals: z.ZodArray<z.ZodString>;
+                child_statuses: z.ZodArray<z.ZodString>;
+                has_result: z.ZodBoolean;
+                live_status: z.ZodNullable<z.ZodString>;
+                children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    goal: z.ZodString;
+                    session_id: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            processes: z.ZodArray<z.ZodObject<{
+                process_id: z.ZodString;
+                session_key: z.ZodString;
+                command: z.ZodString;
+                started_at: z.ZodNullable<z.ZodNumber>;
+                exited: z.ZodBoolean;
+                exited_at: z.ZodNullable<z.ZodNumber>;
+                exit_code: z.ZodNullable<z.ZodNumber>;
+                completion_reason: z.ZodString;
+                watched: z.ZodBoolean;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly 'process.delegation_result': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            session_id: z.ZodString;
+            delegation_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>;
+    };
 };
 export declare const AccountUsageSnapshotSchema: z.ZodObject<{
     provider: z.ZodNullable<z.ZodString>;
@@ -1453,6 +1618,7 @@ export declare const ChatUsageSchema: z.ZodObject<{
     cache_write_tokens: z.ZodNumber;
     estimated_cost_usd: z.ZodNullable<z.ZodNumber>;
 }, z.core.$strip>;
+/** `failed`, `partial`, and `compression_exhausted` are the Agent's own turn-result flags, forwarded as sent; `failed` also sets `status: 'error'`. */
 export declare const ChatStartResultSchema: z.ZodObject<{
     status: z.ZodEnum<{
         error: "error";
@@ -1462,7 +1628,9 @@ export declare const ChatStartResultSchema: z.ZodObject<{
     messages: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     final_response: z.ZodString;
     error: z.ZodNullable<z.ZodString>;
-    result_status: z.ZodString;
+    failed: z.ZodBoolean;
+    partial: z.ZodBoolean;
+    compression_exhausted: z.ZodBoolean;
     tool_limit_reached: z.ZodBoolean;
     usage: z.ZodObject<{
         prompt_tokens: z.ZodNumber;
@@ -1529,6 +1697,13 @@ export declare const ChatStreamSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     event: z.ZodLiteral<"clarify_resolved">;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    event: z.ZodLiteral<"approval_resolved">;
+    data: z.ZodObject<{
+        approval_id: z.ZodString;
+        session_id: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
 }, z.core.$strip>, z.ZodObject<{
     event: z.ZodLiteral<"compressing">;
     data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -1570,7 +1745,9 @@ export declare const CHAT_METHODS: {
             messages: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             final_response: z.ZodString;
             error: z.ZodNullable<z.ZodString>;
-            result_status: z.ZodString;
+            failed: z.ZodBoolean;
+            partial: z.ZodBoolean;
+            compression_exhausted: z.ZodBoolean;
             tool_limit_reached: z.ZodBoolean;
             usage: z.ZodObject<{
                 prompt_tokens: z.ZodNumber;
@@ -1637,6 +1814,13 @@ export declare const CHAT_METHODS: {
         }, z.core.$strip>, z.ZodObject<{
             event: z.ZodLiteral<"clarify_resolved">;
             data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            event: z.ZodLiteral<"approval_resolved">;
+            data: z.ZodObject<{
+                approval_id: z.ZodString;
+                session_id: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>;
         }, z.core.$strip>, z.ZodObject<{
             event: z.ZodLiteral<"compressing">;
             data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -1661,6 +1845,7 @@ export declare const CHAT_METHODS: {
             checkpoint: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
         }, z.core.$strip>;
     };
+    /** `can_redirect`: the Agent can deliver a pending steer now (TAL-424 Send now). */
     readonly 'chat.steer': {
         readonly params: z.ZodObject<{
             stream_id: z.ZodOptional<z.ZodString>;
@@ -1670,11 +1855,98 @@ export declare const CHAT_METHODS: {
         readonly result: z.ZodObject<{
             accepted: z.ZodBoolean;
             fallback: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            can_redirect: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    };
+    /**
+     * TAL-424: take `pending[index]` back out of the Agent's pending steer slot (Edit, Cancel). `pending` is the server's
+     * not-yet-consumed steer texts, oldest first. `withdrawn: false` when the Agent already took it; the slot is untouched.
+     */
+    readonly 'chat.steer_withdraw': {
+        readonly params: z.ZodObject<{
+            stream_id: z.ZodOptional<z.ZodString>;
+            session_id: z.ZodOptional<z.ZodString>;
+            pending: z.ZodArray<z.ZodString>;
+            index: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            withdrawn: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    /**
+     * TAL-424: deliver `pending[index]` now with the Agent's `redirect`: `delivery: redirect` restarts the model request with
+     * it, `delivery: steer` puts it last on the slot while tools yield. Not redirected: it stays pending, `requeued` in its
+     * place (`kept`) or last (`last`); `withdrawn: false` when the Agent already took it.
+     */
+    readonly 'chat.steer_now': {
+        readonly params: z.ZodObject<{
+            stream_id: z.ZodOptional<z.ZodString>;
+            session_id: z.ZodOptional<z.ZodString>;
+            pending: z.ZodArray<z.ZodString>;
+            index: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            redirected: z.ZodBoolean;
+            withdrawn: z.ZodBoolean;
+            delivery: z.ZodOptional<z.ZodEnum<{
+                redirect: "redirect";
+                steer: "steer";
+            }>>;
+            requeued: z.ZodOptional<z.ZodEnum<{
+                kept: "kept";
+                last: "last";
+            }>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * TAL-255: manual `/compress` of `conversation_history` through the Agent's `compress_now` on a throwaway agent. Nothing is
+     * persisted: the server installs `messages` as the session's model context. `message` is the Agent's text for a result
+     * that did not compress; `agent_session_id` is the state.db id after a possible rotation. A compressed result holds its
+     * Agent's context-engine notification until `chat.compress_finalize` reports whether the server installed it.
+     */
+    readonly 'chat.compress': {
+        readonly params: z.ZodObject<{
+            profile_home: z.ZodString;
+            session_id: z.ZodString;
+            model: z.ZodString;
+            model_provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            conversation_history: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            focus_topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            enabled_toolsets: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            status: z.ZodEnum<{
+                compressed: "compressed";
+                lock_skipped: "lock_skipped";
+                nothing_to_do: "nothing_to_do";
+            }>;
+            messages: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            before_tokens: z.ZodNumber;
+            after_tokens: z.ZodNumber;
+            summary: z.ZodNullable<z.ZodObject<{
+                headline: z.ZodOptional<z.ZodString>;
+                token_line: z.ZodOptional<z.ZodString>;
+                note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$loose>>;
+            message: z.ZodNullable<z.ZodString>;
+            agent_session_id: z.ZodString;
+            commit_token: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    /** TAL-255: second phase of `chat.compress`; `finalized: false` when the token is unknown or already expired. */
+    readonly 'chat.compress_finalize': {
+        readonly params: z.ZodObject<{
+            commit_token: z.ZodString;
+            committed: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly result: z.ZodObject<{
+            finalized: z.ZodBoolean;
         }, z.core.$strip>;
     };
     readonly 'chat.evict_agent': {
         readonly params: z.ZodObject<{
             session_id: z.ZodString;
+            clear_session: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
         readonly result: z.ZodObject<{
             evicted: z.ZodBoolean;

package/dist/sidecar/namespaces.js

@@ -32,7 +32,12 @@ export const CommandSchema = z.object({
     name: z.string(), description: z.string(), category: z.string(), aliases: z.array(z.string()), args_hint: z.string(), subcommands: z.array(z.string()),
     cli_only: z.boolean(), gateway_only: z.boolean(),
 });
-export const PluginProviderSchema = z.object({ name: z.string(), display_name: z.string(), env_vars: z.array(z.string()), api_key_env: z.string().nullable() });
+/**
+ * A model-provider plugin installed and enabled in the profile (TAL-288); bundled providers are built-ins. `setup` is the Agent's
+ * own verdict without spawning the plugin's CLI: `not_loaded` means the installed plugin could not be loaded (import failure, or its
+ * provider id or directory name is taken by another profile's plugin in this process-wide registry).
+ */
+export const PluginProviderSchema = z.object({ name: z.string(), display_name: z.string(), auth_type: z.string(), setup: z.enum(['ready', 'missing_cli', 'needs_setup', 'not_loaded', 'unavailable']) });
 export const COMMANDS_METHODS = {
     'commands.registry': { params: ProfileHomeParams, result: z.object({ commands: z.array(CommandSchema) }) },
     'commands.exec': { params: ProfileHomeParams.extend({ command: z.string().min(1) }), result: z.object({ output: z.string(), source: z.enum(['agent', 'plugin']) }) },
@@ -155,6 +160,21 @@ export const PROVIDERS_METHODS = {
     'models.estimate_tokens': { params: z.object({ messages: z.array(Loose) }), result: z.object({ tokens: z.number().int() }) },
     'models.capabilities': { params: ProfileHomeParams.extend({ provider: z.string(), model: z.string() }), result: z.object({ capabilities: Loose.nullable() }) },
 };
+// ── oauth ──────────────────────────────────────────────────────────────
+/**
+ * TAL-398: an Agent device-code sign-in (Nous Portal, OpenAI Codex, xAI, MiniMax) the sidecar runs for one profile home.
+ * `oauth.start` answers the code to show; a sidecar thread polls the provider and writes the credential through the
+ * Agent's own auth store. A flow belongs to the profile home that started it: poll and cancel from another home do not
+ * find it. `error` is the Agent's reason for a flow that ended without a credential.
+ */
+export const OAuthFlowStatusSchema = z.enum(['pending', 'approved', 'denied', 'expired', 'cancelled', 'error']);
+const OAuthFlow = z.object({ flow_id: z.string(), provider: z.string(), status: OAuthFlowStatusSchema, error: z.string().nullable() });
+const OAuthFlowParams = ProfileHomeParams.extend({ flow_id: z.string().min(1) });
+export const OAUTH_METHODS = {
+    'oauth.start': { params: ProfileHomeParams.extend({ provider: z.string().min(1) }), result: z.object({ flow_id: z.string(), provider: z.string(), status: z.literal('pending'), user_code: z.string(), verification_url: z.string(), expires_in: z.number().int(), interval: z.number().int() }) },
+    'oauth.poll': { params: OAuthFlowParams, result: OAuthFlow },
+    'oauth.cancel': { params: OAuthFlowParams, result: OAuthFlow },
+};
 // ── aux / text / process / usage / gateway ─────────────────────────────
 export const AuxUsageSchema = z.object({ prompt_tokens: z.number().int().optional(), completion_tokens: z.number().int().optional(), total_tokens: z.number().int().optional() });
 export const AUX_METHODS = {
@@ -162,7 +182,6 @@ export const AUX_METHODS = {
     'aux.resolve': { params: ProfileHomeParams.extend({ task: z.string().min(1), main_runtime: Loose.nullable().optional() }), result: z.object({ configured: z.boolean(), model: z.string().nullable(), error: z.string().optional() }) },
 };
 export const TEXT_METHODS = {
-    'text.redact': { params: z.object({ text: z.string(), force: z.boolean().optional() }), result: z.object({ text: z.string() }) },
     'text.image_mode': { params: ProfileHomeParams.extend({ provider: z.string(), model: z.string(), cfg: Loose.nullable().optional(), requested_provider: z.string().optional() }), result: z.object({ mode: z.enum(['native', 'text']), reason: z.string(), supports_vision: z.boolean().nullable() }) },
     'text.portal_tags': { params: ProfileHomeParams, result: z.object({ client_tag: z.string().nullable(), conversation_tag: z.string().nullable(), tags: z.union([z.array(z.string()), Loose]) }) },
 };
@@ -171,8 +190,31 @@ export const PROCESS_METHODS = {
     'process.drain': { params: ProfileHomeParams.extend({ max_events: z.number().int().positive().optional() }), result: z.object({ events: z.array(ProcessEventSchema) }) },
     'process.requeue': { params: z.object({ events: z.array(Loose) }), result: z.object({ requeued: z.number().int() }) },
     'process.mark_consumed': { params: z.object({ process_id: z.string().min(1) }), result: Ok },
+    /** TAL-459: the Agent's durable delivery ledger. A null claim means another consumer delivered (or holds) it; "" means nothing durable to acknowledge. */
+    'process.claim_delivery': { params: ProfileHomeParams.extend({ event: Loose, consumer: z.string().min(1) }), result: z.object({ claim_id: z.string().nullable() }) },
+    'process.complete_delivery': { params: ProfileHomeParams.extend({ event: Loose, claim_id: z.string() }), result: Ok },
+    'process.release_delivery': { params: ProfileHomeParams.extend({ event: Loose, claim_id: z.string() }), result: Ok },
+    /** Hands back a claim the busy target never admitted, without spending one of the Agent's delivery attempts. */
+    'process.defer_delivery': { params: ProfileHomeParams.extend({ event: Loose, claim_id: z.string() }), result: Ok },
     'process.format_notification': { params: z.object({ event: Loose }), result: z.object({ text: z.string() }) },
     'process.list': { params: ProfileHomeParams, result: z.object({ sessions: z.array(Loose) }) },
+    /** TAL-372: the Agent's view of these WebUI sessions' background work: ledger delegations (with live status) and notified processes. */
+    'process.background_list': {
+        params: ProfileHomeParams.extend({ session_ids: z.array(z.string().min(1)) }),
+        result: z.object({
+            delegations: z.array(z.object({
+                delegation_id: z.string(), origin_ui_session_id: z.string(), state: z.string(), dispatched_at: z.number().nullable(), completed_at: z.number().nullable(),
+                updated_at: z.number().nullable(), goals: z.array(z.string()), child_statuses: z.array(z.string()), has_result: z.boolean(), live_status: z.string().nullable(),
+                /** TAL-494: the subagent sessions this unit ran (absent from a sidecar before TAL-494). */
+                children: z.array(z.object({ goal: z.string(), session_id: z.string() })).optional(),
+            })),
+            processes: z.array(z.object({
+                process_id: z.string(), session_key: z.string(), command: z.string(), started_at: z.number().nullable(), exited: z.boolean(), exited_at: z.number().nullable(),
+                exit_code: z.number().int().nullable(), completion_reason: z.string(), watched: z.boolean(),
+            })),
+        }),
+    },
+    'process.delegation_result': { params: ProfileHomeParams.extend({ session_id: z.string().min(1), delegation_id: z.string().min(1) }), result: z.object({ text: z.string() }) },
 };
 export const AccountUsageSnapshotSchema = z.object({ provider: z.string().nullable(), available: z.boolean(), unavailable_reason: z.string().nullable().optional(), windows: z.array(Loose), details: z.array(Json) }).catchall(Json);
 export const USAGE_METHODS = {
@@ -189,8 +231,10 @@ export const WORKTREE_METHODS = {
 };
 // ── chat / approval / clarify ──────────────────────────────────────────
 export const ChatUsageSchema = z.object({ prompt_tokens: z.number().int(), completion_tokens: z.number().int(), cache_read_tokens: z.number().int(), cache_write_tokens: z.number().int(), estimated_cost_usd: z.number().nullable() });
+/** `failed`, `partial`, and `compression_exhausted` are the Agent's own turn-result flags, forwarded as sent; `failed` also sets `status: 'error'`. */
 export const ChatStartResultSchema = z.object({
-    status: z.enum(['completed', 'cancelled', 'error']), messages: z.array(Loose), final_response: z.string(), error: z.string().nullable(), result_status: z.string(),
+    status: z.enum(['completed', 'cancelled', 'error']), messages: z.array(Loose), final_response: z.string(), error: z.string().nullable(),
+    failed: z.boolean(), partial: z.boolean(), compression_exhausted: z.boolean(),
     tool_limit_reached: z.boolean(), usage: ChatUsageSchema, context: Loose, model: z.string(), provider: z.string(), compressed: z.boolean(), agent_session_id: z.string(),
     token_sent: z.boolean(), pending_steer: z.string(), live_tool_calls: z.array(Loose),
 });
@@ -211,6 +255,8 @@ export const ChatStreamSchema = z.discriminatedUnion('event', [
     z.object({ event: z.literal('approval'), data: Loose }),
     z.object({ event: z.literal('clarify'), data: Loose }),
     z.object({ event: z.literal('clarify_resolved'), data: Loose }),
+    /** The Agent stopped waiting on an approval: `reason` is its settle cause (`resolved`, `timeout`, `interrupted`, `session_closed`). */
+    z.object({ event: z.literal('approval_resolved'), data: z.looseObject({ approval_id: z.string(), session_id: z.string().optional(), reason: z.string().optional() }) }),
     z.object({ event: z.literal('compressing'), data: Loose }),
     z.object({ event: z.literal('warning'), data: Loose }),
     z.object({ event: z.literal('status'), data: Loose }),
@@ -233,8 +279,42 @@ export const CHAT_METHODS = {
         /** `checkpoint`: the Agent's canonical transcript for the stopped turn, captured before the interrupt (absent until it has one). */
         result: z.object({ ok: z.boolean(), reason: z.string().optional(), pending_steer: z.string().optional(), checkpoint: z.array(Loose).optional() }),
     },
-    'chat.steer': { params: z.object({ stream_id: z.string().optional(), session_id: z.string().optional(), text: z.string().min(1) }), result: z.object({ accepted: z.boolean(), fallback: z.string().nullable().optional() }) },
-    'chat.evict_agent': { params: z.object({ session_id: z.string().min(1) }), result: z.object({ evicted: z.boolean() }) },
+    /** `can_redirect`: the Agent can deliver a pending steer now (TAL-424 Send now). */
+    'chat.steer': { params: z.object({ stream_id: z.string().optional(), session_id: z.string().optional(), text: z.string().min(1) }), result: z.object({ accepted: z.boolean(), fallback: z.string().nullable().optional(), can_redirect: z.boolean().optional() }) },
+    /**
+     * TAL-424: take `pending[index]` back out of the Agent's pending steer slot (Edit, Cancel). `pending` is the server's
+     * not-yet-consumed steer texts, oldest first. `withdrawn: false` when the Agent already took it; the slot is untouched.
+     */
+    'chat.steer_withdraw': { params: z.object({ stream_id: z.string().optional(), session_id: z.string().optional(), pending: z.array(z.string().min(1)).min(1), index: z.number().int().nonnegative() }), result: z.object({ withdrawn: z.boolean() }) },
+    /**
+     * TAL-424: deliver `pending[index]` now with the Agent's `redirect`: `delivery: redirect` restarts the model request with
+     * it, `delivery: steer` puts it last on the slot while tools yield. Not redirected: it stays pending, `requeued` in its
+     * place (`kept`) or last (`last`); `withdrawn: false` when the Agent already took it.
+     */
+    'chat.steer_now': {
+        params: z.object({ stream_id: z.string().optional(), session_id: z.string().optional(), pending: z.array(z.string().min(1)).min(1), index: z.number().int().nonnegative() }),
+        result: z.object({ redirected: z.boolean(), withdrawn: z.boolean(), delivery: z.enum(['redirect', 'steer']).optional(), requeued: z.enum(['kept', 'last']).optional() }),
+    },
+    /**
+     * TAL-255: manual `/compress` of `conversation_history` through the Agent's `compress_now` on a throwaway agent. Nothing is
+     * persisted: the server installs `messages` as the session's model context. `message` is the Agent's text for a result
+     * that did not compress; `agent_session_id` is the state.db id after a possible rotation. A compressed result holds its
+     * Agent's context-engine notification until `chat.compress_finalize` reports whether the server installed it.
+     */
+    'chat.compress': {
+        params: ProfileHomeParams.extend({
+            session_id: z.string().min(1), model: z.string(), model_provider: z.string().nullable().optional(), conversation_history: z.array(Loose),
+            focus_topic: z.string().nullable().optional(), enabled_toolsets: z.array(z.string()).nullable().optional(),
+        }),
+        result: z.object({
+            status: z.enum(['compressed', 'lock_skipped', 'nothing_to_do']), messages: z.array(Loose), before_tokens: z.number().int(), after_tokens: z.number().int(),
+            summary: z.looseObject({ headline: z.string().optional(), token_line: z.string().optional(), note: z.string().nullable().optional() }).nullable(), message: z.string().nullable(), agent_session_id: z.string(),
+            commit_token: z.string().nullable(),
+        }),
+    },
+    /** TAL-255: second phase of `chat.compress`; `finalized: false` when the token is unknown or already expired. */
+    'chat.compress_finalize': { params: z.object({ commit_token: z.string().min(1), committed: z.boolean() }), result: z.object({ finalized: z.boolean() }) },
+    'chat.evict_agent': { params: z.object({ session_id: z.string().min(1), clear_session: z.boolean().optional() }), result: z.object({ evicted: z.boolean() }) },
     'chat.commit_memory': { params: z.object({ session_id: z.string().min(1) }), result: z.object({ committed: z.boolean() }) },
     'approval.respond': { params: ProfileHomeParams.extend({ session_id: z.string().min(1), choice: z.enum(['once', 'session', 'always', 'deny']), request_id: z.string().nullable().optional() }), result: z.object({ ok: z.boolean(), resolved: z.number().int(), choice: z.string() }) },
     'approval.pending': { params: z.object({ session_id: z.string().min(1) }), result: z.object({ pending: z.array(Loose) }) },