@otto-code/protocol 0.6.1 → 0.6.3

package/dist/messages.js

@@ -177,6 +177,23 @@ const AgentPersonalityVoiceSchema = z
     name: z.string().min(1),
 })
     .passthrough();
+// The three Visualizer lifecycle moments a personality voice-cue line can
+// belong to. Protocol owns this vocabulary — the daemon's cue generator, the
+// personality editor, and the Visualizer playback hook all import it from here.
+export const CUE_MOMENTS = ["join", "thinking", "done"];
+// Pre-generated (and user-editable) spoken "voice cue" lines for the personality
+// — a few short variations for each of three Visualizer moments (its node joins
+// the graph, first starts thinking, completes). Stored on the personality so
+// they're deterministic and hand-tunable in the editor; the Visualizer reads
+// them directly (no runtime generation). All groups optional/loose — a
+// personality may have none, or only some. See docs/visualizer.md "Voice cues".
+const AgentPersonalityVoiceCuesSchema = z
+    .object({
+    join: z.array(z.string()).optional(),
+    thinking: z.array(z.string()).optional(),
+    done: z.array(z.string()).optional(),
+})
+    .passthrough();
 // A named, reusable agent template stored per-host. `id` is the stable identity
 // everything binds to; `name` is a freely-renamable label. Effort and roles are
 // plain strings on the wire (like speech engine/model ids) so the daemon can
@@ -199,6 +216,7 @@ export const AgentPersonalitySchema = z
     roles: z.array(z.string().min(1)).optional(),
     spinner: AgentPersonalitySpinnerSchema.optional(),
     voice: AgentPersonalityVoiceSchema.optional(),
+    voiceCues: AgentPersonalityVoiceCuesSchema.optional(),
 })
     .passthrough();
 const MutableAgentPersonalitiesConfigSchema = z
@@ -367,6 +385,22 @@ const AgentProviderNoticeSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("warning"), message: z.string() }),
     z.object({ type: z.literal("error"), message: z.string() }),
 ]);
+// Provider-reported plan rate-limit status (e.g. Claude claude.ai plan
+// windows), pushed on the agent stream when it changes. Presentation-only:
+// the app decides whether to show it (rateLimitWarningsEnabled setting).
+export const AgentRateLimitInfoSchema = z.object({
+    status: z.enum(["allowed", "warning", "rejected"]),
+    // Percentage of the limit window used, 0-100. Absent when the provider
+    // does not report it (Claude only includes it near the limit).
+    utilizationPercent: z.number().optional(),
+    // Provider-reported window identifier, e.g. "five_hour" | "seven_day".
+    // Open set — display code falls back to a generic label for unknown values.
+    limitType: z.string().optional(),
+    // ISO 8601 timestamp when the window resets.
+    resetsAt: z.string().optional(),
+    // True when usage is currently drawing from overage/extra usage credits.
+    isUsingOverage: z.boolean().optional(),
+});
 export const AgentFeatureToggleSchema = z.object({
     type: z.literal("toggle"),
     id: z.string(),
@@ -436,6 +470,13 @@ const AgentCapabilityFlagsSchema = z
     supportsRewindBoth: z.boolean().optional().default(false),
 })
     .catchall(z.boolean());
+const ContextCompositionSchema = z.object({
+    systemPrompt: z.number().optional(),
+    userMessages: z.number().optional(),
+    toolResults: z.number().optional(),
+    reasoning: z.number().optional(),
+    subagentResults: z.number().optional(),
+});
 const AgentUsageSchema = z.object({
     inputTokens: z.number().optional(),
     cachedInputTokens: z.number().optional(),
@@ -443,6 +484,9 @@ const AgentUsageSchema = z.object({
     totalCostUsd: z.number().optional(),
     contextWindowMaxTokens: z.number().optional(),
     contextWindowUsedTokens: z.number().optional(),
+    // Provider-graded context breakdown for the visualizer ring/bar; absent ⇒
+    // occupancy only (pre-composition behavior). See ContextComposition.
+    contextComposition: ContextCompositionSchema.optional(),
 });
 const AgentSessionConfigSchema = z.object({
     provider: AgentProviderSchema,
@@ -754,6 +798,22 @@ export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
         })
             .optional(),
     }),
+    // Predicted next-user-prompt suggestion emitted after a turn. Transient: the
+    // app shows the latest as composer ghost text (Tab to accept) and clears it on
+    // the next turn_started. COMPAT(promptSuggestions): added in v0.6.3.
+    z.object({
+        type: z.literal("prompt_suggestion"),
+        provider: AgentProviderSchema,
+        suggestion: z.string(),
+    }),
+    // Provider-reported plan rate-limit status (Claude claude.ai plan windows).
+    // Transient: the app shows a suppressible warning strip near the composer.
+    // Deduped provider-side. COMPAT(rateLimitEvents): added in v0.6.3.
+    z.object({
+        type: z.literal("rate_limit_updated"),
+        provider: AgentProviderSchema,
+        info: AgentRateLimitInfoSchema,
+    }),
 ]);
 const AgentPersistenceHandleSchema = z
     .object({
@@ -1229,6 +1289,32 @@ export const SpeechTtsPreviewRequestSchema = z.object({
         .passthrough()
         .optional(),
 });
+// COMPAT(visualizerVoiceCues): added in v0.6.3; gate lives in
+// features.visualizerVoiceCues. Author short spoken "cue" lines for a
+// personality — a handful of variations each for three Visualizer moments
+// (join / thinking / done) — via the Writer mini-task chain, flavored by the
+// persona's `name` + `prompt`. The persona is passed inline (not a stored id)
+// so the personality editor can generate for an unsaved draft too; the result
+// is stored on the personality (`voiceCues`) and edited there, so this is an
+// editor-time action, not a runtime one. `cwd` scopes provider resolution to a
+// workspace; omitted falls back to any resolvable one.
+export const VisualizerVoiceCuesGenerateRequestSchema = z.object({
+    type: z.literal("visualizer.voiceCues.generate.request"),
+    requestId: z.string(),
+    name: z.string(),
+    prompt: z.string().optional(),
+    cwd: z.string().optional(),
+    // The persona's roles (e.g. "researcher", "coder") so the writer can flavor
+    // the lines to what the agent does. Permissive strings to match the stored
+    // personality shape (forward-compatible with roles this daemon predates).
+    roles: z.array(z.string().min(1)).optional(),
+    // When present, author only this one moment's lines (a focused single-moment
+    // prompt) and return only that group. The editor issues one request per
+    // moment so it can show generation progress and keep the moments distinct.
+    // Omitted → author all three at once (the original all-in-one path, still
+    // used by older clients).
+    moment: z.enum(CUE_MOMENTS).optional(),
+});
 export const AgentPersonalitiesGetStatsRequestSchema = z.object({
     type: z.literal("agentPersonalities.get_stats.request"),
     requestId: z.string(),
@@ -1620,11 +1706,22 @@ const SuggestedTaskActionResponsePayloadSchema = z.object({
     error: z.string().nullable(),
 });
 // Start one or more suggested tasks, applying the SAME mode to each — no
-// combining. `worktree` spins a new worktree-backed workspace per task, `local`
-// a new session in the same repo/cwd per task, `in_session` steers the parent
-// agent with the task prompt. The daemon resolves the parent agent's brain
-// (provider/model/personality) so a started task continues the suggesting agent.
-export const TasksSuggestedStartModeSchema = z.enum(["worktree", "local", "in_session"]);
+// combining. Four modes, only `subagent` links the new agent to the parent:
+//  - `new_chat`:   a fresh independent agent in its own tab, same repo/cwd, NO
+//                  parent link — survives the parent's cancel/archive.
+//  - `subagent`:   a bound child agent that shows in the parent's Subagents
+//                  track and archive-cascades with it.
+//  - `worktree`:   an independent agent on a new git worktree (auto branch-off),
+//                  isolated workspace — also unlinked from the parent.
+//  - `in_session`: steers the parent agent with the task prompt (no new agent).
+// The daemon resolves the parent agent's brain (provider/model/personality) so a
+// started task continues the suggesting agent.
+export const TasksSuggestedStartModeSchema = z.enum([
+    "new_chat",
+    "subagent",
+    "worktree",
+    "in_session",
+]);
 export const TasksSuggestedStartRequestMessageSchema = z.object({
     type: z.literal("tasks.suggested.start.request"),
     parentAgentId: z.string(),
@@ -2608,6 +2705,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigRequestMessageSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
+    VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
     ReadProjectConfigRequestMessageSchema,
     WriteProjectConfigRequestMessageSchema,
@@ -2956,6 +3054,8 @@ export const ServerInfoStatusPayloadSchema = z
         agentPersonalities: z.boolean().optional(),
         // COMPAT(ttsPreview): added in v0.4.7, drop the gate when daemon floor >= v0.4.7.
         ttsPreview: z.boolean().optional(),
+        // COMPAT(visualizerVoiceCues): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        visualizerVoiceCues: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
         setAgentPersonality: z.boolean().optional(),
         // COMPAT(checkoutGitCommit): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
@@ -2984,6 +3084,15 @@ export const ServerInfoStatusPayloadSchema = z
         // permissions). The client gates this behind an "edit anyway" warning;
         // an old daemon leaves the flag unset and out-of-project files are not offered.
         fileOutsideWorkspace: z.boolean().optional(),
+        // COMPAT(promptSuggestions): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        // Set when the daemon emits agent_stream `prompt_suggestion` events (native
+        // Claude next-prompt predictions). The client gates the Settings toggle on
+        // this; suggestions already degrade silently on an old daemon (no event).
+        promptSuggestions: z.boolean().optional(),
+        // COMPAT(rateLimitEvents): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        // Set when the daemon emits agent_stream `rate_limit_updated` events (Claude
+        // plan rate-limit status). Warnings degrade silently on an old daemon (no event).
+        rateLimitEvents: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3666,6 +3775,18 @@ export const SpeechTtsPreviewResponseSchema = z.object({
     })
         .passthrough(),
 });
+export const VisualizerVoiceCuesGenerateResponseSchema = z.object({
+    type: z.literal("visualizer.voiceCues.generate.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // Absent when generation failed (see error) or no writer/provider
+        // resolves on this host. Reuses the stored-cues shape.
+        cues: AgentPersonalityVoiceCuesSchema.optional(),
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
 export const AgentPersonalitiesGetStatsResponseSchema = z.object({
     type: z.literal("agentPersonalities.get_stats.response"),
     payload: z
@@ -5141,6 +5262,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigResponseMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
+    VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
     ReadProjectConfigResponseMessageSchema,
     WriteProjectConfigResponseMessageSchema,

package/dist/observed-subagent-title.d.ts

@@ -0,0 +1,26 @@
+/** Hard cap so no provider summary can produce a wall-of-text label. */
+export declare const OBSERVED_SUBAGENT_TITLE_MAX = 60;
+export declare function normalizeObservedTitleSource(value: string | undefined | null): string | null;
+export declare function normalizeObservedSubagentType(value: string | undefined | null): string | null;
+/**
+ * Derive the frozen row name for an observed subagent. Prefer the stable
+ * `subAgentType` (e.g. "code-explorer") over the description — a
+ * `task_progress` description is the ever-changing AI summary, which must
+ * never become the label. Generic catch-all types ("general-purpose") are
+ * skipped in favor of the description. Callers freeze the result at the first
+ * named update.
+ */
+export declare function deriveObservedSubagentTitle(update: {
+    subAgentType?: string;
+    description?: string;
+}): string;
+/**
+ * True when this update carries a real name source we can freeze the title on.
+ * A generic catch-all type alone doesn't count — freezing "general-purpose"
+ * would lock out the description a later update may carry.
+ */
+export declare function observedUpdateHasTitleSource(update: {
+    subAgentType?: string;
+    description?: string;
+}): boolean;
+//# sourceMappingURL=observed-subagent-title.d.ts.map

package/dist/observed-subagent-title.js

@@ -0,0 +1,63 @@
+// Shared naming rule for provider-managed (observed) subagents. This is the
+// single source of truth for how an observed subagent is titled — the daemon
+// uses it to freeze the track-row label (agent-projections.ts), and the app's
+// visualizer uses it so page-side child labels (subagent_dispatch/return
+// particles ride an edge keyed by child NAME) resolve to exactly the same
+// string as the child node the daemon-titled agent row spawned. If the two
+// ever diverge, the dispatch/return visuals silently stop rendering.
+// See docs/agent-lifecycle.md (Item 4) and docs/visualizer.md.
+/** Hard cap so no provider summary can produce a wall-of-text label. */
+export const OBSERVED_SUBAGENT_TITLE_MAX = 60;
+/**
+ * Catch-all subagent types that make lousy row labels — Claude's default Task
+ * runs as "general-purpose". These never become the title; the task
+ * description names the row instead (user-locked).
+ */
+const GENERIC_OBSERVED_SUBAGENT_TYPES = new Set([
+    "general-purpose",
+    "general",
+    "task",
+    "agent",
+    "subagent",
+]);
+export function normalizeObservedTitleSource(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const collapsed = value.replace(/\s+/g, " ").trim();
+    return collapsed.length > 0 ? collapsed : null;
+}
+export function normalizeObservedSubagentType(value) {
+    const normalized = normalizeObservedTitleSource(value);
+    if (normalized === null || GENERIC_OBSERVED_SUBAGENT_TYPES.has(normalized.toLowerCase())) {
+        return null;
+    }
+    return normalized;
+}
+/**
+ * Derive the frozen row name for an observed subagent. Prefer the stable
+ * `subAgentType` (e.g. "code-explorer") over the description — a
+ * `task_progress` description is the ever-changing AI summary, which must
+ * never become the label. Generic catch-all types ("general-purpose") are
+ * skipped in favor of the description. Callers freeze the result at the first
+ * named update.
+ */
+export function deriveObservedSubagentTitle(update) {
+    const base = normalizeObservedSubagentType(update.subAgentType) ??
+        normalizeObservedTitleSource(update.description) ??
+        "Subagent";
+    if (base.length <= OBSERVED_SUBAGENT_TITLE_MAX) {
+        return base;
+    }
+    return `${base.slice(0, OBSERVED_SUBAGENT_TITLE_MAX - 1).trimEnd()}…`;
+}
+/**
+ * True when this update carries a real name source we can freeze the title on.
+ * A generic catch-all type alone doesn't count — freezing "general-purpose"
+ * would lock out the description a later update may carry.
+ */
+export function observedUpdateHasTitleSource(update) {
+    return (normalizeObservedSubagentType(update.subAgentType) !== null ||
+        normalizeObservedTitleSource(update.description) !== null);
+}
+//# sourceMappingURL=observed-subagent-title.js.map

package/dist/tool-call-display.d.ts

@@ -7,5 +7,14 @@ export interface ToolCallDisplayModel {
     summary?: string;
     errorText?: string;
 }
+/**
+ * Friendly display name for a bare tool identifier, used at every surface that
+ * shows a tool/action name without a full timeline item to run through
+ * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
+ * activity rows). Strips the MCP/Otto namespace, consults the known-tool
+ * registry, then title-cases as a fallback — so "mcp__otto__spawn_task",
+ * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ */
+export declare function getToolDisplayName(name: string): string;
 export declare function buildToolCallDisplayModel(input: ToolCallDisplayInput): ToolCallDisplayModel;
 //# sourceMappingURL=tool-call-display.d.ts.map

package/dist/tool-call-display.js

@@ -1,4 +1,4 @@
-import { getOttoToolLeafName, isOttoToolName } from "./tool-name-normalization.js";
+import { getMcpToolLeafName, getOttoToolLeafName } from "./tool-name-normalization.js";
 import { stripCwdPrefix } from "./path-utils.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6,26 +6,71 @@ function isRecord(value) {
 function readString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+// Curated display names — the registry of tools we explicitly "know about".
+// Keyed by the lowercased leaf name (transport namespace already stripped).
+//
+// Only tools whose bare id does NOT title-case cleanly on its own need an entry
+// here: lowercase compound names ("websearch") a splitter can't segment, or
+// ones we want to word deliberately. Well-formed snake_case ("spawn_task") and
+// camelCase ("WebSearch") names are handled by the algorithmic humanizer below
+// and do NOT need listing.
+//
+// Anything not here falls through to the humanizer and still renders readably —
+// so an unmapped tool shows up looking slightly generic (e.g. a stray provider
+// tool), which is the cue to add it here. Extend this map to teach Otto a tool.
+const KNOWN_TOOL_DISPLAY_NAMES = {
+    websearch: "Web Search",
+    web_search: "Web Search",
+    webfetch: "Web Fetch",
+    web_fetch: "Web Fetch",
+    todowrite: "Update Todos",
+    todoread: "Read Todos",
+    multiedit: "Multi Edit",
+    notebookedit: "Edit Notebook",
+    notebookread: "Read Notebook",
+    bashoutput: "Bash Output",
+    killshell: "Kill Shell",
+    exitplanmode: "Exit Plan Mode",
+    applypatch: "Apply Patch",
+    ls: "List Files",
+};
+// Split camelCase / PascalCase and separator-delimited identifiers into words,
+// then Title-Case them: "WebSearch" -> "Web Search", "spawn_task" -> "Spawn
+// Task", "HTTPServer" -> "HTTP Server".
+function titleCaseToolId(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+        .join(" ");
+}
 function humanizeToolName(name) {
     const trimmed = name.trim();
     if (!trimmed) {
         return name;
     }
-    if (isOttoToolName(trimmed)) {
-        const leaf = getOttoToolLeafName(trimmed);
-        if (leaf) {
-            return humanizeToolName(leaf);
-        }
-    }
-    if (/[:./]/.test(trimmed) || trimmed.includes("__")) {
-        return trimmed;
+    // Strip the transport namespace first ("mcp__otto__spawn_task" ->
+    // "spawn_task", "otto.list_agents" -> "list_agents") so both the known-tool
+    // lookup and the fallback operate on the bare tool id.
+    const leaf = getMcpToolLeafName(trimmed) ?? getOttoToolLeafName(trimmed);
+    if (leaf) {
+        return humanizeToolName(leaf);
     }
-    return trimmed
-        .replace(/[._-]+/g, " ")
-        .split(" ")
-        .filter((segment) => segment.length > 0)
-        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
-        .join(" ");
+    return KNOWN_TOOL_DISPLAY_NAMES[trimmed.toLowerCase()] ?? titleCaseToolId(trimmed);
+}
+/**
+ * Friendly display name for a bare tool identifier, used at every surface that
+ * shows a tool/action name without a full timeline item to run through
+ * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
+ * activity rows). Strips the MCP/Otto namespace, consults the known-tool
+ * registry, then title-cases as a fallback — so "mcp__otto__spawn_task",
+ * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ */
+export function getToolDisplayName(name) {
+    return humanizeToolName(name);
 }
 function formatErrorText(error) {
     if (error === null || error === undefined) {

package/dist/tool-name-normalization.d.ts

@@ -5,5 +5,21 @@ export declare function isSpeakToolName(name: string): boolean;
 export declare function isLikelyNamespacedToolName(name: string): boolean;
 export declare function isOttoToolName(name: string): boolean;
 export declare function getOttoToolLeafName(name: string): string | null;
+/**
+ * Strip a leading MCP namespace for DISPLAY, returning the bare tool id.
+ *
+ * Tools hosted over MCP arrive namespaced as `mcp__<server>__<tool>` (Claude
+ * Code format). The `mcp__<server>__` part is transport plumbing that means
+ * nothing to a reader — "Create Issue", not "mcp__linear__create_issue". This
+ * generalizes {@link getOttoToolLeafName} to ANY server so every MCP tool reads
+ * cleanly, not just Otto's own.
+ *
+ * Returns `null` when the name carries no `mcp__…__` namespace, so callers keep
+ * plain tool names (`Read`, `bash`) and dotted/other forms untouched. Case is
+ * preserved — MCP tool ids are already snake_case and callers humanize after.
+ * `speak` is never treated as namespaced (it renders as a chat bubble, not an
+ * action row).
+ */
+export declare function getMcpToolLeafName(name: string): string | null;
 export declare function isLikelyExternalToolName(name: string): boolean;
 //# sourceMappingURL=tool-name-normalization.d.ts.map

package/dist/tool-name-normalization.js

@@ -69,6 +69,32 @@ export function getOttoToolLeafName(name) {
     }
     return null;
 }
+/**
+ * Strip a leading MCP namespace for DISPLAY, returning the bare tool id.
+ *
+ * Tools hosted over MCP arrive namespaced as `mcp__<server>__<tool>` (Claude
+ * Code format). The `mcp__<server>__` part is transport plumbing that means
+ * nothing to a reader — "Create Issue", not "mcp__linear__create_issue". This
+ * generalizes {@link getOttoToolLeafName} to ANY server so every MCP tool reads
+ * cleanly, not just Otto's own.
+ *
+ * Returns `null` when the name carries no `mcp__…__` namespace, so callers keep
+ * plain tool names (`Read`, `bash`) and dotted/other forms untouched. Case is
+ * preserved — MCP tool ids are already snake_case and callers humanize after.
+ * `speak` is never treated as namespaced (it renders as a chat bubble, not an
+ * action row).
+ */
+export function getMcpToolLeafName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || isSpeakToolName(trimmed) || !trimmed.includes("__")) {
+        return null;
+    }
+    const segments = trimmed.split("__").filter((segment) => segment.length > 0);
+    if (segments.length >= 3 && segments[0].toLowerCase() === "mcp") {
+        return segments.slice(2).join("__");
+    }
+    return null;
+}
 export function isLikelyExternalToolName(name) {
     const normalized = normalizeToolName(name);
     if (!normalized) {

package/dist/validation/ws-outbound-schema-metadata.d.ts

@@ -183,6 +183,33 @@ export declare const WSOutboundMessageSchema: {
                 args: import("zod").ZodObject<{
                     browserId: import("zod").ZodString;
                 }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                command: import("zod").ZodLiteral<"focus_tab">;
+                args: import("zod").ZodObject<{
+                    browserId: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                command: import("zod").ZodLiteral<"page_text">;
+                args: import("zod").ZodObject<{
+                    browserId: import("zod").ZodString;
+                    maxChars: import("zod").ZodDefault<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                command: import("zod").ZodLiteral<"set_color_scheme">;
+                args: import("zod").ZodObject<{
+                    browserId: import("zod").ZodString;
+                    colorScheme: import("zod").ZodEnum<{
+                        auto: "auto";
+                        light: "light";
+                        dark: "dark";
+                    }>;
+                }, import("zod/v4/core").$strict>;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                command: import("zod").ZodLiteral<"screenshot_element">;
+                args: import("zod").ZodObject<{
+                    browserId: import("zod").ZodString;
+                    ref: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>;
             }, import("zod/v4/core").$strip>], "command">;
         }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"activity_log">;
@@ -1073,6 +1100,24 @@ export declare const WSOutboundMessageSchema: {
                             }>;
                         }, import("zod/v4/core").$strip>;
                     }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    type: import("zod").ZodLiteral<"prompt_suggestion">;
+                    provider: import("zod").ZodString;
+                    suggestion: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    type: import("zod").ZodLiteral<"rate_limit_updated">;
+                    provider: import("zod").ZodString;
+                    info: import("zod").ZodObject<{
+                        status: import("zod").ZodEnum<{
+                            warning: "warning";
+                            allowed: "allowed";
+                            rejected: "rejected";
+                        }>;
+                        utilizationPercent: import("zod").ZodOptional<import("zod").ZodNumber>;
+                        limitType: import("zod").ZodOptional<import("zod").ZodString>;
+                        resetsAt: import("zod").ZodOptional<import("zod").ZodString>;
+                        isUsingOverage: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                    }, import("zod/v4/core").$strip>;
                 }, import("zod/v4/core").$strip>], "type">;
                 timestamp: import("zod").ZodString;
                 seq: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -3446,6 +3491,11 @@ export declare const WSOutboundMessageSchema: {
                                 model: import("zod").ZodString;
                                 name: import("zod").ZodString;
                             }, import("zod/v4/core").$loose>>;
+                            voiceCues: import("zod").ZodOptional<import("zod").ZodObject<{
+                                join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            }, import("zod/v4/core").$loose>>;
                         }, import("zod/v4/core").$loose>>>;
                     }, import("zod/v4/core").$loose>>;
                     agentTeams: import("zod").ZodDefault<import("zod").ZodObject<{
@@ -3570,6 +3620,11 @@ export declare const WSOutboundMessageSchema: {
                                 model: import("zod").ZodString;
                                 name: import("zod").ZodString;
                             }, import("zod/v4/core").$loose>>;
+                            voiceCues: import("zod").ZodOptional<import("zod").ZodObject<{
+                                join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                            }, import("zod/v4/core").$loose>>;
                         }, import("zod/v4/core").$loose>>>;
                     }, import("zod/v4/core").$loose>>;
                     agentTeams: import("zod").ZodDefault<import("zod").ZodObject<{
@@ -3637,6 +3692,17 @@ export declare const WSOutboundMessageSchema: {
                 format: import("zod").ZodOptional<import("zod").ZodString>;
                 error: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$loose>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"visualizer.voiceCues.generate.response">;
+            payload: import("zod").ZodObject<{
+                requestId: import("zod").ZodString;
+                cues: import("zod").ZodOptional<import("zod").ZodObject<{
+                    join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$loose>>;
+                error: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"agentPersonalities.get_stats.response">;
             payload: import("zod").ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/protocol",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Otto shared protocol schemas and wire types",
   "files": [
     "dist",