@otto-code/protocol 0.8.10 → 0.8.13

package/dist/speech.js

@@ -0,0 +1,177 @@
+import { z } from "zod";
+/**
+ * Otto speech wire schemas: the speech.* settings, TTS preview and speak RPCs, the local STT/TTS model options, and the mutable speech daemon config. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+// Speech engine ids and model ids stay plain strings on the wire so adding an
+// engine or model never breaks an older peer; the daemon validates values
+// against its own catalog when applying a patch.
+export const MutableSpeechSttConfigSchema = z
+    .object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    language: z.string().optional(),
+})
+    .passthrough();
+export const MutableSpeechTtsConfigSchema = z
+    .object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    // Voice name (e.g. "af_heart" for local Kokoro, "alloy" for OpenAI). The
+    // daemon maps local voice names to sherpa speaker ids internally.
+    voice: z.string().optional(),
+    speed: z.number().optional(),
+})
+    .passthrough();
+export const MutableSpeechDictationConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    stt: MutableSpeechSttConfigSchema.optional(),
+})
+    .passthrough();
+export const MutableSpeechVoiceModeConfigSchema = z
+    .object({
+    enabled: z.boolean().optional(),
+    stt: MutableSpeechSttConfigSchema.optional(),
+    tts: MutableSpeechTtsConfigSchema.optional(),
+})
+    .passthrough();
+// Credentials for the OpenAI speech engine. The key persists to config.json
+// (providers.openai.apiKey) like provider env keys do, and is echoed back in
+// get_daemon_config_response the same way provider connection keys are.
+export const MutableSpeechOpenAiConfigSchema = z
+    .object({
+    apiKey: z.string().optional(),
+})
+    .passthrough();
+export const MutableSpeechConfigSchema = z
+    .object({
+    dictation: MutableSpeechDictationConfigSchema.optional(),
+    voiceMode: MutableSpeechVoiceModeConfigSchema.optional(),
+    openai: MutableSpeechOpenAiConfigSchema.optional(),
+})
+    .passthrough();
+export const SpeechSettingsGetOptionsRequestSchema = z.object({
+    type: z.literal("speech.settings.get_options.request"),
+    requestId: z.string(),
+});
+// One-shot "read this text aloud with this voice" for the voice-preview button.
+// The voice binding is soft, matching personality-voice semantics: an
+// unavailable voice degrades to the host default at synthesis time, and an
+// absent voice uses the host default. Synthesis runs on the host's active TTS
+// provider (there is no per-request provider switch); model/provider are hints.
+export const SpeechTtsPreviewRequestSchema = z.object({
+    type: z.literal("speech.tts.preview.request"),
+    requestId: z.string(),
+    text: z.string(),
+    voice: z
+        .object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        name: z.string(),
+    })
+        .passthrough()
+        .optional(),
+});
+// Read a full assistant message aloud on demand (the per-message playback
+// button). Unlike the preview RPC - which truncates to a short sample and
+// returns one buffered clip - this synthesizes the ENTIRE text and streams it
+// back as `audio_output` chunks (isVoiceMode: false), one group per sentence, so
+// playback starts after the first sentence instead of the whole message.
+// `voice` (optional) is the speaking agent's personality voice, resolved on the
+// client from the live personality (same soft-binding semantics as the preview
+// button); absent uses the host default. The correlated response lands once
+// playback finishes, is canceled, or errors.
+export const SpeechTtsSpeakRequestSchema = z.object({
+    type: z.literal("speech.tts.speak.request"),
+    requestId: z.string(),
+    text: z.string(),
+    voice: z
+        .object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+        name: z.string(),
+    })
+        .passthrough()
+        .optional(),
+});
+// Stop the session's in-flight message playback (the button's stop press).
+// Aborts synthesis on the host; the pending speak response then resolves as
+// canceled and the client flushes its own audio queue.
+export const SpeechTtsSpeakCancelRequestSchema = z.object({
+    type: z.literal("speech.tts.speak.cancel.request"),
+    requestId: z.string(),
+});
+export const SpeechEngineOptionSchema = z.object({
+    id: z.string(),
+    available: z.boolean(),
+    reason: z.string().optional(),
+});
+export const LocalSpeechSttModelOptionSchema = z.object({
+    id: z.string(),
+    // Short display name (e.g. "Parakeet v2 (English)"); older daemons omit it
+    // and clients fall back to the id.
+    label: z.string().optional(),
+    description: z.string(),
+});
+export const LocalSpeechTtsModelOptionSchema = z.object({
+    id: z.string(),
+    label: z.string().optional(),
+    description: z.string(),
+    voices: z.array(z.string()),
+    defaultVoice: z.string(),
+});
+export const SpeechSettingsGetOptionsResponseSchema = z.object({
+    type: z.literal("speech.settings.get_options.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        options: z.object({
+            sttEngines: z.array(SpeechEngineOptionSchema),
+            ttsEngines: z.array(SpeechEngineOptionSchema),
+            local: z.object({
+                sttModels: z.array(LocalSpeechSttModelOptionSchema),
+                ttsModels: z.array(LocalSpeechTtsModelOptionSchema),
+            }),
+            openai: z.object({
+                configured: z.boolean(),
+                sttModels: z.array(z.string()),
+                ttsModels: z.array(z.string()),
+                ttsVoices: z.array(z.string()),
+            }),
+        }),
+    })
+        .passthrough(),
+});
+export const SpeechTtsPreviewResponseSchema = z.object({
+    type: z.literal("speech.tts.preview.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // base64-encoded audio bytes; absent when synthesis failed (see error).
+        audio: z.string().optional(),
+        // Media type carrying the sample rate, e.g. "audio/pcm;rate=24000",
+        // so the client audio engine plays it back at the correct pitch.
+        format: z.string().optional(),
+        // Human-readable failure reason when audio could not be produced.
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
+export const SpeechTtsSpeakResponseSchema = z.object({
+    type: z.literal("speech.tts.speak.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // True when the full message played to completion; absent/false when it was
+        // canceled or produced no audio. `error` carries a human-readable failure.
+        ok: z.boolean().optional(),
+        canceled: z.boolean().optional(),
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
+export const SpeechTtsSpeakCancelResponseSchema = z.object({
+    type: z.literal("speech.tts.speak.cancel.response"),
+    payload: z.object({ requestId: z.string() }).passthrough(),
+});
+//# sourceMappingURL=speech.js.map

package/dist/storage.d.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+/**
+ * Otto storage wire schemas: the history.agents.* archive and the attachments.images.* RPCs that report and clear daemon-side storage. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+export declare const HistoryAgentsClearArchivedRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"history.agents.clear_archived.request">;
+    olderThanDays: z.ZodDefault<z.ZodNumber>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const HistoryAgentsClearArchivedResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"history.agents.clear_archived.response">;
+    payload: z.ZodObject<{
+        matched: z.ZodNumber;
+        deleted: z.ZodNumber;
+        failed: z.ZodNumber;
+        agentIds: z.ZodArray<z.ZodString>;
+        dryRun: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+        ottoBytes: z.ZodOptional<z.ZodNumber>;
+        reclaimedBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const HistoryAgentsStorageStatsRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"history.agents.get_storage_stats.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const HistoryAgentsStorageStatsResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"history.agents.get_storage_stats.response">;
+    payload: z.ZodObject<{
+        archivedCount: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AttachmentsImagesStatsRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attachments.images.get_stats.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const AttachmentsImagesStatsResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attachments.images.get_stats.response">;
+    payload: z.ZodObject<{
+        fileCount: z.ZodNumber;
+        totalBytes: z.ZodNumber;
+        oldestAt: z.ZodNullable<z.ZodString>;
+        maxAgeDays: z.ZodNumber;
+        maxTotalMb: z.ZodNumber;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const AttachmentsImagesClearRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attachments.images.clear.request">;
+    olderThanDays: z.ZodDefault<z.ZodNumber>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const AttachmentsImagesClearResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"attachments.images.clear.response">;
+    payload: z.ZodObject<{
+        matched: z.ZodNumber;
+        deleted: z.ZodNumber;
+        freedBytes: z.ZodNumber;
+        dryRun: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type HistoryAgentsClearArchivedRequest = z.infer<typeof HistoryAgentsClearArchivedRequestSchema>;
+export type HistoryAgentsClearArchivedResponse = z.infer<typeof HistoryAgentsClearArchivedResponseSchema>;
+export type HistoryAgentsStorageStatsRequest = z.infer<typeof HistoryAgentsStorageStatsRequestSchema>;
+export type HistoryAgentsStorageStatsResponse = z.infer<typeof HistoryAgentsStorageStatsResponseSchema>;
+export type AttachmentsImagesStatsRequest = z.infer<typeof AttachmentsImagesStatsRequestSchema>;
+export type AttachmentsImagesStatsResponse = z.infer<typeof AttachmentsImagesStatsResponseSchema>;
+export type AttachmentsImagesClearRequest = z.infer<typeof AttachmentsImagesClearRequestSchema>;
+export type AttachmentsImagesClearResponse = z.infer<typeof AttachmentsImagesClearResponseSchema>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Otto storage wire schemas: the history.agents.* archive and the attachments.images.* RPCs that report and clear daemon-side storage. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+// ── History management ──────────────────────────────────────────────────────
+// Bulk counterpart to the existing flat `delete_agent_request`: hard-delete
+// every archived chat record at or past a cutoff in one server-side pass. It has
+// to be server-side because the history list is cursor-paginated across hosts,
+// so the client never holds the whole archived set.
+//
+// Deleting a chat removes Otto's record only. Provider-owned session data is
+// deliberately left in place. See docs/chat-lifecycle.md.
+// Gated by server_info.features.historyDelete.
+export const HistoryAgentsClearArchivedRequestSchema = z.object({
+    type: z.literal("history.agents.clear_archived.request"),
+    // 0 = every archived chat. N = only chats archived at least N days ago.
+    olderThanDays: z.number().int().min(0).default(0),
+    // Safe by default: a request that omits the flag previews instead of deleting.
+    // The client always sends it explicitly.
+    dryRun: z.boolean().default(true),
+    requestId: z.string(),
+});
+export const HistoryAgentsClearArchivedResponseSchema = z.object({
+    type: z.literal("history.agents.clear_archived.response"),
+    payload: z.object({
+        // How many archived records the cutoff selected - the number the confirm
+        // dialog quotes back after a dry run.
+        matched: z.number().int().nonnegative(),
+        deleted: z.number().int().nonnegative(),
+        failed: z.number().int().nonnegative(),
+        // Ids actually deleted, so the client drops exactly those rows from its
+        // caches. Empty on a dry run. Unlike close_items_response, a destructive
+        // batch reports per-item outcome rather than silently omitting failures.
+        agentIds: z.array(z.string()),
+        dryRun: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+        ottoBytes: z.number().int().nonnegative().optional(),
+        reclaimedBytes: z.number().int().nonnegative().optional(),
+    }),
+});
+export const HistoryAgentsStorageStatsRequestSchema = z.object({
+    type: z.literal("history.agents.get_storage_stats.request"),
+    requestId: z.string(),
+});
+export const HistoryAgentsStorageStatsResponseSchema = z.object({
+    type: z.literal("history.agents.get_storage_stats.response"),
+    payload: z.object({
+        archivedCount: z.number().int().nonnegative(),
+        totalBytes: z.number().nonnegative(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// ── Attachment storage ──────────────────────────────────────────────────────
+// Agents produce image bytes continuously (browser screenshots above all), and
+// the daemon materializes each one to $OTTO_HOME/attachments so the timeline has
+// a file to point at. These two RPCs are the user's window into that store: how
+// much is there, and give it back. See docs/attachment-lifecycle.md.
+//
+// Scope is deliberately global, not per-chat or per-workspace. Filenames are a
+// content hash, so the same bytes may be referenced from several transcripts and
+// "this workspace's images" is a fiction we would have to invent and maintain.
+// Gated by server_info.features.attachmentStorage.
+export const AttachmentsImagesStatsRequestSchema = z.object({
+    type: z.literal("attachments.images.get_stats.request"),
+    requestId: z.string(),
+});
+export const AttachmentsImagesStatsResponseSchema = z.object({
+    type: z.literal("attachments.images.get_stats.response"),
+    payload: z.object({
+        fileCount: z.number().int().nonnegative(),
+        totalBytes: z.number().nonnegative(),
+        // ISO timestamp of the oldest image, or null when the store is empty. The
+        // readout quotes it so "512 MB" comes with "since March".
+        oldestAt: z.string().nullable(),
+        // The policy currently in force, so the settings row shows real numbers
+        // rather than the client's idea of the defaults.
+        maxAgeDays: z.number().int().nonnegative(),
+        maxTotalMb: z.number().int().nonnegative(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const AttachmentsImagesClearRequestSchema = z.object({
+    type: z.literal("attachments.images.clear.request"),
+    // 0 = every stored image. N = only images untouched for at least N days.
+    olderThanDays: z.number().int().min(0).default(0),
+    // Safe by default: a request that omits the flag previews instead of deleting.
+    // The client always sends it explicitly. Same contract as
+    // history.agents.clear_archived, and for the same reason - the client cannot
+    // enumerate the set, and there is no undo.
+    dryRun: z.boolean().default(true),
+    requestId: z.string(),
+});
+export const AttachmentsImagesClearResponseSchema = z.object({
+    type: z.literal("attachments.images.clear.response"),
+    payload: z.object({
+        matched: z.number().int().nonnegative(),
+        deleted: z.number().int().nonnegative(),
+        freedBytes: z.number().nonnegative(),
+        dryRun: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+//# sourceMappingURL=storage.js.map

package/dist/suggested-tasks.d.ts

@@ -0,0 +1,106 @@
+import { z } from "zod";
+/**
+ * Otto suggested-task wire schemas: the tasks.suggested.* start and dismiss RPCs and the suggested-task payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+export declare const SuggestedTaskStateSchema: z.ZodEnum<{
+    pending: "pending";
+    started: "started";
+    dismissed: "dismissed";
+}>;
+export declare const SuggestedTaskInfoSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    parentAgentId: z.ZodString;
+    title: z.ZodString;
+    tldr: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        pending: "pending";
+        started: "started";
+        dismissed: "dismissed";
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const SuggestedTasksChangedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"suggested_tasks_changed">;
+    payload: z.ZodObject<{
+        parentAgentId: z.ZodString;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            parentAgentId: z.ZodString;
+            title: z.ZodString;
+            tldr: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                pending: "pending";
+                started: "started";
+                dismissed: "dismissed";
+            }>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const SuggestedTaskActionResponsePayloadSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    parentAgentId: z.ZodString;
+    accepted: z.ZodBoolean;
+    succeeded: z.ZodNumber;
+    failed: z.ZodNumber;
+    error: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const TasksSuggestedStartModeSchema: z.ZodEnum<{
+    worktree: "worktree";
+    new_chat: "new_chat";
+    subagent: "subagent";
+    in_session: "in_session";
+}>;
+export declare const TasksSuggestedStartRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tasks.suggested.start.request">;
+    parentAgentId: z.ZodString;
+    taskIds: z.ZodArray<z.ZodString>;
+    mode: z.ZodEnum<{
+        worktree: "worktree";
+        new_chat: "new_chat";
+        subagent: "subagent";
+        in_session: "in_session";
+    }>;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const TasksSuggestedStartResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tasks.suggested.start.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        parentAgentId: z.ZodString;
+        accepted: z.ZodBoolean;
+        succeeded: z.ZodNumber;
+        failed: z.ZodNumber;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TasksSuggestedDismissRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tasks.suggested.dismiss.request">;
+    parentAgentId: z.ZodString;
+    taskIds: z.ZodArray<z.ZodString>;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const TasksSuggestedDismissResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tasks.suggested.dismiss.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        parentAgentId: z.ZodString;
+        accepted: z.ZodBoolean;
+        succeeded: z.ZodNumber;
+        failed: z.ZodNumber;
+        error: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SuggestedTaskInfo = z.infer<typeof SuggestedTaskInfoSchema>;
+export type SuggestedTaskState = z.infer<typeof SuggestedTaskStateSchema>;
+export type SuggestedTasksChanged = z.infer<typeof SuggestedTasksChangedSchema>;
+export type TasksSuggestedStartMode = z.infer<typeof TasksSuggestedStartModeSchema>;
+export type TasksSuggestedStartResponseMessage = z.infer<typeof TasksSuggestedStartResponseMessageSchema>;
+export type TasksSuggestedDismissResponseMessage = z.infer<typeof TasksSuggestedDismissResponseMessageSchema>;
+export type TasksSuggestedStartRequestMessage = z.infer<typeof TasksSuggestedStartRequestMessageSchema>;
+export type TasksSuggestedDismissRequestMessage = z.infer<typeof TasksSuggestedDismissRequestMessageSchema>;
+//# sourceMappingURL=suggested-tasks.d.ts.map

package/dist/suggested-tasks.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+/**
+ * Otto suggested-task wire schemas: the tasks.suggested.* start and dismiss RPCs and the suggested-task payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
+ */
+// A suggested task a chat surfaced via the `suggest_task` tool (Claude Desktop
+// parity). Renders as a chip in the parent agent's session; the user starts it
+// (new worktree / local / this session) or dismisses it. The `prompt` is
+// deliberately NOT part of this wire shape - it stays server-side and is only
+// used when the task is started ("not shown directly" in Claude Desktop).
+// COMPAT(suggestedTasks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
+export const SuggestedTaskStateSchema = z.enum(["pending", "started", "dismissed"]);
+export const SuggestedTaskInfoSchema = z.object({
+    taskId: z.string(),
+    parentAgentId: z.string(),
+    title: z.string(),
+    tldr: z.string(),
+    cwd: z.string().optional(),
+    state: SuggestedTaskStateSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+// Pushed with the full current set of pending suggested tasks for a parent
+// agent whenever any of them changes (spawn/start/dismiss) - same full-list
+// reconciliation shape as BackgroundShellTasksChangedSchema.
+export const SuggestedTasksChangedSchema = z.object({
+    type: z.literal("suggested_tasks_changed"),
+    payload: z.object({
+        parentAgentId: z.string(),
+        tasks: z.array(SuggestedTaskInfoSchema),
+    }),
+});
+// Aggregate outcome for a start/dismiss over one or more tasks. `succeeded`/
+// `failed` count the tasks acted on so the client can report "Started 3 tasks";
+// `error` collects any per-task failure messages (the failed tasks' chips stay).
+export const SuggestedTaskActionResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    parentAgentId: z.string(),
+    accepted: z.boolean(),
+    succeeded: z.number(),
+    failed: z.number(),
+    error: z.string().nullable(),
+});
+// Start one or more suggested tasks, applying the SAME mode to each - no
+// 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(),
+    taskIds: z.array(z.string()),
+    mode: TasksSuggestedStartModeSchema,
+    requestId: z.string(),
+});
+export const TasksSuggestedStartResponseMessageSchema = z.object({
+    type: z.literal("tasks.suggested.start.response"),
+    payload: SuggestedTaskActionResponsePayloadSchema,
+});
+export const TasksSuggestedDismissRequestMessageSchema = z.object({
+    type: z.literal("tasks.suggested.dismiss.request"),
+    parentAgentId: z.string(),
+    taskIds: z.array(z.string()),
+    requestId: z.string(),
+});
+export const TasksSuggestedDismissResponseMessageSchema = z.object({
+    type: z.literal("tasks.suggested.dismiss.response"),
+    payload: SuggestedTaskActionResponsePayloadSchema,
+});
+//# sourceMappingURL=suggested-tasks.js.map

package/dist/terminal-compatibility.d.ts

@@ -0,0 +1,55 @@
+import { z } from "zod";
+/**
+ * Otto terminal-compatibility wire schemas: the terminal.compatibility.* probe RPCs. Fork-only capability, so it owns its schemas; messages.ts re-exports them. New file rather than terminal-*.ts because those import from messages.ts.
+ */
+export declare const TerminalCompatibilityDiagnosticRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"terminal.compatibility.diagnostic.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const TerminalCompatibilityDiagnosticStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    pass: "pass";
+    fail: "fail";
+    warn: "warn";
+}>;
+export declare const TerminalCompatibilityDiagnosticCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>;
+    detail: z.ZodString;
+    evidence: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TerminalCompatibilityDiagnosticResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"terminal.compatibility.diagnostic.response">;
+    payload: z.ZodObject<{
+        requestId: z.ZodString;
+        success: z.ZodBoolean;
+        error: z.ZodNullable<z.ZodString>;
+        generatedAt: z.ZodString;
+        platform: z.ZodOptional<z.ZodString>;
+        term: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        termProgram: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        checks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                pass: "pass";
+                fail: "fail";
+                warn: "warn";
+            }>;
+            detail: z.ZodString;
+            evidence: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TerminalCompatibilityDiagnosticStatus = z.infer<typeof TerminalCompatibilityDiagnosticStatusSchema>;
+export type TerminalCompatibilityDiagnosticCheck = z.infer<typeof TerminalCompatibilityDiagnosticCheckSchema>;
+export type TerminalCompatibilityDiagnosticRequest = z.infer<typeof TerminalCompatibilityDiagnosticRequestSchema>;
+export type TerminalCompatibilityDiagnosticResponse = z.infer<typeof TerminalCompatibilityDiagnosticResponseSchema>;
+//# sourceMappingURL=terminal-compatibility.d.ts.map

package/dist/terminal-compatibility.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+/**
+ * Otto terminal-compatibility wire schemas: the terminal.compatibility.* probe RPCs. Fork-only capability, so it owns its schemas; messages.ts re-exports them. New file rather than terminal-*.ts because those import from messages.ts.
+ */
+export const TerminalCompatibilityDiagnosticRequestSchema = z.object({
+    type: z.literal("terminal.compatibility.diagnostic.request"),
+    requestId: z.string(),
+});
+export const TerminalCompatibilityDiagnosticStatusSchema = z.enum([
+    "pass",
+    "fail",
+    "warn",
+    "unknown",
+]);
+export const TerminalCompatibilityDiagnosticCheckSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    status: TerminalCompatibilityDiagnosticStatusSchema,
+    detail: z.string(),
+    evidence: z.string().optional(),
+});
+export const TerminalCompatibilityDiagnosticResponseSchema = z.object({
+    type: z.literal("terminal.compatibility.diagnostic.response"),
+    payload: z.object({
+        requestId: z.string(),
+        success: z.boolean(),
+        error: z.string().nullable(),
+        generatedAt: z.string(),
+        platform: z.string().optional(),
+        term: z.string().nullable().optional(),
+        termProgram: z.string().nullable().optional(),
+        checks: z.array(TerminalCompatibilityDiagnosticCheckSchema),
+    }),
+});
+//# sourceMappingURL=terminal-compatibility.js.map

package/dist/terminal-input-mode.d.ts

@@ -5,6 +5,8 @@ export interface TerminalInputModeFeedResult {
 export interface TerminalInputModeState {
     kittyKeyboardFlags: number;
     win32InputMode: boolean;
+    applicationCursorKeys?: boolean;
+    bracketedPaste?: boolean;
 }
 export declare const DEFAULT_TERMINAL_INPUT_MODE_STATE: TerminalInputModeState;
 export declare function terminalInputModeSupportsModifiedEnter(state: TerminalInputModeState): boolean;
@@ -12,6 +14,8 @@ export declare function terminalInputModeStatesEqual(left: TerminalInputModeStat
 export declare class TerminalInputModeTracker {
     private kittyKeyboardFlags;
     private win32InputMode;
+    private applicationCursorKeys;
+    private bracketedPaste;
     private readonly kittyKeyboardStack;
     private pending;
     feed(data: string): TerminalInputModeFeedResult;