@maudecode/talaria-web-contracts 1.18.0 → 1.20.0

package/dist/views.js

@@ -5,7 +5,12 @@
  * that must survive a round trip (documented passthrough).
  */
 import { z } from 'zod';
-import { CanonicalBotChatSchema } from './sidecar/namespaces.js';
+import { RunStatusSchema } from './run-status.js';
+import { AgentRefreshConfirmationSchema } from './sidecar/runtime.js';
+import { SpeedTierSchema } from './speed.js';
+import { ExecutionModeSchema, OwnerAttachmentSchema } from './gateway-session.js';
+import { CanonicalBotChatSchema, GatewayModeSchema, PluginOAuthClientSchema, PluginSettingFieldSchema, SkillCatalogIdentitySchema } from './sidecar/namespaces.js';
+export { SpeedTierSchema } from './speed.js';
 const Json = z.unknown();
 export const NullableString = z.string().nullable();
 export const NullableNumber = z.number().nullable();
@@ -38,8 +43,10 @@ export const DiffHunkSchema = z.object({
  * that diff parsed (TAL-604). Absent on a call whose result has no diff.
  */
 export const ToolEditDiffSchema = z.object({ added: z.number().int(), removed: z.number().int(), diff: z.string(), truncated: z.boolean(), hunks: z.array(DiffHunkSchema) });
-/** Server-derived display fields every tool call carries: the kind, and the redacted first-line label of its main argument (`''` when none; omitted on a live frame with none, which keeps its start frame's target), and a file edit's `edit_diff`. */
-export const ToolDisplayFields = { kind: ToolKindSchema.optional(), target: z.string().optional(), edit_diff: ToolEditDiffSchema.optional() };
+/** The latest server-normalized MCP update; never stored with the transcript. */
+export const ToolProgressSchema = z.object({ percent: z.number().min(0).max(100).nullable(), message: z.string().nullable() });
+/** Shared tool display fields. Progress is ephemeral, absent on older servers and null after completion. */
+export const ToolDisplayFields = { progress: ToolProgressSchema.nullable().optional(), kind: ToolKindSchema.optional(), target: z.string().optional(), edit_diff: ToolEditDiffSchema.optional() };
 /**
  * TAL-315: a tool result's display sections, decided by the server's one rule for live, replayed and persisted results
  * alike. Clients show `stdout`, `stderr`, a labelled `error` and a labelled `exit_code` (sent only when worth showing), or
@@ -100,8 +107,8 @@ export const TurnFileChangeSchema = z.looseObject({ path: z.string(), action: z.
 export const TurnTerminalStateSchema = z.enum(['completed', 'no_response', 'cancelled', 'interrupted', 'tool_limit_reached', 'compression_exhausted', 'error']);
 export const ActivitySceneSchema = z.looseObject({
     version: z.literal('activity_scene_v1'), activity_rows: z.array(ActivitySceneRowSchema), final_answer: z.string().optional(),
-    /** TAL-456: a settled final answer too long to lay out whole; clients render it collapsed, with a local "Show more". */
-    final_answer_excerpt: z.string().optional(), turn_duration: z.number().nullable().optional(),
+    /** TAL-456: an older settled final answer too long to lay out whole. Absent on the session-global newest settled visible reply and throughout the next running turn. Clients render the excerpt with a local "Show more". */
+    final_answer_excerpt: z.string().optional().describe("Collapsed preview of an older settled final answer. Absent on the session-global newest visible reply; its exemption transfers only when a newer visible reply settles."), turn_duration: z.number().nullable().optional(),
     /** TAL-186: `final_answer` with its media references rewritten for display (see `_display_content`), and its media. */
     final_answer_display: z.string().optional(), final_answer_media: z.array(DisplayMediaSchema).optional(),
     terminal_state: z.string().optional().describe('The turn\'s outcome: a `TurnTerminalState` (`completed`, `no_response`, `error`, `cancelled`, `interrupted`, `tool_limit_reached`, ...), or `running` for the running turn of a run with no journal to replay (TAL-374). A running scene holds every persisted row (no final answer) and renders open, with no "Worked" fold or outcome; the live rows streamed after attach continue it, and the settled scene replaces both.'),
@@ -115,8 +122,13 @@ export const ActivitySceneSchema = z.looseObject({
     file_changes: z.array(TurnFileChangeSchema).optional(),
     activity_rows_total: z.number().int().optional(), activity_rows_offset: z.number().int().optional(), activity_rows_complete: z.boolean().optional(), activity_rows_omitted: z.number().int().optional(), activity_scene_ref: z.string().optional(),
 });
-/** TAL-460: one finished background item (see `_background_update.lines`). */
-export const BackgroundLineSchema = z.object({ kind: z.enum(['agent', 'command', 'other']), status: z.enum(['completed', 'failed', 'notice']), label: z.string(), exit_code: z.number().int().nullable().optional() });
+/** The server-owned result-review lifecycle (TAL-1022). */
+export const BackgroundReviewStateSchema = z.enum(['waiting', 'reviewing', 'reviewed', 'failed', 'unknown']);
+/** One finished background item (see `_background_update.lines`). */
+export const BackgroundLineSchema = z.object({ kind: z.enum(['agent', 'command', 'other']), status: z.enum(['completed', 'failed', 'notice']), label: z.string(), exit_code: z.number().int().nullable().optional(),
+    /** Server-composed worker and parent outcome. Failure/unknown worker outcomes take precedence. */
+    review_state: BackgroundReviewStateSchema.optional(),
+});
 export const MessageSchema = z.looseObject({
     role: z.string(), content: MessageContentSchema.optional(), id: MessageIdSchema.optional(), message_id: MessageIdSchema.optional(), timestamp: z.number().nullable().optional(),
     attachments: z.array(AttachmentSchema).optional(), tool_calls: z.array(ToolCallSchema).optional(),
@@ -144,9 +156,9 @@ export const MessageSchema = z.looseObject({
     _steer: z.looseObject({ steer_id: z.string(), submitted_at: z.number().nullable().optional(), consumed_at: z.number().optional(), phase_duration: z.number().optional() }).optional(),
     /** On a steered turn's last reply: seconds from the last consumed steer to the turn's end. */
     _final_phase_duration: z.number().optional(),
-    /** A settled body too long to lay out whole: clients render `_display_excerpt` collapsed, with a local "Show more" for `content`. */
-    _display_truncated: z.boolean().optional(),
-    _display_excerpt: z.string().optional(),
+    /** A settled body too long to lay out whole. The session-global newest settled visible assistant reply and running output carry no excerpt. Only a newer visible terminal answer transfers that exemption. Clients render `_display_excerpt` with a local "Show more" for full `content`. */
+    _display_truncated: z.boolean().optional().describe("Whether this settled body has a collapsed preview. The newest settled visible assistant reply and active-turn output remain full."),
+    _display_excerpt: z.string().optional().describe("Collapsed preview with full content retained. The newest settled visible assistant reply remains exempt throughout the next running turn, until a newer visible reply settles."),
     /**
      * TAL-452: a typed user message (never a steer, background update or marker) longer than 20 lines or 2,000
      * characters. Clients show it folded to a few lines with a local "Show more"; copy and edit use the whole `content`.
@@ -168,11 +180,13 @@ export const MessageSchema = z.looseObject({
     _background_update: z.object({
         kind: z.enum(['delegation', 'process', 'mixed', 'other']), attention: z.boolean(), count: z.number().int().positive(), summary: z.string(),
         /**
-         * TAL-460: one completion line per finished item, shown in place of the row. Clients localize the wording per
-         * `kind` and `status`: an agent by its goal (`completed` / `failed`), a command (`finished` / `failed` with
-         * `exit_code`), or `label` as written for any other notice. `content` stays available in full on expansion.
+         * One completion line per finished item. Clients show its label and exactly one leading icon from `review_state`,
+         * with localized accessible/help wording. Parent review never overrides failed/unknown worker outcomes.
+         * `content` stays available in full on expansion.
          */
         lines: z.array(BackgroundLineSchema),
+        /** Parent review only, established from admission, the live run, and terminal evidence. */
+        review_state: BackgroundReviewStateSchema.optional(),
     }).optional(),
     /**
      * TAL-305: a marker the Agent wrote around context compaction, not a message anyone typed. Clients render a collapsed
@@ -181,6 +195,19 @@ export const MessageSchema = z.looseObject({
     _marker_kind: z.enum(['context_compaction', 'preserved_task_list']).optional(),
     /** TAL-305: a preserved task list's card body, without its marker line. */
     _marker_body: z.string().optional(),
+    /**
+     * TAL-815: an assistant row the Agent wrote as a notice, not the model's reply. `failed_turn`: the boundary closing a
+     * turn that failed, with its copy in `content`. Clients show it as a notice in its place, never as a reply bubble or
+     * part of a turn's reply; it is absent when Web's own error row already reports that turn. `session_finalize` is
+     * a plugin's closing text after clear, with role `local_notice`, display-only and excluded from model history.
+     */
+    _notice_kind: z.enum(['failed_turn', 'session_finalize']).optional(),
+    /**
+     * TAL-816: a user row of a messaging session that the Agent's gateway mirrored after a webhook route's or cron job's
+     * delivery to the chat, not a message the user sent. Clients show it as a delivery notice titled by a localized label
+     * per `kind` with `name`, and `body` (the delivered text, without its label line) beneath, never as a user bubble.
+     */
+    _delivery: z.object({ kind: z.enum(['webhook', 'cron']), name: z.string(), body: z.string() }).optional(),
     /** TAL-460: part of the Agent's reply to the background update just before it in the same turn. */
     _background_reply: z.boolean().optional(),
     /** TAL-460: that reply is only a silence marker; clients show the update's lines and nothing of this turn's reply. */
@@ -201,6 +228,23 @@ export const PendingSteerSchema = z.object({
     steer_id: z.string(), text: z.string(), submitted_at: z.number(), state: z.enum(['pending', 'sending_now']),
     actions: z.object({ edit: z.boolean(), cancel: z.boolean(), send_now: z.boolean() }),
 });
+/**
+ * TAL-803: an out-of-band notice the Agent raised for the session (a memory provider that failed to load, credit and
+ * usage warnings), one per `key`. The server keeps it until the Agent clears that key, `expires_at` passes, or a new agent
+ * replaces the one that raised it.
+ */
+export const SessionNoticeSchema = z.object({
+    key: z.string(), level: z.enum(['info', 'warn', 'error', 'success']), text: z.string(),
+    expires_at: NullableNumber.describe('Unix seconds when the server drops it; null when only the Agent clears it.'),
+});
+/**
+ * TAL-808: the session's standing `/goal` while it runs, from the Agent's goal state. `parked` is an active goal waiting on
+ * a process or a timer; `reason` is why it is paused or what it waits on. A done, cleared or absent goal is null.
+ */
+export const SessionGoalSchema = z.object({
+    text: z.string(), status: z.enum(['active', 'paused', 'parked']), turns_used: z.number().int().nonnegative(), max_turns: z.number().int().nonnegative(),
+    reason: NullableString, parked_until: NullableNumber.describe('Unix seconds a timed park ends; null otherwise.'),
+});
 /**
  * TAL-299: the context ring, computed by the server. `context_used_tokens` is the post-compression estimate, else the last
  * prompt (never the cumulative `input_tokens`); `context_window_tokens` is the model's window. The percents are rounded
@@ -215,12 +259,13 @@ export const ContextUsageFields = {
 const ActiveTurnOriginSchema = z.enum(['user', 'background']).nullable().optional().describe('Who started the running turn; null while idle.');
 const IsStreamingSchema = z.boolean().describe('True only while the session\'s run is a live stream on this server.');
 const ActiveStreamIdSchema = NullableString.optional().describe('The live stream id; non-null only while `is_streaming` is true.');
+const ReadOnlyReasonSchema = NullableString.optional().describe('Server-owned reason this session is display-only or its ownership cannot be verified.');
 const ReadOnlySchema = z.boolean().describe('The session cannot be modified from Web: a read-only import, a view-only subagent child, or a foreign session whose owner refuses claiming.');
-const CanBranchSchema = z.boolean().describe('Web may branch this session: never a subagent child, and a read-only session only when it is a cron run.');
-const CanPinSchema = z.boolean().describe('Web may pin or unpin this session: never a subagent child.');
-const CanArchiveSchema = z.boolean().describe('Web may archive or unarchive this session: never a subagent child.');
+const CanBranchSchema = z.boolean().describe('Web may branch this session: never a subagent child or an ownership-locked session; other read-only sessions only when they are cron runs.');
+const CanPinSchema = z.boolean().describe('Web may pin or unpin this session: never a subagent child or a session locked by canonical ownership or unreadable ownership storage.');
+const CanArchiveSchema = z.boolean().describe('Web may archive or unarchive this session: never a subagent child or a session locked by canonical ownership or unreadable ownership storage.');
 const CanDeleteSchema = z.boolean().describe('Web may delete this session: never a read-only session (a read-only import, a view-only subagent child, or a foreign session whose owner refuses claiming).');
-const CanDuplicateSchema = z.boolean().describe('Web may duplicate this session: it has a WebUI copy and is not a subagent child.');
+const CanDuplicateSchema = z.boolean().describe('Web may duplicate this session: it has a WebUI copy, is not a subagent child, and is not locked by canonical ownership or unreadable ownership storage.');
 // TAL-310: the server classifies every session's source once; clients file rows by it and never scan source markers.
 export const SourceKindSchema = z.enum(['webui', 'cli', 'messaging', 'cron', 'webhook', 'subagent', 'claude_code', 'kanban', 'api', 'other'])
     .describe('The session\'s source family. `is_cli_session` is true only for `cli` and `claude_code`.');
@@ -245,18 +290,29 @@ export const CompressionReferenceSchema = z.object({
 export const BranchedFromSchema = z.object({ session_id: SessionIdSchema, title: z.string() });
 /** Full session record from `GET /api/session` and mutations returning `session`. */
 export const SessionSchema = z.looseObject({
+    context_detail_key: z.string().nullable().optional().describe('Opaque identity for open-only context details; changes with owner epoch, model and context.'),
+    composer_state_key: z.string().optional().describe('Opaque profile-home and owner identity for device-local composer state; never an API session id.'),
     session_id: SessionIdSchema, title: z.string(), workspace: z.string().optional(), created_workspace: z.string().nullable().optional(), model: NullableString.optional(), model_provider: NullableString.optional(),
     model_option_id: NullableString.optional().describe('TAL-301: the catalog entry id the stored model/provider selects; null when none.'),
     messages: z.array(MessageSchema).optional(), tool_calls: z.array(ToolCallSchema).optional(), created_at: UnixSeconds.optional(), updated_at: UnixSeconds.optional(), last_message_at: NullableNumber.optional(),
     message_count: z.number().optional(), user_message_count: z.number().optional(), pinned: z.boolean().optional(), archived: z.boolean().optional(), project_id: NullableString.optional(), profile: NullableString.optional(),
     personality: NullableString.optional(), input_tokens: z.number().optional(), output_tokens: z.number().optional(), cache_read_tokens: z.number().optional(), cache_write_tokens: z.number().optional(),
-    cache_hit_percent: NullableNumber.optional(), estimated_cost: NullableNumber.optional(), active_stream_id: ActiveStreamIdSchema, is_streaming: IsStreamingSchema, active_turn_origin: ActiveTurnOriginSchema, pending_steers: z.array(PendingSteerSchema).optional().describe('TAL-424: the active stream\'s pending steers, oldest first.'), has_pending_user_message: z.boolean().optional(),
+    cache_hit_percent: NullableNumber.optional(), estimated_cost: NullableNumber.optional(), active_stream_id: ActiveStreamIdSchema, is_streaming: IsStreamingSchema, active_turn_origin: ActiveTurnOriginSchema, pending_steers: z.array(PendingSteerSchema).optional().describe('TAL-424: the active stream\'s pending steers, oldest first.'),
+    run_status: RunStatusSchema.nullable().optional().describe('Current server-selected run presentation; null when no turn runs. Older servers omit it.'),
+    compression_started_at: NullableNumber.optional().describe('TAL-1006: when the compression clients show started (epoch seconds): the running manual job\'s, else the live run\'s open span; null when none runs.'),
+    notices: z.array(SessionNoticeSchema).optional().describe('TAL-803: the Agent\'s active notices for the session, oldest first.'),
+    goal: SessionGoalSchema.nullable().optional().describe('TAL-808: the standing /goal; null when none runs.'),
+    automatic_turns_held: z.boolean().optional().describe('TAL-899: the user pressed Stop, so no automatic turn (background wakeup or goal continuation) starts until their next message.'), has_pending_user_message: z.boolean().optional(),
     pending_user_message: NullableString.optional(), pending_attachments: z.array(AttachmentSchema).optional(), pending_started_at: NullableNumber.optional(), pending_user_source: NullableString.optional(),
     context_length: NullableNumber.optional(), threshold_tokens: NullableNumber.optional(), last_prompt_tokens: NullableNumber.optional(), post_compression_context_tokens_estimate: NullableNumber.optional(), ...ContextUsageFields,
-    enabled_toolsets: z.array(z.string()).nullable().optional(), composer_draft: ComposerDraftSchema.optional(), is_cli_session: z.boolean().optional(), source_kind: SourceKindSchema, is_messaging_session: IsMessagingSessionSchema, sort_ts: SortTsSchema, read_only: ReadOnlySchema, can_branch: CanBranchSchema, can_pin: CanPinSchema, can_archive: CanArchiveSchema, can_delete: CanDeleteSchema, can_duplicate: CanDuplicateSchema, source_tag: NullableString.optional(),
+    execution_mode: ExecutionModeSchema.optional().describe('TAL-1040: the Agent execution policy frozen when the session was created; absent from older servers.'),
+    enabled_toolsets: z.array(z.string()).nullable().optional(), composer_draft: ComposerDraftSchema.optional(), is_cli_session: z.boolean().optional(), source_kind: SourceKindSchema, is_messaging_session: IsMessagingSessionSchema, sort_ts: SortTsSchema, read_only: ReadOnlySchema, read_only_reason: ReadOnlyReasonSchema, owner_attachment: OwnerAttachmentSchema.optional(), can_branch: CanBranchSchema, can_pin: CanPinSchema, can_archive: CanArchiveSchema, can_delete: CanDeleteSchema, can_duplicate: CanDuplicateSchema, source_tag: NullableString.optional(),
     can_compress: z.boolean().optional().describe('TAL-614: a manual compression would start now: writable, no running turn, and at least four model-history messages. Only the full session detail carries it; absent means no.'),
+    confirms_deep_truncate: z.boolean().optional().describe('TAL-929: this server holds a `session.truncate` that discards more than one user turn until it is confirmed; absent on older servers, which cut at once.'),
     source_label: NullableString.optional(), session_source: NullableString.optional(), raw_source: NullableString.optional(), parent_session_id: NullableString.optional(), worktree_path: NullableString.optional(),
-    worktree_branch: NullableString.optional(), worktree_repo_root: NullableString.optional(), share_token: NullableString.optional(), share_url: NullableString.optional(), share_created_at: NullableNumber.optional(), manual_title: z.boolean().optional(),
+    worktree_branch: NullableString.optional(), worktree_repo_root: NullableString.optional(),
+    worktree_retained: z.literal(true).optional().describe('TAL-1254: the last sidecar start found this worktree gone from git; the Agent\'s sweep keeps an archived one under `refs/hermes/archive/`. Absent while the worktree exists.'),
+    share_token: NullableString.optional(), share_url: NullableString.optional(), share_created_at: NullableNumber.optional(), manual_title: z.boolean().optional(),
     compression_anchor_summary: NullableString.optional(), compression_recovery: z.record(z.string(), Json).optional(), recommended_recovery_action: NullableString.optional(), compression_recovery_action: NullableString.optional(),
     compression_recovery_source_session_id: NullableString.optional(), gateway_routing: Json.optional(), _messages_offset: z.number().optional(), _messages_truncated: z.boolean().optional(), _msg_limit_max: z.number().optional(), _load_revision: z.string().optional(),
     /**
@@ -276,12 +332,18 @@ export const SessionEnvelopeSchema = z.looseObject({ session: SessionSchema });
 export const SessionRowSchema = z.looseObject({
     session_id: SessionIdSchema, title: z.string(), workspace: z.string().optional(), model: NullableString.optional(), created_at: UnixSeconds.optional(), updated_at: UnixSeconds.optional(), last_message_at: NullableNumber.optional(),
     message_count: z.number().optional(), pinned: z.boolean().optional(), archived: z.boolean().optional(), project_id: NullableString.optional(), profile: NullableString.optional(), is_streaming: IsStreamingSchema,
-    is_cli_session: z.boolean().optional(), source_kind: SourceKindSchema, is_messaging_session: IsMessagingSessionSchema, sort_ts: SortTsSchema, cron_running: z.boolean().optional(), read_only: ReadOnlySchema, can_branch: CanBranchSchema, can_pin: CanPinSchema, can_archive: CanArchiveSchema, can_delete: CanDeleteSchema, can_duplicate: CanDuplicateSchema, attention: z.looseObject({ kind: z.string().optional(), count: z.number().optional() }).nullable().optional(),
+    is_cli_session: z.boolean().optional(), source_kind: SourceKindSchema, is_messaging_session: IsMessagingSessionSchema, sort_ts: SortTsSchema, cron_running: z.boolean().optional(), read_only: ReadOnlySchema, read_only_reason: ReadOnlyReasonSchema, owner_attachment: OwnerAttachmentSchema.optional(), can_branch: CanBranchSchema, can_pin: CanPinSchema, can_archive: CanArchiveSchema, can_delete: CanDeleteSchema, can_duplicate: CanDuplicateSchema, attention: z.looseObject({ kind: z.string().optional(), count: z.number().optional() }).nullable().optional(),
     source_tag: NullableString.optional(), source_label: NullableString.optional(), session_source: NullableString.optional(), raw_source: NullableString.optional(), parent_session_id: NullableString.optional(),
     active_stream_id: ActiveStreamIdSchema, share_token: NullableString.optional(), share_url: NullableString.optional(), worktree_branch: NullableString.optional(), match_type: z.enum(['title', 'metadata', 'content']).optional(), match_preview: NullableString.optional(),
     workspace_name: WorkspaceNameSchema,
     ...ContextUsageFields,
 });
+/**
+ * TAL-785: whether the Agent's `state.db` could serve the Agent session rows. `corrupt`: SQLite reports the file
+ * damaged; `unavailable`: it could not be read for another reason (permissions, a lock, an I/O error); `outdated`: a
+ * readable database from an older hermes-agent. `reason` explains a degraded state.
+ */
+export const AgentStorageSchema = z.object({ state: z.enum(['ok', 'corrupt', 'unavailable', 'outdated']), reason: z.string().nullable() });
 export const SessionsListSchema = z.looseObject({
     sessions: z.array(SessionRowSchema).describe('Canonical display order (TAL-306): pinned first, then active (streaming or a pending prompt), then newest `sort_ts`, then `session_id`. Clients keep it.'), sidebar_reference_sessions: z.array(SessionRowSchema), server_time: z.number(), server_tz: z.string(), active_profile: z.string(), all_profiles: z.boolean(), include_archived: z.boolean(),
     archived_count: z.number().int(), archived_webui_count: z.number().int(), archived_cli_count: z.number().int(), other_profile_count: z.number().int(), cli_count: z.number().int(), webui_session_count: z.number().int(),
@@ -289,10 +351,11 @@ export const SessionsListSchema = z.looseObject({
     // TAL-482: sidebar counts for the "Scheduled sessions" / "Webhook sessions" groups; `_truncated` means more exist than are listed.
     scheduled_session_count: z.number().int().nonnegative(), scheduled_sessions_truncated: z.boolean(),
     webhook_session_count: z.number().int().nonnegative(), webhook_sessions_truncated: z.boolean(),
+    agent_storage: AgentStorageSchema.describe('Agent session storage health; a degraded state explains an empty or missing Agent session list.'),
     archived_limit: z.number().int().nullable().optional(), archived_offset: z.number().int().optional(),
 });
 export const SessionStatusSchema = z.looseObject({
-    session_id: SessionIdSchema, title: z.string().optional(), active_stream_id: ActiveStreamIdSchema, active_turn_origin: ActiveTurnOriginSchema, agent_running: IsStreamingSchema, is_streaming: IsStreamingSchema, read_only: ReadOnlySchema, message_count: z.number().optional(), model: NullableString.optional(),
+    session_id: SessionIdSchema, title: z.string().optional(), active_stream_id: ActiveStreamIdSchema, active_turn_origin: ActiveTurnOriginSchema, agent_running: IsStreamingSchema, is_streaming: IsStreamingSchema, read_only: ReadOnlySchema, read_only_reason: ReadOnlyReasonSchema, owner_attachment: OwnerAttachmentSchema.optional(), message_count: z.number().optional(), model: NullableString.optional(),
     profile: NullableString.optional(), workspace: z.string().optional(), input_tokens: z.number().optional(), output_tokens: z.number().optional(), total_tokens: z.number().optional(), estimated_cost: NullableNumber.optional(), updated_at: UnixSeconds.optional(),
 });
 export const SessionUsageSchema = z.looseObject({ input_tokens: z.number().optional(), output_tokens: z.number().optional(), total_tokens: z.number().optional(), estimated_cost: NullableNumber.optional(), model: NullableString.optional() });
@@ -300,12 +363,20 @@ export const ProjectSchema = z.looseObject({ project_id: z.string(), name: z.str
 export const ProjectsSchema = z.looseObject({ projects: z.array(ProjectSchema), active_profile: z.string(), all_profiles: z.boolean(), other_profile_count: z.number().int() });
 export const SessionDeleteResultSchema = z.looseObject({ ok: z.literal(true), state_db_cleanup_failed: z.boolean().optional() });
 // ── chat ─────────────────────────────────────────────────────────────────
+/** `voice_turn` (TAL-801): the turn was spoken (an App voice note), so the Agent runs it on `auxiliary.voice_chat`. */
 export const ChatStartRequestSchema = z.looseObject({
+    submission_id: z.string().min(1).max(128).optional().describe('Stable native-owner admission identity. Reuse only for an exact retry of the same submission.'),
     session_id: SessionIdSchema, message: z.string().optional(), model: z.string().nullable().optional(), model_provider: z.string().nullable().optional(), workspace: z.string().nullable().optional(), profile: z.string().nullable().optional(),
     explicit_model_pick: z.boolean().optional(), attachments: z.array(z.union([AttachmentSchema, z.string()])).optional(), moa_config: z.boolean().optional(), regenerate: z.boolean().optional(), regeneration_revision: z.string().optional(),
+    voice_turn: z.boolean().optional(),
+    /** TAL-818: this client renders `connect_card`, so a `manage_connections` call waits on the card; without it the Agent answers with plain links. */
+    connect_card: z.boolean().optional(),
+    /** The starting client renders the masked `skill_secret` prompt; omitted by older and native clients. */
+    skill_secret: z.boolean().optional(),
 });
 /** Accepted turn. `stream_id` is the owner identity for the SSE connection. */
 export const ChatStartResponseSchema = z.looseObject({
+    owner_attachment: OwnerAttachmentSchema.optional(), admission_id: z.string().optional(),
     stream_id: z.string().optional(), session_id: SessionIdSchema.optional(), turn_id: z.string().optional(), user_message_id: z.union([z.string(), z.number()]).nullable().optional(), pending_started_at: z.number().nullable().optional(),
     title: z.string().optional(), effective_model: z.string().optional(), effective_model_provider: z.string().optional(), queued: z.boolean().optional(), ok: z.boolean().optional(), status: z.string().optional(), reason: z.string().optional(), session: SessionSchema.optional(),
 });
@@ -330,14 +401,15 @@ export const SteerWithdrawRequestSchema = z.object({ session_id: SessionIdSchema
 /** `withdrawn: false` when the steer is unknown, already taken by the Agent (it then settles as consumed), or being sent. */
 export const SteerWithdrawResponseSchema = z.object({ withdrawn: z.boolean(), text: z.string().optional() });
 export const SteerSendNowRequestSchema = z.object({ session_id: SessionIdSchema, steer_id: z.string().min(1) });
-/** `redirected: false` when nothing is live to deliver it to now; the steer stays pending. */
-export const SteerSendNowResponseSchema = z.object({ redirected: z.boolean() });
+/** The server decides why Send now did or did not deliver. `redirected` remains for older clients. */
+export const SteerSendNowResponseSchema = z.object({ redirected: z.boolean(), outcome: z.enum(['delivered', 'next_step', 'not_running', 'taken', 'failed']) });
 /** `text` is delivered to the running agent; `display_text` is what the transcript shows. */
 export const SteerRequestSchema = z.looseObject({ session_id: SessionIdSchema, text: z.string().min(1), display_text: z.string().optional(), steer_id: z.string().optional() });
 /** `accepted: false` with a `fallback` reason means the message was not delivered; the caller keeps the draft. */
 /** TAL-460: a steer sent while a background turn runs starts the user's own turn instead; `started_turn` is its start response. */
 export const SteerResponseSchema = z.looseObject({ accepted: z.boolean(), fallback: NullableString.optional(), stream_id: NullableString.optional(), steer_id: z.string().optional(), started_turn: ChatStartResponseSchema.optional() });
 export const ApprovalPendingSchema = z.looseObject({
+    allowed_choices: z.array(z.enum(['once', 'session', 'always', 'deny'])).optional(), can_enable_yolo: z.boolean().optional(),
     approval_id: z.string().optional(), session_id: z.string().optional(), command: z.string().optional(), description: z.string().optional(), title: z.string().optional(), name: z.string().optional(), kind: z.string().optional(),
     reason: z.string().optional(), action: z.string().optional(), question: z.string().optional(), status: z.string().optional(), pending_count: z.number().optional(), run_id: z.string().optional(), mirror_token: z.string().optional(),
 });
@@ -347,17 +419,38 @@ export const ApprovalRespondRequestSchema = z.looseObject({ session_id: SessionI
 export const ApprovalRespondResponseSchema = z.looseObject({ ok: z.boolean(), choice: z.string().optional(), yolo_enabled: z.boolean().optional(), stale_cleared: z.boolean().optional(), error: z.string().optional(), pending_count: z.number().optional() });
 export const ClarifyChoiceSchema = z.union([z.string(), z.looseObject({ label: z.string().optional(), value: z.string().optional(), text: z.string().optional() })]);
 /** One question the client asks, in server order; answers are keyed by `qid`. A single-question prompt is one `q0` step. */
-export const ClarifyStepSchema = z.looseObject({ qid: z.string(), question: z.string(), choices: z.array(z.string()), multi_select: z.boolean() });
+export const ClarifyStepSchema = z.looseObject({ qid: z.string(), question: z.string(), choices: z.array(z.string()), multi_select: z.boolean(),
+    answered: z.boolean().optional().describe('TAL-1271: a gateway-owned batch question the owner already holds an answer for; it stays editable until the last answer.') });
 /** Keyed step answers; a multi-select step takes a list. The server shapes them into the Agent's reply. */
 export const ClarifyAnswersSchema = z.record(z.string(), z.union([z.string(), z.array(z.string())]));
+/** TAL-887: one input of a password-manager prompt, answered under its `key`; a `secure` input is masked. */
+export const VaultPromptFieldSchema = z.object({ key: z.enum(['master_password', 'identifier', 'password', 'code', 'secret']), secure: z.boolean() });
+/**
+ * TAL-887: the Agent asks for a password manager's master password (`vault_unlock`), a login to save for the page it is
+ * on (`vault_save_login`), a one-time code (`vault_code`), or a skill environment secret (`skill_secret`). Clients answer through
+ * `/api/clarify/respond` with keyed `answers`, or `decline`; an empty answer, a decline, a cancel and `timeout_at` all
+ * resolve it unanswered. Answers never enter chat, logs, streams, or responses. Skill secrets are saved only to the invoking profile.
+ */
+export const VaultPromptSchema = z.object({
+    kind: z.enum(['vault_unlock', 'vault_save_login', 'vault_code', 'skill_secret']),
+    backend: z.string().nullable().describe('The password manager (`vault_unlock`).'),
+    display_name: z.string().nullable().describe('Its display name (`vault_unlock`).'),
+    origin: z.string().nullable().describe('The page origin the login is saved for (`vault_save_login`).'),
+    site: z.string().nullable().describe('The site, by host (`vault_save_login`, `vault_code`).'),
+    hint: z.string().nullable().describe('Where the code was sent, when the Agent says (`vault_code`).'),
+    skill: z.object({ env_var: z.string(), skill_name: z.string(), help: z.string().nullable(), required_for: z.string().nullable() }).optional().describe('Profile-local environment setup metadata (`skill_secret`).'),
+    fields: z.array(VaultPromptFieldSchema),
+    timeout_at: z.number().describe('Unix seconds when the Agent stops waiting.'),
+});
 export const ClarifyPendingSchema = z.looseObject({
     steps: z.array(ClarifyStepSchema).optional(),
+    vault: VaultPromptSchema.optional(),
     clarify_id: z.string().optional(), session_id: z.string().optional(), question: z.string().optional(), description: z.string().optional(), choices: z.array(ClarifyChoiceSchema).optional(), title: z.string().optional(),
     name: z.string().optional(), kind: z.string().optional(), reason: z.string().optional(), action: z.string().optional(), status: z.string().optional(), raw_preview: z.string().optional(), timeout_at: z.number().optional(),
     timeout_seconds: z.number().optional(), pending_count: z.number().optional(), index: z.number().optional(), total: z.number().optional(),
 });
 export const ClarifyPendingEnvelopeSchema = z.looseObject({ pending: ClarifyPendingSchema.nullable(), pending_count: z.number().int() });
-export const ClarifyRespondRequestSchema = z.looseObject({ session_id: SessionIdSchema, answers: ClarifyAnswersSchema.optional(), response: z.string().optional(), answer: z.string().optional(), choice: z.string().optional(), clarify_id: z.string().optional() });
+export const ClarifyRespondRequestSchema = z.looseObject({ session_id: SessionIdSchema, answers: ClarifyAnswersSchema.optional(), response: z.string().optional(), answer: z.string().optional(), choice: z.string().optional(), clarify_id: z.string().optional(), decline: z.boolean().optional() });
 export const ClarifyRespondResponseSchema = z.looseObject({ ok: z.boolean(), response: z.string().optional(), error: z.string().optional(), stale: z.boolean().optional() });
 export const DraftSchema = z.looseObject({ text: z.string(), files: z.array(Json) });
 export const DraftResponseSchema = z.looseObject({ ok: z.literal(true), draft: DraftSchema, draft_version: z.string().nullable(), unchanged: z.boolean().optional() });
@@ -391,6 +484,8 @@ export const BackgroundTaskSchema = z.object({
     agents: BackgroundLinkSchema.shape.agents.nullable(),
     pinned: z.boolean(),
     dismissible: z.boolean(),
+    /** TAL-1172: confirmed running work this session may stop. */
+    can_stop: z.boolean().optional(),
     active: z.boolean(),
 });
 /**
@@ -401,6 +496,7 @@ export const BackgroundTaskSchema = z.object({
 export const BackgroundTasksResponseSchema = z.object({ session_id: z.string(), tasks: z.array(BackgroundTaskSchema), agent_available: z.boolean(), agents_working: z.boolean().optional() });
 export const BackgroundTaskResultSchema = z.object({ task_id: z.string(), text: z.string() });
 export const BackgroundDismissRequestSchema = z.object({ session_id: SessionIdSchema, task_id: z.string().min(1) });
+export const BackgroundStopResponseSchema = z.object({ outcome: z.enum(['stopped', 'not_running', 'not_found']) });
 export const BackgroundDismissResponseSchema = z.object({ ok: z.literal(true), task: BackgroundTaskSchema });
 export const ShareCreateResponseSchema = z.looseObject({ ok: z.literal(true), share: z.looseObject({ token: z.string(), url: z.string(), title: z.string(), message_count: z.number().int(), created_at: z.number(), updated_at: z.number() }), session: SessionRowSchema });
 export const ShareMessageSchema = z.looseObject({ role: z.string(), content: z.union([z.string(), z.null(), z.array(Json)]).optional() });
@@ -409,8 +505,18 @@ export const ShareReadSchema = z.looseObject({ share: ShareSchema });
 export const SessionNewRequestSchema = z.looseObject({
     title: z.string().optional(), workspace: z.string().optional(), workspace_inherited_from_prev_session: z.boolean().optional(), model: z.string().nullable().optional(), model_provider: z.string().nullable().optional(),
     profile: z.string().nullable().optional(), prev_session_id: z.string().optional(), project_id: z.string().nullable().optional(), worktree: Json.optional(), enabled_toolsets: z.array(z.string()).nullable().optional(), parent_session_id: z.string().optional(),
+    execution_mode: ExecutionModeSchema.optional().describe('TAL-1040: `ignore_config` and `safe` start the session through the Agent owner; omitted means normal.'),
+    request_id: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional().describe('TAL-1040: stable creation identity for a diagnostic chat. Reuse it only to retry the same creation.'),
 });
-export const TranscribeCapabilitySchema = z.looseObject({ ok: z.literal(true), available: z.boolean(), provider: z.string() });
+/**
+ * `streaming` (TAL-802): live dictation over `TRANSCRIBE_STREAM_PATH` would open for this profile (`stt.streaming` on, a live provider wire).
+ * `warm_supported` (TAL-916): a client starting a recording should `POST /api/transcribe/warm` so the engine loads while the user speaks.
+ */
+export const TranscribeCapabilitySchema = z.looseObject({ ok: z.literal(true), available: z.boolean(), provider: z.string(), streaming: z.boolean(), warm_supported: z.boolean() });
+/** TAL-906: what read-aloud speaks for a message; clients play it as is. */
+export const SpeechPrepareSchema = z.object({ spoken_text: z.string() });
+/** `POST /api/transcribe`: the recording's transcript; `filtered` (TAL-917) when the server emptied a phrase Whisper invents on silent audio. */
+export const TranscribeResponseSchema = z.looseObject({ ok: z.literal(true), transcript: z.string(), filtered: z.boolean() });
 // ── settings, profiles, models, providers ───────────────────────────────
 /** TAL-411: the request profile's quota urgency thresholds. A save patches valid fields and clamps critical to at most warning. */
 export const QuotaThresholdsSchema = z.object({
@@ -422,7 +528,7 @@ export const SettingsSchema = z.looseObject({
     bot_name: z.string().optional(), default_model: z.string().optional(), default_workspace: z.string().optional(), language: z.string().optional(), send_key: z.string().optional(), font_size: z.string().optional(),
     full_width_chat: z.boolean().optional(), chat_width: z.enum(['comfortable', 'wide', 'full']).optional(), auto_scroll_follow: z.boolean().optional(), render_user_markdown: z.boolean().optional(), chat_activity_display_mode: z.string().optional(), default_message_mode: z.string().optional(),
     fade_text_effect: z.boolean().optional(), hidden_tabs: z.array(z.string()).optional(), composer_control_order: z.array(z.string()).optional(), show_cli_sessions: z.boolean().optional(), show_claude_code_sessions: z.boolean().optional(),
-    show_cron_sessions: z.boolean().optional(), show_webhook_sessions: z.boolean().optional(), show_kanban_sessions: z.boolean().optional(), check_for_updates: z.boolean().optional(), ignore_agent_updates: z.boolean().optional(),
+    show_cron_sessions: z.boolean().optional(), show_webhook_sessions: z.boolean().optional(), show_kanban_sessions: z.boolean().optional(), check_for_updates: z.boolean().optional(), summarize_updates_automatically: z.boolean().optional(), ignore_agent_updates: z.boolean().optional(),
     auth_enabled: z.boolean().optional(), password_auth_enabled: z.boolean().optional(), password_env_var: z.boolean().optional(), passkeys_enabled: z.boolean().optional(), passwordless_enabled: z.boolean().optional(),
     auth_disabled_acknowledged: z.boolean().optional(), webui_version: z.string().optional(), agent_version: z.string().optional(), update_channel: z.string().optional(), agent_update_channel: z.enum(['stable', 'experimental']).optional(), update_channel_version: NullableString.optional(),
     max_tokens: NullableNumber.optional(), max_tokens_effective: NullableNumber.optional(), max_tokens_fallback: NullableNumber.optional(), tts_engine: z.string().optional(), tts_voice: z.string().optional(),
@@ -434,20 +540,47 @@ export const SettingsSchema = z.looseObject({
 export const ProfileSchema = z.looseObject({
     name: z.string(), path: z.string().optional(), is_active: z.boolean().optional(), is_default: z.boolean().optional(), model: NullableString.optional(), provider: NullableString.optional(), skill_count: z.number().optional(),
     total_skills: z.number().optional(), enabled_skills: z.number().optional(), gateway_running: z.boolean().optional(), has_env: z.boolean().optional(), visible: z.boolean().optional(),
+    /** TAL-805: the profile's gateway mode; `gateway_running` is true exactly for `own` and `served`. */
+    gateway_mode: GatewayModeSchema.optional(),
     /** TAL-213: Bot Mode identity from `profile.yaml` (the bot's roster title, else the profile's display name), one bounded printable line each. */
     display_name: z.string().optional(), description: z.string().optional(), has_avatar: z.boolean().optional(),
     /** TAL-213: present only when the profile has a canonical Bot Chat; clients open `tip_session_id` after switching to the profile. */
     canonical_session: CanonicalBotChatSchema.nullable().optional(),
+    /** TAL-819: skill and memory writes the Agent staged for approval, reviewed on the Skills and Memory pages. */
+    pending_writes: z.number().int().optional(),
 });
 export const ProfilesSchema = z.looseObject({ profiles: z.array(ProfileSchema), active: z.string(), single_profile_mode: z.boolean().optional() });
 export const ActiveProfileSchema = z.looseObject({ name: z.string(), path: z.string().optional(), is_default: z.boolean().optional(), default_workspace: NullableString.optional() });
 export const ProfileSwitchSchema = ProfilesSchema.extend({ is_default: z.boolean(), default_model: Json, default_model_provider: Json, default_workspace: z.string().nullable() });
 /** `/api/reasoning`: config.yaml agent.reasoning_effort / display.show_reasoning, resolved for a model. */
-export const ReasoningStatusSchema = z.looseObject({ show_reasoning: z.boolean().optional(), reasoning_effort: z.string().nullable().optional(), supported_efforts: z.array(z.string()).optional(), supports_reasoning_effort: z.boolean().optional(), supports_thinking_toggle: z.boolean().optional() });
-/** TAL-301: `provider_id`/`bare_id` are the server's split of `id`; clients match a stored `(model, provider)` against them and send `id` back. */
-export const ModelEntrySchema = z.looseObject({ id: z.string(), label: z.string().optional(), provider: z.string().optional(), provider_id: z.string().optional(), bare_id: z.string().optional(), supports_fast_tier: z.boolean().optional() });
-export const ModelGroupSchema = z.looseObject({ provider: z.string(), provider_id: z.string().optional(), models: z.array(ModelEntrySchema), extra_models: z.array(ModelEntrySchema).optional() });
-export const ModelsSchema = z.looseObject({ active_provider: NullableString.optional(), default_model: z.string().optional(), default_provider_id: NullableString.optional(), default_bare_id: z.string().optional(), default_option_id: NullableString.optional(), groups: z.array(ModelGroupSchema), aliases: z.record(z.string(), Json).optional(), configured_model_badges: z.record(z.string(), Json).optional() });
+export const ReasoningStatusSchema = z.looseObject({ show_reasoning: z.boolean().optional(), reasoning_effort: z.string().nullable().optional(), supported_efforts: z.array(z.string()).optional(), supports_reasoning_effort: z.boolean().optional(), supports_thinking_toggle: z.boolean().optional(), supports_session_scope: z.boolean().optional() });
+export const QuotaLevelSchema = z.enum(['healthy', 'warning', 'critical', 'stale', 'unavailable']);
+/**
+ * TAL-301: `provider_id`/`bare_id` are the server's split of `id`; clients match a stored `(model, provider)` against them and send `id` back.
+ * TAL-807: `limit` is present while the provider's credential pool cannot serve this model until `resets_at` (ISO-8601 UTC).
+ */
+export const ModelEntrySchema = z.looseObject({
+    id: z.string(), label: z.string().optional(), provider: z.string().optional(), provider_id: z.string().optional(), bare_id: z.string().optional(), supports_fast_tier: z.boolean().optional(), supported_speed_tiers: z.array(SpeedTierSchema).optional(),
+    limit: z.object({ scope: z.literal('model'), resets_at: z.string() }).optional(),
+});
+/** TAL-807: a group's rate limit: every pool account benched until `resets_at`, else the entry ids (`models`) cooling down until their reset. */
+export const ModelGroupLimitSchema = z.discriminatedUnion('scope', [
+    z.object({ scope: z.literal('account'), resets_at: z.string() }),
+    z.object({ scope: z.literal('models'), models: z.record(z.string(), z.string()) }),
+]);
+/**
+ * TAL-807: `limit` is the provider's live pool rate limit; `quota_level` is the TAL-411 `remaining` level of the tightest
+ * account-scope window in the provider's last account-usage read (a model-family window never counts), absent without one
+ * and while the group is account-limited.
+ */
+export const CatalogAvailabilitySchema = z.object({ status: z.enum(['available', 'stale', 'unavailable']), authoritative: z.boolean(), unavailable_reason: NullableString, generation: z.string().min(1).describe('Opaque source generation; cached data from another generation must never be merged.') });
+export const ModelGroupSchema = z.looseObject({
+    availability: CatalogAvailabilitySchema.optional(),
+    provider: z.string(), provider_id: z.string().optional(), models: z.array(ModelEntrySchema), extra_models: z.array(ModelEntrySchema).optional(),
+    limit: ModelGroupLimitSchema.optional(), quota_level: QuotaLevelSchema.optional(),
+});
+export const ModelsSchema = z.looseObject({ availability: CatalogAvailabilitySchema.optional(), active_provider: NullableString.optional(), default_model: z.string().optional(), default_provider_id: NullableString.optional(), default_bare_id: z.string().optional(), default_option_id: NullableString.optional(), groups: z.array(ModelGroupSchema), aliases: z.record(z.string(), Json).optional(), configured_model_badges: z.record(z.string(), Json).optional() });
+export const ModelsLiveSchema = z.looseObject({ availability: CatalogAvailabilitySchema.optional(), provider: z.string().optional(), source: z.string().optional(), models: z.array(ModelEntrySchema), count: z.number().optional(), error: z.string().optional() });
 /** TAL-603: where a card's credential comes from; `other` is a source the server cannot name, shown as its raw `key_source`. */
 export const KeySourceKindSchema = z.enum(['env', 'oauth', 'config', 'pool', 'plugin', 'other']);
 /**
@@ -461,8 +594,7 @@ export const ProviderSchema = z.looseObject({
     is_custom: z.boolean().optional(), key_source: z.string().optional(), base_url: NullableString.optional(), auth_error: NullableString.optional(), env_var: NullableString.optional(), models: z.array(ModelEntrySchema).optional(), models_total: z.number().optional(),
     is_active: z.boolean().optional(), key_source_kind: KeySourceKindSchema.nullable().optional(), removable: z.boolean().optional(),
 });
-export const ProvidersSchema = z.looseObject({ providers: z.array(ProviderSchema), active_provider: NullableString.optional() });
-export const QuotaLevelSchema = z.enum(['healthy', 'warning', 'critical', 'stale', 'unavailable']);
+export const ProvidersSchema = z.looseObject({ availability: CatalogAvailabilitySchema.optional(), providers: z.array(ProviderSchema), active_provider: NullableString.optional() });
 /** TAL-411: the server's classification per colour basis; `/api/provider/quotas` only, at the profile's thresholds. */
 export const QuotaUrgencySchema = z.looseObject({ remaining: QuotaLevelSchema, pace: QuotaLevelSchema.describe('Burn rate and pace tolerance; the remaining classification when the window has no pace.') });
 /** TAL-409: a window's pace as of the envelope's `computed_at`. Stale once `valid_until` (the window's reset) passes. */
@@ -487,6 +619,7 @@ export const QuotaWindowSchema = z.looseObject({
 });
 const QuotaWindowIndex = z.number().int().nullable().optional();
 export const QuotaSourceSchema = z.looseObject({
+    computed_at: z.string().optional().describe('Original reference time of this source, retained with stale windows.'),
     source_id: z.string(), provider_id: z.string().optional(), provider_label: z.string().optional(), account_label: z.string().optional(), status: z.string().optional(), supported: z.boolean().optional(), message: z.string().nullable().optional(),
     is_active_provider: z.boolean().optional(), quota: Json.optional(), windows: z.array(QuotaWindowSchema).optional(), balances: Json.optional(), plan: Json.optional(), details: Json.optional(), unavailable_reason: Json.optional(), retry_after: Json.optional(), fetched_at: Json.optional(),
     pace_window_index: QuotaWindowIndex.describe('The window a pace-coloured widget shows: the weekly one, else the first 5h/session window.'),
@@ -507,8 +640,8 @@ export const ProviderQuotaSchema = z.looseObject({
     account_limits: QuotaAccountLimitsSchema.nullable().optional(),
 });
 /** Python `get_provider_quotas`: the stable identity envelope the iOS quota widget persists (`scope_id`/`profile_id`). */
-export const ProviderQuotasSchema = z.looseObject({
-    version: z.number(), computed_at: z.string().describe('ISO-8601 UTC reference time of every window `pace`.'), scope_id: z.string(), profile_id: z.string(), active_provider: NullableString, requested_source_id: NullableString,
+export const ProviderQuotasSchema = z.looseObject({ availability: CatalogAvailabilitySchema.optional(),
+    version: z.number(), computed_at: z.string().describe('ISO-8601 UTC request reference time; coalesced or stale sources retain their own computed_at.'), scope_id: z.string(), profile_id: z.string(), active_provider: NullableString, requested_source_id: NullableString,
     missing_source: z.boolean().describe('True when `?source=` names a source id this scope no longer has; `sources` is then empty.'),
     sources: z.array(QuotaSourceSchema).describe('Each live source id exactly once, ordered by `provider_id`, then `account_label`, then `source_id`. Clients render this list as-is; a `?source=` read returns that one row.'),
 });
@@ -543,8 +676,12 @@ export const AuxiliaryTaskSchema = z.looseObject({
     selected_option_id: z.string().nullable(),
     /** False only for a pinned model the current catalog does not list; it stays visible and editable. */
     in_catalog: z.boolean(),
+    /** TAL-800: the slot a plugin task inherits its route from; while the task is Auto, `value_label` names that slot's model. */
+    inherit_from: z.string().nullable(),
+    /** TAL-800: the reasoning effort the slot runs with (the Agent's default until one is saved; `''` = provider default); null when the Agent does not report its slots. */
+    reasoning_effort: z.string().nullable(),
 });
-export const AuxiliaryModelsSchema = z.looseObject({ main: z.looseObject({ model: z.string().optional(), provider: z.string().optional(), base_url: z.string().optional(), api_key_set: z.boolean().optional() }), tasks: z.array(AuxiliaryTaskSchema) });
+export const AuxiliaryModelsSchema = z.looseObject({ main: z.looseObject({ model: z.string().optional(), provider: z.string().optional(), base_url: z.string().optional(), api_key_set: z.boolean().optional(), service_tier: z.enum(['', 'default', 'priority', 'ultrafast']).optional().describe('Empty string is the Standard value returned by older servers.'), supported_speed_tiers: z.array(SpeedTierSchema).optional() }), tasks: z.array(AuxiliaryTaskSchema) });
 export const MaxTokensSchema = z.looseObject({ max_tokens: NullableNumber, max_tokens_effective: NullableNumber, max_tokens_fallback: NullableNumber });
 // ── workspaces, files, git ───────────────────────────────────────────────
 /** A registry entry; `name` is never empty (the folder name when none is registered, `Home` for `default`), so pickers show it as-is (TAL-303). */
@@ -567,18 +704,20 @@ export const FileContentSchema = z.looseObject({
 const GitBadgeSchema = z.looseObject({ is_git: z.boolean().optional(), branch: NullableString.optional(), dirty: z.number().optional(), modified: z.number().optional(), untracked: z.number().optional(), ahead: z.number().optional(), behind: z.number().optional() });
 export const GitInfoSchema = z.looseObject({ git: GitBadgeSchema.nullable().optional() });
 // ── tools ────────────────────────────────────────────────────────────────
-export const SkillSchema = z.looseObject({ name: z.string(), description: NullableString.optional(), category: NullableString.optional(), disabled: z.boolean().optional() });
+export const SkillSchema = z.looseObject({ ...SkillCatalogIdentitySchema.shape, name: z.string(), description: NullableString.optional(), category: NullableString.optional(), disabled: z.boolean().optional() });
 export const SkillsSchema = z.looseObject({ skills: z.array(SkillSchema), categories: z.array(Json).optional() });
 /**
  * `linked_files` groups the skill directory's files by folder (`references`, `templates`, ...); open one with `?file=`.
  * A linked file that is not UTF-8 text carries `binary: true` and its `size` instead of `content`.
  */
-export const SkillContentSchema = z.looseObject({ name: z.string().optional(), content: z.string().optional(), path: z.string().optional(), linked_files: z.record(z.string(), z.array(z.string())).optional(), binary: z.literal(true).optional(), size: z.number().optional(), success: z.boolean().optional(), message: z.string().optional(), ok: z.boolean().optional() });
+export const SkillContentSchema = z.looseObject({ editable: z.boolean().optional(), name: z.string().optional(), content: z.string().optional(), path: z.string().optional(), linked_files: z.record(z.string(), z.array(z.string())).optional(), binary: z.literal(true).optional(), size: z.number().optional(), success: z.boolean().optional(), message: z.string().optional(), ok: z.boolean().optional() });
 export const SkillsUsageSchema = z.looseObject({ usage: z.record(z.string(), z.looseObject({ use_count: z.number().optional(), view_count: z.number().optional(), patch_count: z.number().optional() })), skill_names: z.array(z.string()).optional(), total_invocations: z.number().optional(), unique_skills_used: z.number().optional() });
 export const MemorySchema = z.looseObject({
     memory: z.string(), user: z.string(), soul: z.string(), project_context: z.string().optional(), memory_path: z.string().optional(), user_path: z.string().optional(), soul_path: z.string().optional(), project_context_path: z.string().optional(),
     project_context_name: z.string().optional(), project_context_workspace: z.string().optional(), memory_mtime: NullableNumber.optional(), user_mtime: NullableNumber.optional(), soul_mtime: NullableNumber.optional(), project_context_mtime: NullableNumber.optional(),
     project_context_shadowed: z.array(Json).optional(), external_notes_enabled: z.boolean().optional(),
+    /** TAL-784: the revision of each file as this read found it. A save sends the revision its edit started from. */
+    memory_revision: z.string(), user_revision: z.string(), soul_revision: z.string(),
 });
 export const PromptSchema = z.looseObject({ id: z.string().optional(), name: z.string().optional(), title: z.string().optional(), label: z.string().optional(), text: z.string().optional(), content: z.string().optional(), created_at: z.number().optional() });
 export const PromptsSchema = z.looseObject({ prompts: z.array(PromptSchema) });
@@ -588,12 +727,15 @@ export const PromptsSchema = z.looseObject({ prompts: z.array(PromptSchema) });
  * clients can run it, and `unsupported_message` is the English text a client outside `clients` shows when it is typed.
  * Clients suggest the entries listing them whose name or any alias starts with the typed text (case-insensitive), and
  * resolve a typed alias to the entry's `name`. `exec` marks an Agent entry `POST /api/commands/exec` runs: the client
- * posts the typed text there and shows the returned output instead of starting a chat turn (TAL-561).
+ * posts the typed text there with the open chat's `session_id` and shows the returned output instead of starting a chat turn
+ * (TAL-561); `/refine` reviews that chat (TAL-902).
+ * `handler: 'prompt'` marks an Agent prompt built-in: the client sends the typed text as a chat turn and the server starts the
+ * turn with the Agent's expansion of it (TAL-817).
  */
 export const CommandClientSchema = z.enum(['web', 'ios']);
 export const CommandRowSchema = z.looseObject({
     name: z.string(), description: z.string().optional(), aliases: z.array(z.string()), args_hint: z.string().optional(), category: z.string().optional(),
-    handler: z.enum(['client', 'agent']), clients: z.array(CommandClientSchema), unsupported_message: z.string().optional(),
+    handler: z.enum(['client', 'agent', 'prompt']), clients: z.array(CommandClientSchema), unsupported_message: z.string().optional(),
     cli_only: z.boolean().optional(), gateway_only: z.boolean().optional(), subcommands: z.array(Json).optional(), exec: z.boolean().optional(),
 });
 export const CommandsSchema = z.looseObject({ commands: z.array(CommandRowSchema) });
@@ -609,9 +751,11 @@ export const DashboardStatusSchema = z.looseObject({ running: z.boolean(), enabl
  * Gateway status for the Settings banner (TAL-266). `running` and `configured` come from the Agent health probe; when it
  * is inconclusive, stale running metadata or known gateway sessions mark the gateway configured. `platforms` are the
  * messaging platforms of known gateway sessions; `last_active` is the gateway session index's ISO mtime while running, else "".
+ * TAL-805: `gateway_mode` is the active profile's mode and decides `running` when it is not null. It is null for a remote
+ * gateway, or for the root profile when the sidecar cannot answer; a named profile whose mode is unconfirmed reads `stopped`.
  */
 export const GatewayStatusSchema = z.object({
-    running: z.boolean(), configured: z.boolean(), platforms: z.array(z.object({ name: z.string(), label: z.string() })), last_active: z.string(), session_count: z.number().int(),
+    running: z.boolean(), configured: z.boolean(), gateway_mode: GatewayModeSchema.nullable(), platforms: z.array(z.object({ name: z.string(), label: z.string() })), last_active: z.string(), session_count: z.number().int(),
     health: z.object({ state: NullableString, reason: NullableString, gateway_state: NullableString }),
 });
 export const GatewayActionSchema = z.object({ ok: z.literal(true), action: z.enum(['start', 'stop', 'restart']), message: z.string(), status: GatewayStatusSchema });
@@ -627,21 +771,55 @@ export const ProjectOsDashboardSchema = z.object({
     handoff: z.record(z.string(), Json).nullable(), active: z.record(z.string(), Json).nullable(), heartbeat: z.record(z.string(), Json).nullable(),
     onboarding: z.looseObject({ active: z.boolean(), doc_source: z.enum(['project-os', 'root']) }).optional(), goal_summary: z.string(),
 });
-export const AgentHealthSchema = z.looseObject({ alive: z.boolean().nullable().optional(), checked_at: z.string().optional(), details: z.looseObject({ state: z.string().optional(), reason: z.string().optional() }).optional(), gateway_chat: z.looseObject({ enabled: z.boolean().optional(), backend: z.string().optional(), base_url_configured: z.boolean().optional(), api_key_configured: z.boolean().optional() }).optional(), error: z.string().optional() });
+/** One server projection used by chat readiness, HTTP refusals, and persisted stream errors. */
+export const AgentRuntimeMetadataSchema = z.object({
+    agent_runtime_reason: z.enum(['update_active', 'recovery_incomplete', 'source_changed', 'unknown']).optional(),
+    agent_update_state: z.string().optional(),
+    retryable: z.boolean().optional(),
+    restart_scheduled: z.boolean().optional(),
+});
+/** TAL-951: whether Web chat can run, from the Agent sidecar's status; `condition` says why not, null when available. */
+export const ChatReadinessSchema = z.discriminatedUnion('available', [
+    z.object({ available: z.literal(true), condition: z.null() }),
+    z.object({ available: z.literal(false), condition: z.enum(['sidecar_unavailable', 'agent_incompatible', 'agent_runtime_stale']), ...AgentRuntimeMetadataSchema.shape }),
+]);
+/** Messaging-gateway liveness (`alive`, `details`, `gateway_chat`) for Settings → System, plus Web chat readiness in `chat`. */
+export const AgentHealthSchema = z.looseObject({ chat: ChatReadinessSchema.optional().describe('Always sent since TAL-951; absent from older servers.'), alive: z.boolean().nullable().optional(), checked_at: z.string().optional(), details: z.looseObject({ state: z.string().optional(), reason: z.string().optional() }).optional(), gateway_chat: z.looseObject({ enabled: z.boolean().optional(), backend: z.string().optional(), base_url_configured: z.boolean().optional(), api_key_configured: z.boolean().optional() }).optional(), error: z.string().optional() });
 export const SystemHealthSchema = z.looseObject({
     available: z.boolean().optional(), status: z.string().optional(), checked_at: z.string().optional(), cpu: Json.nullable().optional(), memory: Json.nullable().optional(), disk: z.looseObject({ percent: z.number().optional(), total_bytes: z.number().optional(), used_bytes: z.number().optional() }).nullable().optional(),
     errors: z.array(z.looseObject({ code: z.string().optional(), metric: z.string().optional() })).optional(), webui_runtime: Json.optional(),
 });
 export const UpdateStateSchema = z.enum(['up_to_date', 'release_ready', 'commits_behind', 'local_changes', 'finish', 'manual', 'check_failed', 'off', 'unknown']);
-export const UpdateTargetSchema = z.looseObject({ name: z.string().optional(), channel: z.enum(['stable', 'experimental']).optional(), unsupported: z.boolean().optional(), supported_revision: z.string().optional(), supported_version: z.string().optional(), candidate_revision: z.string().optional(), behind: z.number().nullable().optional(), current_sha: z.string().nullable().optional(), latest_sha: z.string().nullable().optional(), compare_url: z.string().optional(), repo_url: z.string().optional(), error: z.string().optional(), ok: z.boolean().optional(), manual_update: z.boolean().optional(), no_git: z.boolean().optional(), install_kind: z.literal('npm').optional(), npm: z.string().optional(), channel_switch: z.boolean().optional(), dirty: z.boolean().optional(), metadata_repair: z.boolean().optional(), release_url: z.string().optional(), ignored: z.boolean().optional(), stale_check: z.boolean().optional(), current_version: z.string().optional(),
+const AgentSupportSchema = z.enum(['supported', 'unchecked']);
+export const UpdateVersionSchema = z.object({
+    version: z.string().describe('The release as shown: the Agent tag or the Web release tag.'),
+    ref: z.string().describe('What `updates.apply`/`updates.force` accept back as `version`: the Agent tag or the Web semver.'),
+    sha: z.string().optional().describe('Agent only: the commit the tag peels to.'),
+    release_url: z.string().nullable(),
+    latest: z.boolean().describe('The channel\'s newest release, the one an update without `version` installs.'),
+    folded: z.boolean().describe('Shown behind the folded "more versions" node: every entry except the newest.'),
+    support: AgentSupportSchema.optional().describe('Agent only: this release\'s classification against the verified Agent window.'),
+    support_label: z.string().optional().describe('Agent only: `support` worded to fit one phone line.'),
+}).describe('TAL-946: one installable Stable release newer than the installed one.');
+export const UpdateTargetSchema = z.looseObject({
+    failed_update: z.object({ version: z.string(), restored_version: z.string() }).optional().describe('Web only: the update that failed before HTTP readiness and the restored package version. Manual retry remains available.'),
+    name: z.string().optional(), channel: z.enum(['stable', 'experimental']).optional(),
+    unsupported: z.boolean().optional().describe('Deprecated (TAL-350): `support === \'unchecked\'`, kept for older clients.'),
+    support: AgentSupportSchema.optional().describe('Agent target only (TAL-350): `supported` when the target revision is exactly a release in the verified Agent window, else `unchecked`; an `unchecked` apply requires `confirmed_agent_revision`.'),
+    support_label: z.string().optional().describe('Agent target only (TAL-946): `support` worded to fit one phone line.'),
+    current_support: AgentSupportSchema.optional().describe('Agent target only: the same classification for the installed Agent revision.'),
+    supported_revision: z.string().optional(), supported_version: z.string().optional(), candidate_revision: z.string().optional(), behind: z.number().nullable().optional(), current_sha: z.string().nullable().optional(), latest_sha: z.string().nullable().optional(), compare_url: z.string().optional(), repo_url: z.string().optional(), error: z.string().optional(), ok: z.boolean().optional(), manual_update: z.boolean().optional(), no_git: z.boolean().optional(), install_kind: z.literal('npm').optional(), npm: z.string().optional(), channel_switch: z.boolean().optional(), dirty: z.boolean().optional(), metadata_repair: z.boolean().optional(), release_url: z.string().optional(), ignored: z.boolean().optional(), stale_check: z.boolean().optional(), current_version: z.string().optional(),
     state: UpdateStateSchema.describe('TAL-559: the status clients word; `off` when checks are disabled or Agent updates are ignored.'),
     can_apply: z.boolean().describe('The apply action is available for this target.'),
     installed_unverified: z.boolean().describe('`release_ready` only: the installed revision sits on no release tag.'),
     manual_link: z.boolean().describe('Show the manual-install (releases) link.'),
     target_version: z.string().nullable().describe('The version the update path leads to, when one is shown.'),
     summary_available: z.boolean().describe('TAL-759: offer "Summarize with AI" for this target (`release_ready` or `commits_behind`).'),
+    versions: z.array(UpdateVersionSchema).describe('TAL-946: every installable Stable release newer than the installed one, newest first; empty unless `release_ready` can apply.'),
+    folded_count: z.number().int().nonnegative().describe('How many `versions` are `folded`.'),
 });
-export const UpdatesCheckSchema = z.looseObject({ disabled: z.boolean().optional(), cached: z.boolean().optional(), channel: z.string().optional(), agent_channel: z.enum(['stable', 'experimental']).optional(), checked_at: z.number().optional(), include_agent: z.boolean().optional(), webui: UpdateTargetSchema.nullable().optional(), agent: UpdateTargetSchema.nullable().optional() });
+export const AgentRecoveryStateSchema = z.object({ phase: z.enum(['idle', 'running', 'waiting', 'complete', 'blocked']), attempt: z.number().int().nonnegative(), detail: z.string(), retry_at: z.string().nullable() });
+export const UpdatesCheckSchema = z.looseObject({ agent_recovery: AgentRecoveryStateSchema.optional(), disabled: z.boolean().optional(), cached: z.boolean().optional(), channel: z.string().optional(), agent_channel: z.enum(['stable', 'experimental']).optional(), checked_at: z.number().optional(), include_agent: z.boolean().optional(), webui: UpdateTargetSchema.nullable().optional(), agent: UpdateTargetSchema.nullable().optional() });
 export const UpdatesSummarySchema = z.object({
     ok: z.boolean(), target: z.enum(['webui', 'agent']), summary: z.string(),
     current_version: z.string().nullable().describe('The installed version this summary starts from.'),
@@ -651,8 +829,13 @@ export const UpdatesSummarySchema = z.object({
     source: z.enum(['release_notes', 'commits', 'none']).describe('Stable targets summarize the release notes they install; commit-tracking targets, or unreadable notes, use commit subjects.'),
     cached: z.boolean(),
 });
-export const UpdateApplySchema = z.looseObject({ ok: z.boolean().optional(), status: z.string().optional(), error: z.string().optional(), message: z.string().optional(), lock: Json.optional(), confirmation_required: z.boolean().optional(), candidate_revision: z.string().optional(), supported_revision: z.string().optional(), supported_version: z.string().optional(), agent_channel: z.enum(['stable', 'experimental']).optional(), notification_id: z.uuid().optional(), channel_switch: z.boolean().optional(), backup_dir: z.string().nullable().optional(), backup_failed: z.boolean().optional(), stash_conflict: z.boolean().optional() });
-export const UpdateNotificationPhaseSchema = z.enum(['applying', 'awaiting_confirmation', 'restarting', 'succeeded', 'blocked', 'failed', 'unknown']);
+export const UpdateApplySchema = z.looseObject({
+    recovery_compatibility: z.object({ manual_execution: z.boolean(), bot_chat_delivery: z.boolean() }).optional()
+        .describe('Whether the target Agent can reconcile retained manual execution and pending Bot Chat records. A false value blocks the update before any source or repair-intent change.'),
+    ok: z.boolean().optional(), status: z.string().optional(), error: z.string().optional(), message: z.string().optional(), lock: Json.optional(), confirmation_required: z.boolean().optional(), refresh_confirmation: AgentRefreshConfirmationSchema.optional(), candidate_revision: z.string().optional(), supported_revision: z.string().optional(), supported_version: z.string().optional(), agent_channel: z.enum(['stable', 'experimental']).optional(), notification_id: z.uuid().optional(), channel_switch: z.boolean().optional(), backup_dir: z.string().nullable().optional(), backup_failed: z.boolean().optional(), stash_conflict: z.boolean().optional(), gateway_restart: z.string().optional().describe('TAL-953: `waiting_for_idle` when an Agent update left the gateway restart to wait for the gateway\'s running work; the update notification reports its outcome.')
+});
+/** `verifying` (TAL-1138): the gateway restarted, and the server is checking that the new gateway process and the Agent runtime answer. */
+export const UpdateNotificationPhaseSchema = z.enum(['applying', 'awaiting_confirmation', 'waiting_for_idle', 'restarting', 'verifying', 'succeeded', 'blocked', 'failed', 'unknown']);
 export const UpdateNotificationActionSchema = z.object({
     id: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/),
     label: z.string().min(1).max(80),
@@ -663,6 +846,12 @@ export const UpdateNotificationDestinationSchema = z.object({
     key: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_.-]*$/),
     label: z.string().min(1).max(80),
 });
+/** TAL-1138: one step of an update as its Updating dialog lists it; the server derives every label and state. */
+export const UpdateStepSchema = z.object({
+    id: z.enum(['install', 'web_restart', 'ready', 'gateway_wait', 'gateway_restart', 'agent_ready']),
+    label: z.string().min(1).max(80),
+    state: z.enum(['done', 'active', 'pending', 'failed']),
+});
 export const UpdateNotificationSchema = z.object({
     id: z.uuid(),
     kind: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9_-]*$/),
@@ -688,6 +877,12 @@ export const UpdateNotificationSchema = z.object({
     active: z.boolean(),
     requires_interaction: z.boolean(),
     can_dismiss: z.boolean(),
+    /** TAL-1138: the update's steps in order; empty for records that are not updates. */
+    steps: z.array(UpdateStepSchema).max(8),
+    /** TAL-1138: every client that sees this record opens its Updating dialog, which cannot be closed while this holds. */
+    presents_dialog: z.boolean(),
+    /** TAL-1138: how an open Updating dialog for this record closes: not at all, with Close, with Restart later (the wait goes on), or by itself after showing the outcome. */
+    dialog_close: z.enum(['none', 'close', 'restart_later', 'auto']),
 });
 export const FrontendBuildIdSchema = z.string().regex(/^[a-f0-9]{64}$/);
 export const TabIdSchema = z.string().regex(/^[A-Za-z0-9_-]{8,64}$/);
@@ -710,10 +905,69 @@ export const UpdateNotificationsSchema = z.object({
     clearable_count: z.number().int().nonnegative(),
     can_clear: z.boolean(),
 });
-export const PluginSchema = z.looseObject({ key: z.string(), name: z.string().optional(), kind: z.string().optional(), enabled: z.boolean().optional(), description: z.string().optional(), version: z.string().optional(), activation: z.string().optional(), is_active_provider: z.boolean().optional(), hooks: z.array(Json).optional() });
-export const PluginsSchema = z.looseObject({ plugins: z.array(PluginSchema), empty: z.boolean().optional(), read_only: z.boolean().optional(), supported_hooks: z.array(z.string()).optional(), unavailable: z.boolean().optional() });
+/** TAL-806: a plugin setting as Settings shows it; `locked` marks a secret the server's launch environment supplies, so an edit would not take effect. */
+export const PluginSettingViewSchema = PluginSettingFieldSchema.extend({ locked: z.boolean().optional() });
+/** TAL-1276: a plugin OAuth client as Settings shows it; `can_sign_out` is true while the profile stores a grant for it (any state but `logged_out`). */
+export const PluginOAuthClientViewSchema = PluginOAuthClientSchema.extend({ can_sign_out: z.boolean() });
+export const PluginSchema = z.looseObject({ key: z.string(), name: z.string().optional(), kind: z.string().optional(), enabled: z.boolean().optional(), description: z.string().optional(), version: z.string().optional(), activation: z.string().optional(), is_active_provider: z.boolean().optional(), hooks: z.array(Json).optional(),
+    /** Stored Agent check, absent when the installed Agent lacks cached update support. */
+    update: z.object({ available: z.boolean(), latest_revision: z.string().optional() }).optional(),
+    /** TAL-806: the manifest's `config_schema` fields with current values; absent when the plugin declares none. */
+    settings: z.array(PluginSettingViewSchema).optional(),
+    /**
+     * TAL-1276: the OAuth clients the manifest declares (Agent v0.22.3+), each with its sign-in state and the two hosts the
+     * sign-in sends the code to. Sign in through `/api/onboarding/oauth/start` with provider `plugin:<key>:<id>`; absent
+     * when the plugin declares none or the Agent cannot sign in to plugin clients.
+     */
+    oauth_clients: z.array(PluginOAuthClientViewSchema).optional() });
+/**
+ * `read_only` (TAL-806): this session may not save plugin `settings` (not the server owner, or no sidecar).
+ * `plugin_isolation_advisory` (TAL-820): more than one profile has third-party plugins installed and one of those runs them
+ * `in_process`, so Settings recommends `plugins.isolation: host`; Talaria never sets the mode.
+ */
+export const PluginsSchema = z.looseObject({ plugins: z.array(PluginSchema), empty: z.boolean().optional(), read_only: z.boolean().optional(), supported_hooks: z.array(z.string()).optional(), unavailable: z.boolean().optional(), plugin_isolation_advisory: z.boolean().optional() });
 export const McpServerSchema = z.looseObject({ name: z.string(), id: z.string().optional(), transport: z.string().optional(), enabled: z.boolean().optional(), can_toggle: z.boolean().optional().describe('Whether PATCH can enable or disable this server; false for invalid config.'), active: z.boolean().optional(), status: z.string().optional(), tools: z.number().optional(), tool_count: z.number().int().nullable().optional(), health: z.string().optional(), health_detail: z.string().optional(), health_checked_at: Json.optional(), health_pending: z.boolean().optional() });
 export const McpServersSchema = z.looseObject({ servers: z.array(McpServerSchema), health_pending: z.boolean().optional(), reload_required: z.boolean().optional(), toggle_supported: z.boolean().optional() });
+/** TAL-818: one connected account of a Nous tool-gateway app; `name` is its alias, else the vendor label. `problem` is its gateway status while it is not active, else null. */
+export const ConnectorAccountViewSchema = z.object({ connection_id: z.string(), name: z.string(), problem: z.enum(['pending', 'failed', 'expired', 'revoked', 'inactive']).nullable(), status_reason: z.string().nullable(), active: z.boolean(), created_at: z.string() });
+/**
+ * TAL-818: one app on the Connectors page. `accounts` are its live accounts, active first. `enabled`: Hermes may use it (the
+ * member rule allows it and no other layer locks it). `org_locked` means an organization or role rule keeps it off whatever the member rule says. `rules_editable`: the switch
+ * may change the member rule (readable rules and no lock). `tools_off` counts the tools the member rules turn off.
+ */
+export const ConnectorViewSchema = z.object({
+    slug: z.string(), name: z.string(), description: z.string(), category: z.string(), logo_url: z.string().nullable(),
+    connected: z.boolean(), accounts: z.array(ConnectorAccountViewSchema), enabled: z.boolean(), org_locked: z.boolean(), rules_editable: z.boolean(), tools_off: z.number().int(),
+});
+/**
+ * TAL-818: the Connectors page. `available` is the Agent's connectors gate; false hides the page. `policy_revision` is the
+ * member rules' revision every rule change sends back; null when the rules are read-only (no member layer, or unreadable),
+ * so no switch changes them. `sign_in_required` offers Nous sign-in without creating a guest on reads.
+ * `rules_error`: why the rules could not be read; every app then reads off (fails closed).
+ */
+export const ConnectorsPageSchema = z.object({ available: z.boolean(), sign_in_required: z.boolean().default(false), connectors: z.array(ConnectorViewSchema), policy_revision: z.string().nullable(), rules_error: z.string().nullable() });
+/**
+ * TAL-818: one app's tools: `enabled`: Hermes may use it (the member rules leave it on and nothing locks it); `locked`: an
+ * organization or role rule (by name or tag) keeps it off. `editable`: its switch may change the member rule (readable rules, the app on in them, and no lock).
+ */
+export const ConnectorToolsViewSchema = z.object({
+    connector: z.string(), policy_revision: z.string().nullable(),
+    tools: z.array(z.object({ slug: z.string(), name: z.string(), description: z.string(), facet: z.enum(['read', 'write', 'destructive', 'unclassified']), deprecated: z.boolean(), enabled: z.boolean(), locked: z.boolean(), editable: z.boolean() })),
+});
+/**
+ * TAL-818: a connection operation, from the Connectors page's Connect or a chat's `manage_connections` card. Each target's
+ * `connect_url` is the authorization link while it waits on one; `actions` are the moves the user may make on it now, and
+ * `env_fields` the credentials an `approve` sends, each with its `label`. `can_continue`: the card may end the wait for the
+ * rest (chat only). `outcome` is null while the operation is open, then `connected` when every target connected.
+ */
+export const ConnectorOperationViewSchema = z.object({
+    op_id: z.string(), settled: z.boolean(), outcome: z.enum(['connected', 'not_connected']).nullable(), can_continue: z.boolean(), tool_call_id: z.string().nullable(),
+    targets: z.array(z.object({
+        name: z.string(), title: z.string(), kind: z.string(), state: z.enum(['pending', 'initiated', 'connected', 'skipped', 'failed', 'expired', 'not_connected']),
+        detail: z.string(), connect_url: z.string().nullable(), actions: z.array(z.enum(['skip', 'retry', 'approve'])),
+        env_fields: z.array(z.object({ name: z.string(), label: z.string(), required: z.boolean(), secret: z.boolean() })),
+    })),
+});
 export const McpToolsSchema = z.looseObject({ tools: z.array(z.looseObject({ name: z.string().optional(), server: z.string().optional(), description: z.string().optional() })), total: z.number().int().optional(), source: z.string().optional(), inventory_scope: z.string().optional(), unavailable_servers: z.array(z.string()).optional() });
 export const NotesSourcesSchema = z.looseObject({ enabled: z.boolean().optional(), sources: z.array(Json).optional(), source: z.string().optional(), inventory_scope: z.string().optional(), recent_ai_notes: z.array(Json).optional(), attach_supported: z.boolean().optional(), automatic_recall_unchanged: z.boolean().optional() });
 /** Joplin search hit: bounded, redacted display text and a snippet around the query; `updated_time` is Joplin's raw value. */
@@ -750,6 +1004,13 @@ export const OnboardingProbeSchema = z.looseObject({ ok: z.boolean().optional(),
 export const OnboardingOAuthSchema = z.looseObject({
     ok: z.boolean().optional(), status: z.string().optional(), url: z.string().optional(), verification_url: z.string().optional(), user_code: z.string().optional(), message: z.string().optional(),
     error: z.string().nullable().optional(), flow_id: z.string().optional(), provider: z.string().optional(), expires_in: z.number().int().optional(), interval: z.number().int().optional(),
+    /**
+     * TAL-1276, a plugin client's browser sign-in (`plugin:<key>:<id>`, no `user_code`): `verification_url` is the
+     * authorize link, `authorize_host` and `token_host` the hosts the code goes to, and `redirect_uri` the address the
+     * browser is sent back to. When that address does not open on this machine, send the one the browser shows to
+     * `/api/plugins/oauth/redirect`.
+     */
+    authorize_host: z.string().optional(), token_host: z.string().optional(), redirect_uri: z.string().optional(),
 });
 // ── automation ───────────────────────────────────────────────────────────
 export const CronScheduleSchema = z.looseObject({ kind: z.string().optional(), expr: z.string().optional(), minutes: z.number().optional(), run_at: z.string().optional(), display: z.string().optional() });
@@ -767,12 +1028,17 @@ export const CronJobViewSchema = z.looseObject({
     derived_state: CronDerivedStateSchema.optional(), needs_attention: z.boolean().optional(), resumable: z.boolean().optional(),
     /** Server-derived (TAL-599): a known cause clients explain in the needs-attention banner. */
     attention_hint: z.enum(['croniter_missing']).nullable(),
+    /** Server-normalized (TAL-810): the job's latest failed run, kept after later successes; `at` is epoch seconds, null when unparseable. */
+    last_failure: z.object({ at: z.number().nullable(), detail: z.string() }).nullable(),
 });
+/** TAL-810: a listed profile's cron store whose writes fail (full disk, read-only mount, permissions), so its scheduler skips every run. `error` and `fix` are the Agent's text; `since` is the last write that landed (epoch seconds), null when unknown. */
+export const CronStoreHealthSchema = z.object({ profile: z.string(), store: z.string(), error: z.string(), fix: z.string(), since: z.number().nullable() });
 export const CronsSchema = z.looseObject({
     jobs: z.array(CronJobViewSchema),
     /** TAL-601: `jobs` arrive in display order (running first, then soonest next run, none last, then name); clients keep it. Absent from older servers. */
     ordered: z.boolean().optional(),
     active_profile: z.string().optional(), all_profiles: z.boolean().optional(), other_profile_count: z.number().optional(), cron_unavailable: z.boolean().optional(),
+    unwritable_stores: z.array(CronStoreHealthSchema),
 });
 export const CronContextSourcesSchema = z.object({ profile: z.string(), sources: z.array(z.object({ job_id: z.string(), label: z.string(), selectable: z.boolean() })) });
 /** `GET /api/crons/recent` row: one job's latest completion, ordered and classified by the server. */
@@ -793,18 +1059,21 @@ export const KanbanTaskActionsSchema = z.object({ block: z.boolean(), unblock: z
 /** Server-computed card policy on every task the Kanban routes return (TAL-557). `requires_running_exit_confirmation`: any action takes the task out of a live run, so clients confirm first. */
 export const KanbanTaskPolicyShape = { available_actions: KanbanTaskActionsSchema, requires_running_exit_confirmation: z.boolean() };
 export const KanbanTaskViewSchema = z.looseObject({ id: z.union([z.string(), z.number()]), title: z.string().optional(), status: z.string().optional(), assignee: NullableString.optional(), priority: z.union([z.string(), z.number()]).nullable().optional(), description: z.string().optional(), tags: z.array(z.string()).optional(), session_id: NullableString.optional(), archived: z.boolean().optional(), created_at: Json.optional(), updated_at: Json.optional(), ...KanbanTaskPolicyShape });
-export const KanbanColumnSchema = z.looseObject({ name: z.string(), tasks: z.array(KanbanTaskViewSchema) });
+/** A board column in the Agent workflow's order (TAL-796): `name` is the status key, `label` the Agent's English label. */
+export const KanbanColumnSchema = z.looseObject({ name: z.string(), label: z.string(), tasks: z.array(KanbanTaskViewSchema) });
 /** One profile lane (TAL-567): an assignee's tasks (`null` = unassigned) across every board column, with its task count. */
 export const KanbanLaneSchema = z.object({ assignee: z.string().nullable(), count: z.number().int(), columns: z.array(KanbanColumnSchema) });
 export const KanbanBoardViewSchema = z.looseObject({ columns: z.array(KanbanColumnSchema).optional(), assignees: z.array(Json).optional(), filters: Json.optional(), latest_event_id: z.number().optional(), read_only: z.boolean().optional(), tenants: z.array(Json).optional(), changed: z.boolean().optional(),
     /** Statuses a bulk status change may target (TAL-557). */
     bulk_move_targets: z.array(z.string()),
+    /** Statuses a new task may start in (TAL-796). */
+    create_statuses: z.array(z.string()),
     /** The saved board view (TAL-567): `true` groups the board into `lanes` by assignee. */
     lane_by_profile: z.boolean(),
     /** Present when `lane_by_profile`: the columns split into profile lanes, assignees in name order, unassigned last. */
     lanes: z.array(KanbanLaneSchema).optional() });
 export const KanbanBoardsViewSchema = z.looseObject({ boards: z.array(z.looseObject({ slug: z.string(), name: z.string().nullable().optional(), is_current: z.boolean().optional(), total: z.number().optional(), archived: z.boolean().optional(), color: z.string().optional(), icon: z.string().optional(), description: z.string().optional(),
-        /** Whether the board can be archived or deleted; the default board cannot (TAL-567). */
+        /** Whether the board can be archived or deleted; the default board (TAL-567) and an archived board (TAL-795) cannot. */
         removable: z.boolean() })), current: z.string().optional(), read_only: z.boolean().optional() });
 /** Board-wide task counts (TAL-567): `status_counts` in board-column order, unknown statuses after; `total` excludes archived tasks. */
 export const KanbanStatsViewSchema = z.looseObject({ by_status: z.record(z.string(), z.number()), total: z.number().int(), status_counts: z.array(z.object({ status: z.string(), count: z.number().int() })) });