@otto-code/protocol 0.6.5 → 0.6.7

package/dist/messages.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { TerminalActivitySchema } from "./terminal-activity.js";
-import { RunSchema } from "./orchestration.js";
+import { OrchestrationGraphSchema, RunSchema } from "./orchestration.js";
 import { ArtifactMetadataSchema } from "./artifacts/types.js";
 import { ArtifactListRequestSchema, ArtifactCreateRequestSchema, ArtifactUpdateRequestSchema, ArtifactRegenerateRequestSchema, ArtifactCancelRequestSchema, ArtifactDeleteRequestSchema, ArtifactStarRequestSchema, ArtifactGetContentRequestSchema, ArtifactListResponseSchema, ArtifactCreateResponseSchema, ArtifactUpdateResponseSchema, ArtifactRegenerateResponseSchema, ArtifactCancelResponseSchema, ArtifactDeleteResponseSchema, ArtifactStarResponseSchema, ArtifactGetContentResponseSchema, ArtifactCreatedNotificationSchema, ArtifactUpdatedNotificationSchema, ArtifactDeletedNotificationSchema, } from "./artifacts/rpc-schemas.js";
 import { CLIENT_CAPS } from "./client-capabilities.js";
@@ -199,20 +199,25 @@ 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"];
+// The 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.
+// "waiting" is the parent's turn ending while its observed sub-agents are still
+// running; it DEFERS "done" rather than replacing it (see docs/visualizer.md).
+export const CUE_MOMENTS = ["join", "thinking", "waiting", "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".
+// — a few short variations for each Visualizer moment (its node joins the graph,
+// first starts thinking, finishes its turn but waits on sub-agents, 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 (personalities
+// authored before "waiting" existed simply stay silent for that moment).
+// See docs/visualizer.md "Voice cues".
 const AgentPersonalityVoiceCuesSchema = z
     .object({
     join: z.array(z.string()).optional(),
     thinking: z.array(z.string()).optional(),
+    waiting: z.array(z.string()).optional(),
     done: z.array(z.string()).optional(),
 })
     .passthrough();
@@ -367,6 +372,12 @@ export const MutableDaemonConfigSchema = z
         preferWriterPersonalities: false,
     }),
     autoArchiveAfterMerge: z.boolean().default(false),
+    // Drop the "Merge into <base>" action from the client's source-control menu
+    // (and stop promoting it to the primary CTA) for a pull-request-only
+    // workflow. Host-level so the whole team's clients share one policy.
+    // Defaults false so a new client parsing an old daemon's config keeps the
+    // action visible. Gated by server_info features.hideMergeIntoBaseSetting.
+    hideMergeIntoBaseAction: z.boolean().default(false),
     enableTerminalAgentHooks: z.boolean().default(false),
     appendSystemPrompt: z.string().default(""),
     terminalProfiles: z.array(TerminalProfileSchema).optional(),
@@ -407,6 +418,8 @@ export const MutableDaemonConfigPatchSchema = z
         .optional(),
     metadataGeneration: MutableMetadataGenerationConfigSchema.partial().optional(),
     autoArchiveAfterMerge: z.boolean().optional(),
+    // Gated by server_info features.hideMergeIntoBaseSetting.
+    hideMergeIntoBaseAction: z.boolean().optional(),
     enableTerminalAgentHooks: z.boolean().optional(),
     appendSystemPrompt: z.string().optional(),
     terminalProfiles: z.array(TerminalProfileSchema).optional(),
@@ -1364,6 +1377,35 @@ export const SpeechTtsPreviewRequestSchema = z.object({
         .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(),
+});
 // 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
@@ -2363,6 +2405,97 @@ export const RunsClearedNotificationSchema = z.object({
         runIds: z.array(z.string()),
     }),
 });
+// ── Orchestration graphs (user orchestrations) ──────────────────────────────
+// Host-level reusable graph templates + user-initiated orchestration start.
+// Gated by server_info.features.orchestrationGraphs. UI says "Orchestration"
+// and "Graph"; the wire keeps the short `runs.` namespace (see docs/glossary.md).
+// See projects/orchestration-graphs.
+export const RunsGraphsListRequestSchema = z.object({
+    type: z.literal("runs.graphs.list.request"),
+    requestId: z.string(),
+});
+export const RunsGraphsListResponseSchema = z.object({
+    type: z.literal("runs.graphs.list.response"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+        requestId: z.string(),
+    }),
+});
+// Upsert a graph template (create when the id is new). Built-in graphs are
+// copy-on-edit daemon-side: saving over a builtIn id persists a user copy.
+export const RunsGraphsSaveRequestSchema = z.object({
+    type: z.literal("runs.graphs.save.request"),
+    graph: OrchestrationGraphSchema,
+    requestId: z.string(),
+});
+export const RunsGraphsSaveResponseSchema = z.object({
+    type: z.literal("runs.graphs.save.response"),
+    payload: z.object({
+        graph: OrchestrationGraphSchema.optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsGraphsDeleteRequestSchema = z.object({
+    type: z.literal("runs.graphs.delete.request"),
+    graphId: z.string(),
+    requestId: z.string(),
+});
+export const RunsGraphsDeleteResponseSchema = z.object({
+    type: z.literal("runs.graphs.delete.response"),
+    payload: z.object({
+        deleted: z.boolean(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+// Broadcast after any save/delete so every client's graph cache converges,
+// mirroring runs.updated.notification's role for runs.
+export const RunsGraphsChangedNotificationSchema = z.object({
+    type: z.literal("runs.graphs.changed.notification"),
+    payload: z.object({
+        graphs: z.array(OrchestrationGraphSchema),
+    }),
+});
+// Start (or draft) a user-initiated orchestration from the New Orchestration
+// dialog. `flavor` is an open vocabulary: "ai" (prompt-and-go — the daemon
+// spawns an orchestrator agent that declares its own plan via start_run) or
+// "graph" (deterministic — the daemon executes `graphId` with `graphInputs`).
+// `draft: true` creates the record without executing (the designer flow);
+// `runId` executes an existing draft in place.
+export const RunsStartRequestSchema = z.object({
+    type: z.literal("runs.start.request"),
+    flavor: z.string(),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    // Orchestrator seat when the active team doesn't fill it: a personality, or
+    // a bare provider/model pair.
+    orchestratorPersonalityId: z.string().optional(),
+    orchestratorProvider: z.string().optional(),
+    orchestratorModel: z.string().optional(),
+    orchestratorThinkingOptionId: z.string().optional(),
+    prompt: z.string().optional(),
+    graphId: z.string().optional(),
+    graphInputs: z.record(z.string(), z.string()).optional(),
+    draft: z.boolean().optional(),
+    runId: z.string().optional(),
+    requestId: z.string(),
+});
+export const RunsStartResponseSchema = z.object({
+    type: z.literal("runs.start.response"),
+    payload: z.object({
+        runId: z.string().optional(),
+        // The root/orchestrator agent whose chat the client navigates to, and the
+        // workspace the daemon resolved it into (the dialog only knows a project
+        // target's cwd).
+        agentId: z.string().optional(),
+        workspaceId: z.string().optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
 // Namespaced successor to checkout_commit_request: per-file selection and
 // structured errors. Gated by server_info.features.checkoutGitCommit; the flat
 // RPC stays accepted for old clients.
@@ -2401,6 +2534,57 @@ export const CheckoutGitRollbackRequestSchema = z.object({
     allowWithRunningAgents: z.boolean().optional(),
     requestId: z.string(),
 });
+// ── Git file investigation (local git, no hosting provider) ─────────────────
+// History / per-commit diff / blame / origin commit for one file or one line
+// range within it. Everything below is plain local git: it works in a repo with
+// no remote and no forge connection, and it is provider-neutral by construction
+// (it inspects the repo, not an agent), so there is no per-provider rollout to
+// look for. Gated by server_info.features.checkoutGitFileHistory.
+// Commits that touched a file, newest first. Whole-file mode follows renames;
+// passing startLine/endLine switches to `git log -L` for that range instead.
+export const CheckoutGitFileHistoryRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_history.request"),
+    cwd: z.string(),
+    // Repo-relative path, as the file is named today.
+    path: z.string(),
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    // 1-based inclusive line range. Both or neither.
+    startLine: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional(),
+    requestId: z.string(),
+});
+// What a single commit did to a single file, as a unified diff. `path` must be
+// the file's name *at that commit* (history entries carry it) or the pathspec
+// misses across a rename.
+export const CheckoutGitFileCommitDiffRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_commit_diff.request"),
+    cwd: z.string(),
+    path: z.string(),
+    sha: z.string(),
+    ignoreWhitespace: z.boolean().optional(),
+    requestId: z.string(),
+});
+// One page of blame. Always paged — blaming a large file whole would block the
+// daemon — so the client walks the file a page at a time.
+export const CheckoutGitFileBlameRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_blame.request"),
+    cwd: z.string(),
+    path: z.string(),
+    startLine: z.number().int().positive().optional(),
+    lineCount: z.number().int().positive().optional(),
+    // Blame at a specific commit instead of the working tree.
+    sha: z.string().optional(),
+    requestId: z.string(),
+});
+// The commit that first added the file ("who originally wrote this"), following
+// renames so a moved file reports its true origin.
+export const CheckoutGitFileOriginRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_origin.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
 export const CheckoutMergeRequestSchema = z.object({
     type: z.literal("checkout_merge_request"),
     cwd: z.string(),
@@ -2677,6 +2861,23 @@ export const ArchiveWorkspaceRequestSchema = z.object({
     type: z.literal("archive_workspace_request"),
     workspaceId: z.string(),
     requestId: z.string(),
+    // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7, drop the optional
+    // gate when daemon floor >= v0.6.7. Absent means "keep" — the leftover local
+    // branch is never touched (old-client behavior). "delete" asks the daemon to
+    // remove the worktree's local branch after the backing directory is torn down
+    // (only when this was the last reference to it and the branch is not checked
+    // out elsewhere). Gated by server_info.features.worktreeArchiveBranchCleanup.
+    branchDisposition: z.enum(["keep", "delete"]).optional(),
+});
+// Read-only pre-archive inspection for a worktree-backed workspace: what branch
+// it is on, whether that branch is merged into its base, and whether archiving
+// will actually free the branch (last reference, not checked out elsewhere). The
+// client uses this to render the "delete the leftover branch?" confirmation.
+// COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7.
+export const WorkspaceArchivePreflightRequestSchema = z.object({
+    type: z.literal("workspace.archive.preflight.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
 });
 // Create a new workspace record. Unlike open_project, this never deduplicates by
 // directory: it always produces a fresh workspace. The source discriminates
@@ -2709,6 +2910,36 @@ export const WorkspaceCreateRequestSchema = z.object({
         }),
     ]),
 });
+// Re-attach a "left" Otto worktree as a live workspace. Two targets: revive an
+// archived worktree workspace record in place (recreating its backing directory
+// from the kept branch when it is gone), or bind a fresh workspace to an orphaned
+// on-disk Otto worktree that no live workspace references.
+// COMPAT(worktreeReattach): added in v0.6.7. Gated by server_info.features.worktreeReattach.
+export const WorktreeReattachTargetSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("workspace"),
+        workspaceId: z.string(),
+    }),
+    z.object({
+        kind: z.literal("orphan"),
+        worktreePath: z.string(),
+        projectId: z.string().optional(),
+    }),
+]);
+export const WorktreeReattachRequestSchema = z.object({
+    type: z.literal("worktree.reattach.request"),
+    requestId: z.string(),
+    target: WorktreeReattachTargetSchema,
+});
+// List re-attachable Otto worktrees for a project/repo: archived worktree
+// workspace records whose branch is kept, plus orphaned on-disk worktrees with no
+// live workspace. Either projectId or a cwd inside the repo is required.
+export const WorktreeReattachListRequestSchema = z.object({
+    type: z.literal("worktree.reattach.list.request"),
+    requestId: z.string(),
+    projectId: z.string().optional(),
+    cwd: z.string().optional(),
+});
 export const WorkspaceClearAttentionRequestSchema = z.object({
     type: z.literal("workspace.clear_attention.request"),
     workspaceId: z.union([z.string(), z.array(z.string())]),
@@ -3052,6 +3283,8 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigRequestMessageSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
+    SpeechTtsSpeakRequestSchema,
+    SpeechTtsSpeakCancelRequestSchema,
     VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
     ReadProjectConfigRequestMessageSchema,
@@ -3105,10 +3338,18 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitCommitAgentRequestSchema,
     CheckoutGitRollbackRequestSchema,
     CheckoutGitGetOperationLogRequestSchema,
+    CheckoutGitFileHistoryRequestSchema,
+    CheckoutGitFileCommitDiffRequestSchema,
+    CheckoutGitFileBlameRequestSchema,
+    CheckoutGitFileOriginRequestSchema,
     RunsGetSnapshotRequestSchema,
     RunsGateRespondRequestSchema,
     RunsCancelRequestSchema,
     RunsClearRequestSchema,
+    RunsGraphsListRequestSchema,
+    RunsGraphsSaveRequestSchema,
+    RunsGraphsDeleteRequestSchema,
+    RunsStartRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -3144,6 +3385,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     OpenProjectRequestSchema,
     ProjectAddRequestSchema,
     ArchiveWorkspaceRequestSchema,
+    WorkspaceArchivePreflightRequestSchema,
+    WorktreeReattachListRequestSchema,
+    WorktreeReattachRequestSchema,
     WorkspaceCreateRequestSchema,
     WorkspaceClearAttentionRequestSchema,
     FileExplorerRequestSchema,
@@ -3416,6 +3660,9 @@ 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(ttsSpeak): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        // Host can stream a full message aloud on demand (per-message playback).
+        ttsSpeak: 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.
@@ -3428,6 +3675,27 @@ export const ServerInfoStatusPayloadSchema = z
         checkoutGitRollback: z.boolean().optional(),
         // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
         checkoutGitLog: z.boolean().optional(),
+        // Local-git file investigation: history, per-commit diff, blame, origin
+        // commit — for a whole file or a line range. No forge connection needed
+        // and no per-provider rollout; it is git, so every provider gets it at
+        // once.
+        // COMPAT(checkoutGitFileHistory): added in v0.6.6, drop the gate when daemon floor >= v0.6.6.
+        checkoutGitFileHistory: z.boolean().optional(),
+        // Set when the daemon can inspect a worktree's leftover branch before
+        // archiving (workspace.archive.preflight.*) and delete it as part of the
+        // archive (archive_workspace_request.branchDisposition). Without it the
+        // client archives the worktree exactly as before and never offers to
+        // remove the branch — no degraded client-side branch detection exists.
+        // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        worktreeArchiveBranchCleanup: z.boolean().optional(),
+        // COMPAT(worktreeReattach): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        worktreeReattach: z.boolean().optional(),
+        // Set when the daemon persists the host-level hideMergeIntoBaseAction
+        // workspace policy (read/written via the daemon config RPCs). Without
+        // it the client hides the Workspaces toggle, since patching the field
+        // on an old daemon would silently fail to stick.
+        // COMPAT(hideMergeIntoBaseSetting): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        hideMergeIntoBaseSetting: z.boolean().optional(),
         // COMPAT(agentTeams): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
         agentTeams: z.boolean().optional(),
         // COMPAT(modelTierOverrides): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
@@ -3440,6 +3708,8 @@ export const ServerInfoStatusPayloadSchema = z
         activityStats: z.boolean().optional(),
         // COMPAT(runsClear): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
         runsClear: z.boolean().optional(),
+        // COMPAT(orchestrationGraphs): added in v0.6.7, drop the gate when daemon floor >= v0.6.7.
+        orchestrationGraphs: z.boolean().optional(),
         // COMPAT(projectLinks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
         projectLinks: z.boolean().optional(),
         // COMPAT(fileOutsideWorkspace): added in v0.5.8, drop the gate when daemon floor >= v0.5.8.
@@ -3986,6 +4256,79 @@ export const ArchiveWorkspaceResponseMessageSchema = z.object({
         workspaceId: z.string(),
         archivedAt: z.string().nullable(),
         error: z.string().nullable(),
+        // COMPAT(worktreeArchiveBranchCleanup): added in v0.6.7. The name of the
+        // local branch the daemon deleted as part of this archive (when the request
+        // asked for branchDisposition: "delete" and the branch was actually
+        // removed), else null/absent. Old daemons omit it.
+        deletedBranch: z.string().nullable().optional(),
+    }),
+});
+// Whether/how a worktree-backed workspace's local branch can be cleaned up when
+// the workspace is archived. See WorkspaceArchivePreflightRequestSchema.
+export const WorktreeArchiveBranchDetectionSchema = z.object({
+    // True only for Otto-owned worktrees whose branch we can offer to delete.
+    // False for local checkouts, plain directories, and non-owned worktrees — the
+    // client then skips the branch-cleanup UI entirely.
+    isOttoWorktree: z.boolean(),
+    // The local branch checked out in the worktree, or null when detached/unknown.
+    branchName: z.string().nullable(),
+    // The base ref the branch was created from (origin/ stripped), or null.
+    baseBranch: z.string().nullable(),
+    mergeState: z.enum(["merged", "unmerged", "unknown"]),
+    // Commits on the branch not contained in the base ref; null when unknown.
+    unmergedCommitCount: z.number().int().nonnegative().nullable(),
+    // A matching origin/<branch> exists — deleting the local branch keeps the
+    // remote copy. Purely informational for the confirmation copy.
+    hasRemoteBranch: z.boolean(),
+    // The branch is checked out in another worktree too, so git will refuse to
+    // delete it even after this worktree is removed. The client hides the option.
+    branchCheckedOutElsewhere: z.boolean(),
+    // Archiving will actually remove the backing directory (this is the last
+    // active workspace referencing it). Branch cleanup is only offered when true.
+    directoryWillBeRemoved: z.boolean(),
+});
+export const WorkspaceArchivePreflightResponseSchema = z.object({
+    type: z.literal("workspace.archive.preflight.response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        // Null when detection failed (see error) or the workspace is gone.
+        detection: WorktreeArchiveBranchDetectionSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
+// A re-attachable Otto worktree surfaced by worktree.reattach.list.
+// COMPAT(worktreeReattach): added in v0.6.7.
+export const WorktreeReattachCandidateSchema = z.object({
+    // Present when an archived workspace record still backs this worktree; null for
+    // an orphaned on-disk worktree with no record. The reattach request keys off
+    // whichever identity is available.
+    workspaceId: z.string().nullable(),
+    worktreePath: z.string(),
+    branchName: z.string().nullable(),
+    baseBranch: z.string().nullable(),
+    // The worktree directory currently exists on disk. False means the record was
+    // archived away and the directory must be recreated from the branch on reattach.
+    directoryOnDisk: z.boolean(),
+    // The workspace's human name when we have a record, else null.
+    displayName: z.string().nullable(),
+    archivedAt: z.string().nullable(),
+});
+export const WorktreeReattachListResponseSchema = z.object({
+    type: z.literal("worktree.reattach.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        candidates: z.array(WorktreeReattachCandidateSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const WorktreeReattachResponseSchema = z.object({
+    type: z.literal("worktree.reattach.response"),
+    payload: z.object({
+        requestId: z.string(),
+        // The revived/created workspace descriptor, or null on error.
+        workspace: WorkspaceDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
     }),
 });
 export const FetchAgentResponseMessageSchema = z.object({
@@ -4177,6 +4520,23 @@ export const SpeechTtsPreviewResponseSchema = z.object({
     })
         .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(),
+});
 export const VisualizerVoiceCuesGenerateResponseSchema = z.object({
     type: z.literal("visualizer.voiceCues.generate.response"),
     payload: z
@@ -4645,6 +5005,116 @@ export const CheckoutGitRollbackResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+// ── Git file investigation responses ────────────────────────────────────────
+// A structured failure any of the four file-investigation RPCs can report. They
+// are pure reads, so the failure modes are narrow: not a repo, path/revision
+// rejected, or git itself refused.
+export const CheckoutGitFileErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("not_git_repo"),
+    }),
+    z.object({
+        kind: z.literal("invalid_path"),
+        detail: z.string(),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const GitFileHistoryEntrySchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    subject: z.string(),
+    body: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    // Unix seconds.
+    authoredAt: z.number(),
+    committerName: z.string(),
+    committedAt: z.number(),
+    // The file's name at this commit — differs from the requested path across a
+    // rename. Diff requests must echo this one back, not the current name.
+    path: z.string(),
+    previousPath: z.string().optional(),
+    // Single-letter git status (A/M/D/R/C).
+    changeKind: z.string().optional(),
+    isMerge: z.boolean(),
+    // Parent object names, so a diff view can name the revision it is comparing
+    // against instead of writing "<sha>^". Empty for a root commit.
+    parentShas: z.array(z.string()).optional(),
+});
+export const CheckoutGitFileHistoryResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_history.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        entries: z.array(GitFileHistoryEntrySchema),
+        hasMore: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitFileCommitDiffResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_commit_diff.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        sha: z.string(),
+        diff: z.string(),
+        // Highlighted/parsed form of the same diff, when it parsed cleanly.
+        structured: z.array(ParsedDiffFileSchema).optional(),
+        // The file's previous revision — the diff's left-hand side, and the honest
+        // label for it. Absent when this revision created the file.
+        previousSha: z.string().optional(),
+        previousPath: z.string().optional(),
+        truncated: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const GitBlameLineSchema = z.object({
+    line: z.number(),
+    sha: z.string(),
+    originalLine: z.number(),
+});
+// Blame commit metadata is deduped by sha rather than inlined per line: a
+// thousand-line page usually references a handful of commits.
+export const GitBlameCommitSchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    summary: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    authoredAt: z.number(),
+    path: z.string().optional(),
+});
+export const CheckoutGitFileBlameResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_blame.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        lines: z.array(GitBlameLineSchema),
+        commits: z.array(GitBlameCommitSchema),
+        startLine: z.number(),
+        endLine: z.number(),
+        reachedEndOfFile: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitFileOriginResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_origin.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        // Null when the file has no commit history (never committed, or a shallow
+        // clone that does not reach its creation).
+        entry: GitFileHistoryEntrySchema.nullable(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
 export const CheckoutMergeResponseSchema = z.object({
     type: z.literal("checkout_merge_response"),
     payload: z.object({
@@ -5648,6 +6118,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     LegacyListAvailableEditorsResponseMessageSchema,
     LegacyOpenInEditorResponseMessageSchema,
     ArchiveWorkspaceResponseMessageSchema,
+    WorkspaceArchivePreflightResponseSchema,
+    WorktreeReattachListResponseSchema,
+    WorktreeReattachResponseSchema,
     FetchAgentResponseMessageSchema,
     FetchAgentTimelineResponseMessageSchema,
     AgentForkContextResponseMessageSchema,
@@ -5664,6 +6137,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigResponseMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
+    SpeechTtsSpeakResponseSchema,
+    SpeechTtsSpeakCancelResponseSchema,
     VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
     ReadProjectConfigResponseMessageSchema,
@@ -5707,12 +6182,21 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitRollbackResponseSchema,
     CheckoutGitGetOperationLogResponseSchema,
     CheckoutGitLogAppendedNotificationSchema,
+    CheckoutGitFileHistoryResponseSchema,
+    CheckoutGitFileCommitDiffResponseSchema,
+    CheckoutGitFileBlameResponseSchema,
+    CheckoutGitFileOriginResponseSchema,
     RunsGetSnapshotResponseSchema,
     RunsUpdatedNotificationSchema,
     RunsGateRespondResponseSchema,
     RunsCancelResponseSchema,
     RunsClearResponseSchema,
     RunsClearedNotificationSchema,
+    RunsGraphsListResponseSchema,
+    RunsGraphsSaveResponseSchema,
+    RunsGraphsDeleteResponseSchema,
+    RunsGraphsChangedNotificationSchema,
+    RunsStartResponseSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,