@otto-code/protocol 0.6.6 → 0.7.0

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, PromptTemplateSchema, 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";
@@ -84,6 +84,53 @@ const MutableBrowserToolsConfigSchema = z
     enabled: z.boolean().default(false),
 })
     .passthrough();
+/**
+ * Language-server code intelligence, host-scoped because the servers are processes
+ * on the daemon's machine — they follow the host, not the client.
+ *
+ * `enabled` defaults **on** and that is safe: nothing spawns until a
+ * code-intelligence action needs a language in a workspace, so an unused language
+ * costs nothing. What the switch guarantees is that off means off — no server
+ * spawns for any workspace, and the ctags index still serves the outline and the
+ * fuzzy finder.
+ *
+ * `languages` keys are registry row ids (`typescript`, `python`, `csharp`, …). An
+ * absent key means "use the row's own default", so a new row ships with its
+ * intended default rather than reading as disabled.
+ */
+const MutableLspConfigSchema = z
+    .object({
+    enabled: z.boolean().default(true),
+    languages: z.record(z.string(), z.boolean()).default({}),
+    /** Hard LRU cap on simultaneously running servers, across all workspaces. */
+    maxRunningServers: z.number().int().positive().default(6),
+    idleMinutes: z.number().int().positive().default(10),
+    /** Shorter allowance for workspaces the user is not currently looking at. */
+    backgroundIdleMinutes: z.number().int().positive().default(2),
+})
+    .passthrough();
+/**
+ * "Microsoft .NET Solution Management" — the Solution view's own switch.
+ *
+ * **A sibling of `lsp`, not a member of it.** Turning C# code intelligence off does not turn
+ * this off and vice versa: they are independent capabilities that happen to share a language,
+ * and nesting this inside the LSP settings object would imply exactly the coupling that
+ * decision rejects. (It would also be wrong on the facts — LSP has no project-structure
+ * request, so nothing here rides on a language server.)
+ *
+ * Defaults **off**: the feature spawns a process and evaluates MSBuild. Disabled is genuinely
+ * off, not merely hidden — no discovery walk, no `.sln` read, no `.csproj` parse, no sidecar,
+ * no cache, no watcher, and no view switcher. The daemon reads this before scheduling any work,
+ * so a disabled feature costs exactly one boolean check.
+ */
+const MutableDotnetSolutionConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    /** Hard cap on simultaneously running sidecars, across all workspaces. */
+    maxRunningProbes: z.number().int().positive().default(2),
+    idleMinutes: z.number().int().positive().default(10),
+})
+    .passthrough();
 // 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.
@@ -244,6 +291,13 @@ export const AgentPersonalitySchema = z
     spinner: AgentPersonalitySpinnerSchema.optional(),
     voice: AgentPersonalityVoiceSchema.optional(),
     voiceCues: AgentPersonalityVoiceCuesSchema.optional(),
+    // Whether this personality accrues lessons across sessions (personality
+    // memory). ABSENT MEANS ON: a personality with no lessons injects nothing
+    // and costs nothing, so an off-by-default switch would only mean the feature
+    // never starts working for anyone who did not go looking for it. The switch
+    // exists to stop a personality accruing, not to start it.
+    // See docs/agent-personalities.md § Memory.
+    memoryEnabled: z.boolean().optional(),
 })
     .passthrough();
 const MutableAgentPersonalitiesConfigSchema = z
@@ -372,6 +426,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(),
@@ -396,6 +456,24 @@ export const MutableDaemonConfigSchema = z
     // empty so a new client parsing an old daemon's config still sees a
     // well-formed array.
     savedProviderEndpoints: z.array(SavedProviderEndpointSchema).default([]),
+    // Language-server code intelligence. Gated by server_info features.lsp; the
+    // default section is well-formed so a new client parsing an old daemon's config
+    // still renders the screen.
+    lsp: MutableLspConfigSchema.default({
+        enabled: true,
+        languages: {},
+        maxRunningServers: 6,
+        idleMinutes: 10,
+        backgroundIdleMinutes: 2,
+    }),
+    // The Solution view's switch. Gated by server_info features.solutionView; the default
+    // section is well-formed and OFF, so a new client parsing an old daemon's config renders
+    // the row without ever implying the feature is running.
+    dotnetSolutionManagement: MutableDotnetSolutionConfigSchema.default({
+        enabled: false,
+        maxRunningProbes: 2,
+        idleMinutes: 10,
+    }),
 })
     .passthrough();
 export const MutableDaemonConfigPatchSchema = z
@@ -412,6 +490,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(),
@@ -434,6 +514,11 @@ export const MutableDaemonConfigPatchSchema = z
     // Gated by server_info features.savedProviderEndpoints. Replaces the full
     // array (read-modify-write), so forgetting an endpoint drops it from disk.
     savedProviderEndpoints: z.array(SavedProviderEndpointSchema).optional(),
+    // Gated by server_info features.lsp; patches deep-merge, so a `languages`
+    // patch replaces only the keys it names.
+    lsp: MutableLspConfigSchema.partial().optional(),
+    // Gated by server_info features.solutionView; patches deep-merge.
+    dotnetSolutionManagement: MutableDotnetSolutionConfigSchema.partial().optional(),
 })
     .partial()
     .passthrough();
@@ -555,6 +640,14 @@ const ContextCompositionSchema = z.object({
     reasoning: z.number().optional(),
     subagentResults: z.number().optional(),
 });
+// Declared above AgentUsageSchema on purpose: a schema referenced before its
+// declaration is a build-time ReferenceError in the zod-aot output.
+const AgentContextCategorySchema = z.object({
+    /** Provider-supplied display label, not translated and not an enum. */
+    name: z.string(),
+    tokens: z.number(),
+    isDeferred: z.boolean().optional(),
+});
 const AgentUsageSchema = z.object({
     inputTokens: z.number().optional(),
     cachedInputTokens: z.number().optional(),
@@ -567,6 +660,10 @@ const AgentUsageSchema = z.object({
     // Provider-graded context breakdown for the visualizer ring/bar; absent ⇒
     // occupancy only (pre-composition behavior). See ContextComposition.
     contextComposition: ContextCompositionSchema.optional(),
+    // The provider's own labelled split — same accounting as
+    // `agent.context.get_usage`, pushed on the snapshot. Preferred over
+    // contextComposition; absent ⇒ fall back to the estimate, then to occupancy.
+    contextCategories: z.array(AgentContextCategorySchema).optional(),
 });
 const AgentSessionConfigSchema = z.object({
     provider: AgentProviderSchema,
@@ -911,6 +1008,52 @@ const AgentRuntimeInfoSchema = z.object({
     modeId: z.string().nullable().optional(),
     extra: z.record(z.string(), z.unknown()).optional(),
 });
+/**
+ * One message parked for delivery as an agent's NEXT turn (`delivery: "queue"`).
+ * The daemon owns the queue; this is the read-only projection the Queue track
+ * renders. Declared above AgentSnapshotPayloadSchema — zod-aot emits schemas in
+ * source order, so a forward reference is a build-time ReferenceError.
+ */
+export const QueuedAgentMessagePayloadSchema = z.object({
+    id: z.string(),
+    /** Leading text of the message, truncated for display. */
+    preview: z.string(),
+    enqueuedAt: z.string(),
+    attachmentCount: z.number().int().nonnegative().optional(),
+});
+/**
+ * An agent's LIFETIME SPEND, kept as the real token split plus the provider's
+ * own cost — the raw material for "what did this chat cost".
+ *
+ * Deliberately distinct from context-window occupancy (`agent.context.get_usage`
+ * and `lastUsage.contextWindow*`), which answers "how full am I" and shares no
+ * units with this. Conflating the two is why the numbers used to feel wrong; the
+ * UI must never mix them. See docs/glossary.md.
+ *
+ * `costUsd` is only ever a provider's OWN reported cost, already de-inflated so
+ * a parent never carries what its sub-agents reported. It is NEVER derived from
+ * a $/M rate table — a rate keyed off a model id misprices a gateway serving
+ * that model at its own prices (docs/subagent-accounting.md, pricing invariant).
+ * `costCoverage` says how far it can be trusted, so a surface can show a floor
+ * or an honest blank rather than a confident wrong figure.
+ *
+ * Declared above AgentSnapshotPayloadSchema — zod-aot emits schemas in source
+ * order, so a forward reference is a build-time ReferenceError.
+ */
+export const AgentCumulativeUsageSchema = z.object({
+    inputTokens: z.number().optional(),
+    cachedInputTokens: z.number().optional(),
+    cacheCreationInputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    /** Provider-reported cost booked so far. Absent ⇒ nothing was priceable. */
+    costUsd: z.number().optional(),
+    /**
+     * `complete` — every token-bearing turn was priced; `costUsd` is the total.
+     * `partial` — some turns were unpriced; `costUsd` is a FLOOR, present it as
+     * one. `none` — nothing priceable; show tokens and a blank, never an estimate.
+     */
+    costCoverage: z.enum(["complete", "partial", "none"]).optional(),
+});
 export const AgentSnapshotPayloadSchema = z.object({
     id: z.string(),
     provider: AgentProviderSchema,
@@ -938,6 +1081,30 @@ export const AgentSnapshotPayloadSchema = z.object({
     // additive; absent ⇒ no readout. Old clients ignore it.
     // See docs/agent-lifecycle.md (Item 3).
     cumulativeTokens: z.number().optional(),
+    // The same lifetime spend as `cumulativeTokens`, but as the REAL split plus
+    // the provider's own cost, so a chat total can be priced honestly instead of
+    // flattened to one scalar and multiplied by a guessed rate. Its token leaves
+    // sum to `cumulativeTokens`; a client that ignores this loses only the split
+    // and the cost. Absent ⇒ the daemon predates the field or reported nothing.
+    // COMPAT(cumulativeUsage): added in v0.7.0; gated on
+    // server_info.features.cumulativeUsage, drop the gate when floor >= v0.7.0.
+    // See docs/subagent-accounting.md (Chat totals).
+    cumulativeUsage: AgentCumulativeUsageSchema.optional(),
+    // Liveness signals for the sub-agents track: how much work this agent has done
+    // (`toolUseCount`, cumulative and monotonic) and what it is doing right now
+    // (`currentTool`, the latest tool name, cleared once the agent is terminal —
+    // a finished agent isn't "running Bash"). Both are purely additive optional
+    // leaves: a provider that can't report them leaves them absent and the row
+    // omits the readout rather than showing a wrong value.
+    // COMPAT(subagentLiveness): added in v0.6.7; old clients ignore both.
+    // See docs/chat-lifecycle.md (the subagents track).
+    toolUseCount: z.number().optional(),
+    currentTool: z.string().optional(),
+    // Messages parked for delivery as this agent's NEXT turn (delivery: "queue").
+    // Daemon-owned and ephemeral — the composer's Queue track renders straight
+    // from this. Absent/empty ⇒ nothing queued; old clients ignore it.
+    // COMPAT(steerQueue): added in v0.6.8, drop the gate when floor >= v0.6.8.
+    queuedMessages: z.array(QueuedAgentMessagePayloadSchema).optional(),
     lastError: z.string().optional(),
     title: z.string().nullable(),
     labels: z.record(z.string(), z.string()).default({}),
@@ -1038,6 +1205,45 @@ export const CloseItemsRequestMessageSchema = z.object({
     terminalIds: z.array(z.string()).default([]),
     requestId: z.string(),
 });
+// ── 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. The provider's own on-disk
+// transcript (Claude's `~/.claude/projects/**/<sessionId>.jsonl`, Codex threads,
+// OpenCode sessions) is deliberately left in place: Otto never created it,
+// another tool still reads it, and silently deleting another tool's state is not
+// ours to do. There is intentionally **no** opt-in flag for provider data on the
+// wire — the UI discloses what stays behind instead. 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(),
+    }),
+});
 export const UpdateAgentRequestMessageSchema = z.object({
     type: z.literal("update_agent_request"),
     agentId: z.string(),
@@ -1318,6 +1524,47 @@ export const SendAgentMessageRequestSchema = z.object({
     messageId: z.string().optional(), // Client-provided ID for deduplication
     images: z.array(ImageAttachmentSchema).optional(),
     attachments: AgentAttachmentsSchema,
+    // How to reach a BUSY agent. "interrupt" (default, and what every older
+    // client means by omitting this) cancels the in-flight turn and runs this
+    // instead; "queue" lets the turn finish and runs this as the next one.
+    // Against an idle agent both run immediately.
+    // COMPAT(steerQueue): added in v0.6.8, drop the gate when floor >= v0.6.8.
+    delivery: z.enum(["interrupt", "queue"]).optional(),
+});
+/** Pull one message back out of an agent's queue (Queue-track edit / send now). */
+export const AgentQueueRemoveRequestMessageSchema = z.object({
+    type: z.literal("agent.queue.remove.request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
+    /** The queued message's `id` from `AgentSnapshotPayload.queuedMessages`. */
+    messageId: z.string(),
+});
+/**
+ * Move one queued message to a different position in an agent's queue.
+ *
+ * Order is what the queue means, so this is the edit that changes the next
+ * turn's content without changing the queue's membership. The daemon resolves
+ * `messageId` fresh and clamps `toIndex`, so a client acting on a snapshot that
+ * is one drain stale reorders what is actually there or reports `moved: false`.
+ * COMPAT(steerQueueReorder): added in v0.6.9, drop the gate when floor >= v0.6.9.
+ */
+export const AgentQueueReorderRequestMessageSchema = z.object({
+    type: z.literal("agent.queue.reorder.request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
+    /** The queued message's `id` from `AgentSnapshotPayload.queuedMessages`. */
+    messageId: z.string(),
+    /** Zero-based destination, clamped to the queue's current length. */
+    toIndex: z.number().int().nonnegative(),
+});
+/** Drop every message queued behind an agent's current turn. */
+export const AgentQueueClearRequestMessageSchema = z.object({
+    type: z.literal("agent.queue.clear.request"),
+    requestId: z.string(),
+    /** Accepts full ID, unique prefix, or exact full title (server resolves). */
+    agentId: z.string(),
 });
 export const WaitForFinishRequestSchema = z.object({
     type: z.literal("wait_for_finish_request"),
@@ -1369,6 +1616,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
@@ -1889,7 +2165,7 @@ export const SuggestedTasksChangedSchema = z.object({
     }),
 });
 // Context Management — the daemon's accounting of everything a provider sends
-// before the user types (see projects/context-management/context-management.md).
+// before the user types (see docs/context-management.md).
 //
 // Two distinctions carry the whole feature and must not be collapsed on the
 // wire: an `import` edge is inlined into the request while a `reference` edge
@@ -1940,8 +2216,8 @@ export const ContextFindingSchema = z.object({
     relatedNodeIds: z.array(z.string()).optional(),
     // The node this finding is about. Redundant while the finding sits on its
     // node, load-bearing once the report flattens them all into one list — that
-    // list is the "Worth fixing" tab, and without this a row cannot say where it
-    // came from or take you there.
+    // list is the "Issues" tab, and without this a row cannot say where it came
+    // from or take you there.
     nodeId: z.string().optional(),
     // 1-based line of `range.start` in that node's file, so the fix list can jump
     // the editor without the client re-reading bytes to count newlines.
@@ -1949,6 +2225,16 @@ export const ContextFindingSchema = z.object({
     // Last line of the range, so the client can select the whole offending span
     // rather than dropping a cursor at the top of it.
     lineEnd: z.number().optional(),
+    // True for kinds a mechanical delete can resolve on its own (dead links, a
+    // duplicate block) — false/absent for kinds that need judgment (which side
+    // of an import cycle to cut, how to split an oversized entry). Computed
+    // server-side, once, in `locateFinding` — the only place that knows the kind
+    // vocabulary, so the fix-all button never has to guess.
+    fixable: z.boolean().optional(),
+    // The exact text at `range` when the file was scanned. `context.findings.fix`
+    // verifies this still matches before deleting, the same staleness guard
+    // `context.edge.convert` uses for `rawTarget`.
+    snippet: z.string().optional(),
 });
 export const ContextNodeSchema = z.object({
     id: z.string(),
@@ -1999,6 +2285,16 @@ export const ContextReportSchema = z.object({
     workingRoom: z.number(),
     aggregateSeverity: ContextSeveritySchema,
     findings: z.array(ContextFindingSchema),
+    // Which personality this report was evaluated FOR. Context became
+    // personality-specific once personalities accrue memory, so a report is only
+    // interpretable alongside the identity it was measured against.
+    // COMPAT(personalityMemory): additive; absent = the pre-memory, personality-agnostic report.
+    personalityId: z.string().optional(),
+    // That personality's injected memory brief, in tokens. Folded into the
+    // `otto_injected` category total rather than a new category: ContextCategory
+    // is a z.enum travelling daemon->client, so a new member would make a new
+    // daemon's report unparseable by an older client.
+    personalityMemoryTokens: z.number().optional(),
 });
 // Pushed with the full current report whenever a watched context file changes.
 // Full-report reconciliation, same idiom as suggested_tasks_changed.
@@ -2017,6 +2313,10 @@ export const ContextReportGetRequestMessageSchema = z.object({
     workspaceId: z.string(),
     provider: z.string().optional(),
     windowTokens: z.number().optional(),
+    // "Evaluate as if this personality were running here": folds that
+    // personality's injected memory brief into the report's fixed weight. Omitted
+    // means the personality-agnostic report.
+    personalityId: z.string().optional(),
 });
 export const ContextReportGetResponseMessageSchema = z.object({
     type: z.literal("context.report.get.response"),
@@ -2046,6 +2346,154 @@ export const ContextEdgeConvertResponseMessageSchema = z.object({
         error: z.string().optional(),
     }),
 });
+// Deletes every mechanically-fixable finding's range in one pass — the
+// "Fix all" button in the Issues tab. Each item names the file, the range the
+// scan flagged, and the snippet expected there; a file that changed since the
+// scan is skipped rather than corrupted (charter §7.5).
+export const ContextFindingsFixRequestMessageSchema = z.object({
+    type: z.literal("context.findings.fix.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    findings: z.array(z.object({
+        filePath: z.string(),
+        range: ContextRangeSchema,
+        snippet: z.string(),
+    })),
+});
+export const ContextFindingsFixResponseMessageSchema = z.object({
+    type: z.literal("context.findings.fix.response"),
+    payload: z.object({
+        requestId: z.string(),
+        fixedCount: z.number(),
+        failedCount: z.number(),
+        errors: z.array(z.string()),
+    }),
+});
+// ---------------------------------------------------------------------------
+// Personality memory — the lessons a named personality accrues across sessions.
+// See docs/agent-personalities.md § Memory.
+// ---------------------------------------------------------------------------
+// Plain strings on the wire, like personality roles and effort levels, so the
+// daemon can grow the vocabulary without breaking old peers. Logical values:
+// scope "project" | "global"; source "agent" | "user" | "review" | "transfer".
+export const PersonalityMemoryEntrySchema = z
+    .object({
+    id: z.string(),
+    text: z.string(),
+    scope: z.string(),
+    // Absolute, daemon-side. Present only on project-scoped entries.
+    projectRoot: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    source: z.string(),
+    // How many times the lesson has been restated. Drives injection order and
+    // is shown in the brief, because a repeatedly-relearned gotcha is stronger
+    // evidence than a one-off observation.
+    reinforcedCount: z.number().optional(),
+    transferredFrom: z.string().optional(),
+})
+    .passthrough();
+export const PersonalityMemoryListRequestMessageSchema = z.object({
+    type: z.literal("personality.memory.list.request"),
+    requestId: z.string(),
+    personalityId: z.string(),
+    // Which project's lessons count as in-scope for the returned brief. Prefer
+    // `workspaceId` and let the daemon resolve the root: a client computing repo
+    // roots would disagree with the daemon the moment a worktree is involved.
+    workspaceId: z.string().optional(),
+    // Explicit root, for callers with no workspace. Ignored when `workspaceId`
+    // resolves. Omitted (with no workspace) means global lessons only.
+    projectRoot: z.string().optional(),
+});
+export const PersonalityMemoryListResponseMessageSchema = z.object({
+    type: z.literal("personality.memory.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        personalityId: z.string(),
+        personalityName: z.string(),
+        /** Whether this personality is accruing (the `memoryEnabled` switch). */
+        enabled: z.boolean(),
+        /** Every stored entry, including other projects' — the UI shows them all. */
+        entries: z.array(PersonalityMemoryEntrySchema),
+        // The EXACT text the daemon would inject for `projectRoot`, not a
+        // reconstruction. Memory is only trustworthy if it is inspectable, and the
+        // only way the shown text cannot drift from the injected text is for both
+        // to come from one composer.
+        brief: z.string(),
+        briefTokens: z.number(),
+        /** Entries the injection budget cut, so the UI can say so. */
+        briefOmittedCount: z.number().optional(),
+        // The root the brief was composed for, so the UI can tell a project-scoped
+        // entry that applies here from one belonging to another project. Without it
+        // every project entry looks the same and an empty brief next to a list of
+        // lessons reads as a bug. Absent when the request named no workspace.
+        projectRoot: z.string().optional(),
+    }),
+});
+// One write RPC covers add / edit / delete: no `entryId` = add a new lesson,
+// `drop: true` = forget one. The user-facing editing path from Context
+// Management (charter §2.4).
+export const PersonalityMemoryUpdateRequestMessageSchema = z.object({
+    type: z.literal("personality.memory.update.request"),
+    requestId: z.string(),
+    personalityId: z.string(),
+    entryId: z.string().optional(),
+    text: z.string().optional(),
+    scope: z.string().optional(),
+    // Which project a `scope: "project"` write binds to. Same rule as the list
+    // request: prefer `workspaceId` and let the daemon resolve the root, because a
+    // project-scoped entry whose root does not match the daemon's resolution is
+    // filtered out of every brief and is therefore stored but never sent.
+    workspaceId: z.string().optional(),
+    // Explicit root, for callers with no workspace. Ignored when `workspaceId`
+    // resolves.
+    projectRoot: z.string().optional(),
+    drop: z.boolean().optional(),
+});
+export const PersonalityMemoryUpdateResponseMessageSchema = z.object({
+    type: z.literal("personality.memory.update.response"),
+    payload: z.object({
+        requestId: z.string(),
+        ok: z.boolean(),
+        error: z.string().optional(),
+    }),
+});
+// Deleting a personality must never silently destroy what it learned, so the
+// delete flow resolves here first: `mode: "transfer"` moves the lessons to
+// `toPersonalityId` (merging near-duplicates), `mode: "delete"` discards them.
+export const PersonalityMemoryTransferRequestMessageSchema = z.object({
+    type: z.literal("personality.memory.transfer.request"),
+    requestId: z.string(),
+    fromPersonalityId: z.string(),
+    toPersonalityId: z.string().optional(),
+    mode: z.string(),
+});
+export const PersonalityMemoryTransferResponseMessageSchema = z.object({
+    type: z.literal("personality.memory.transfer.response"),
+    payload: z.object({
+        requestId: z.string(),
+        ok: z.boolean(),
+        /** Entries that landed as new rows in the destination. */
+        transferred: z.number().optional(),
+        /** Entries that merged into a lesson the destination already knew. */
+        merged: z.number().optional(),
+        error: z.string().optional(),
+    }),
+});
+// Per-personality lesson counts. Its own RPC over its own file, mirroring
+// agentPersonalities.get_stats — counts must not ride the daemon-config
+// broadcast, or every recorded lesson would fan a config change to every client.
+export const PersonalityMemoryStatsRequestMessageSchema = z.object({
+    type: z.literal("personality.memory.stats.request"),
+    requestId: z.string(),
+});
+export const PersonalityMemoryStatsResponseMessageSchema = z.object({
+    type: z.literal("personality.memory.stats.response"),
+    payload: z.object({
+        requestId: z.string(),
+        counts: z.record(z.string(), z.number()),
+    }),
+});
 // 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).
@@ -2360,14 +2808,172 @@ export const RunsClearResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+// Delete one run by id. Terminal (done/failed/canceled) and draft runs only —
+// deleting an active run is refused so a cleanup click can't silently orphan
+// running agents; cancel it first. Gated by server_info.features.runsDelete.
+export const RunsDeleteRequestSchema = z.object({
+    type: z.literal("runs.delete.request"),
+    requestId: z.string(),
+    runId: z.string(),
+});
+export const RunsDeleteResponseSchema = z.object({
+    type: z.literal("runs.delete.response"),
+    payload: z.object({
+        // The deleted id, or absent when nothing was deleted (unknown or still
+        // active) — `error` then carries why.
+        runId: z.string().optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
 // Broadcast to every connected client (including the requester) so all
 // caches drop the same runs, mirroring runs.updated.notification's upsert.
+// Serves both runs.clear (many ids) and runs.delete (one).
 export const RunsClearedNotificationSchema = z.object({
     type: z.literal("runs.cleared.notification"),
     payload: 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),
+    }),
+});
+// ── Prompt templates ────────────────────────────────────────────────────────
+// Host-level reusable prompts and snippets a graph node can bind to. Same shape
+// as the graph trio above, for the same reason: one store, list/save/delete,
+// plus a full-list push so every client converges.
+export const RunsTemplatesListRequestSchema = z.object({
+    type: z.literal("runs.templates.list.request"),
+    requestId: z.string(),
+});
+export const RunsTemplatesListResponseSchema = z.object({
+    type: z.literal("runs.templates.list.response"),
+    payload: z.object({
+        templates: z.array(PromptTemplateSchema),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesSaveRequestSchema = z.object({
+    type: z.literal("runs.templates.save.request"),
+    template: PromptTemplateSchema,
+    requestId: z.string(),
+});
+export const RunsTemplatesSaveResponseSchema = z.object({
+    type: z.literal("runs.templates.save.response"),
+    payload: z.object({
+        template: PromptTemplateSchema.optional(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesDeleteRequestSchema = z.object({
+    type: z.literal("runs.templates.delete.request"),
+    templateId: z.string(),
+    requestId: z.string(),
+});
+export const RunsTemplatesDeleteResponseSchema = z.object({
+    type: z.literal("runs.templates.delete.response"),
+    payload: z.object({
+        deleted: z.boolean(),
+        error: z.string().optional(),
+        requestId: z.string(),
+    }),
+});
+export const RunsTemplatesChangedNotificationSchema = z.object({
+    type: z.literal("runs.templates.changed.notification"),
+    payload: z.object({
+        templates: z.array(PromptTemplateSchema),
+    }),
+});
+// 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 — or, with `draft: true`, re-saves
+// that draft in place (Edit Orchestration).
+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.
@@ -2729,10 +3335,129 @@ export const ProjectAddRequestSchema = z.object({
     cwd: z.string(),
     requestId: z.string(),
 });
+// ── New project scaffolding ──────────────────────────────────────────────
+// project.add takes a directory that already exists. Scaffolding is the other
+// half: create the directory, optionally give it a git repo (fresh, or cloned
+// from a remote), optionally create that remote on a connected hosting
+// provider, then register the result as a project. One RPC rather than a
+// client-driven sequence so a half-finished project can never be left behind by
+// a dropped socket — the daemon owns the whole transaction.
+// COMPAT(projectScaffold): added in v0.6.9. Gated by server_info.features.projectScaffold.
+// Built-in .gitignore starters. Deliberately a short list of the ecosystems Otto
+// itself works in — this is a convenience, not a mirror of github/gitignore. The
+// wire field stays an open string so a newer daemon can add one without an older
+// client's validator rejecting the message.
+export const PROJECT_SCAFFOLD_GITIGNORE_TEMPLATE_IDS = [
+    "node",
+    "python",
+    "go",
+    "rust",
+    "java",
+    "dotnet",
+];
+// Where the working tree comes from.
+export const ProjectScaffoldGitSchema = z.discriminatedUnion("kind", [
+    // A plain directory. No repository is created.
+    z.object({ kind: z.literal("none") }),
+    z.object({
+        kind: z.literal("init"),
+        // Branch the fresh repo starts on. Absent means the daemon's git default.
+        initialBranch: z.string().optional(),
+        // Starter files written before the first commit.
+        addReadme: z.boolean().optional(),
+        // Identifier of a built-in .gitignore template (see PROJECT_SCAFFOLD_GITIGNORE_TEMPLATE_IDS).
+        gitignoreTemplate: z.string().optional(),
+        // Commit whatever starter files were written. Required for a push.
+        initialCommit: z.boolean().optional(),
+        // Create the repository on a hosting provider, wire it as `origin`, and push.
+        // Requires the provider's createRepository capability.
+        remote: z
+            .object({
+            providerId: GitHostingProviderIdWireSchema,
+            // Account/organization/workspace to create under. Null means the
+            // provider's default for the authenticated identity.
+            owner: z.string().nullable(),
+            name: z.string(),
+            description: z.string().optional(),
+            visibility: z.enum(["private", "public"]),
+        })
+            .optional(),
+    }),
+    z.object({
+        kind: z.literal("clone"),
+        // Any URL `git clone` accepts (https, ssh, scp-style).
+        url: z.string(),
+    }),
+]);
+export const ProjectScaffoldRequestSchema = z.object({
+    type: z.literal("project.scaffold.request"),
+    requestId: z.string(),
+    // Existing directory that will contain the new project folder.
+    parentDirectory: z.string(),
+    // Single path segment created inside parentDirectory. For a clone this may be
+    // omitted, in which case the daemon derives it from the repository URL.
+    folderName: z.string().optional(),
+    git: ProjectScaffoldGitSchema,
+});
+// Steps are reported in the order the daemon runs them. New daemons may add
+// steps, so the wire form stays an open string and clients label unknown ids
+// generically instead of dropping the progress message.
+export const ProjectScaffoldStepIdSchema = z.string();
+export const ProjectScaffoldStepStatusSchema = z.enum(["running", "done", "skipped", "failed"]);
+export const ProjectScaffoldStepSchema = z.object({
+    id: ProjectScaffoldStepIdSchema,
+    status: ProjectScaffoldStepStatusSchema,
+    detail: z.string().nullable(),
+});
+// Repository enumeration for the clone picker, and owner enumeration for the
+// "create a new remote" form. Both are host-level (no repo cwd exists yet), so
+// they address a provider directly instead of resolving one from a checkout.
+export const HostingListRepositoriesRequestSchema = z.object({
+    type: z.literal("hosting.list_repositories.request"),
+    provider: GitHostingProviderIdWireSchema,
+    // Substring filter applied by the provider where it supports one.
+    query: z.string().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    requestId: z.string(),
+});
+export const HostingListOwnersRequestSchema = z.object({
+    type: z.literal("hosting.list_owners.request"),
+    provider: GitHostingProviderIdWireSchema,
+    requestId: z.string(),
+});
 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(),
+});
+// Repoint a worktree-backed workspace's base branch — what the Changes view diffs
+// against, and what merge-into-base and PR creation target. On a stacked branch the
+// useful base is the parent branch, not the repo default, the same way a forge PR
+// carries an explicit base. A null baseRef resets to the repository default branch.
+// COMPAT(worktreeDiffBase): added in v0.6.8.
+export const WorktreeBaseRefSetRequestSchema = z.object({
+    type: z.literal("worktree.baseRef.set.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    // Branch name, with or without an `origin/` prefix; null resets to the default branch.
+    baseRef: z.string().nullable(),
 });
 // Create a new workspace record. Unlike open_project, this never deduplicates by
 // directory: it always produces a fresh workspace. The source discriminates
@@ -2765,6 +3490,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())]),
@@ -2805,6 +3560,8 @@ const FileExplorerEntrySchema = z.object({
     modifiedAt: z.string(),
 });
 export const FileEolSchema = z.enum(["lf", "crlf"]);
+/** What a directory entry is. Shared by the file-mutation RPCs below. */
+export const FileEntryKindSchema = z.enum(["file", "directory"]);
 const FileExplorerFileSchema = z.object({
     path: z.string(),
     kind: z.enum(["text", "image", "binary"]),
@@ -2870,6 +3627,96 @@ export const FileWriteRequestSchema = z.object({
     eol: FileEolSchema.optional(),
     requestId: z.string(),
 });
+/**
+ * The general file-mutation surface: create, delete, rename/move.
+ *
+ * Deliberately separate from `file.write.request`, which is the text editor's
+ * conditional *content* save. These three change what exists in the directory
+ * rather than what is inside a file, and unlike `file.write` they are
+ * **workspace-bounded**: the daemon refuses a `cwd` outside every known Otto
+ * workspace, the way directory listing already does. Editing a stray file the
+ * user opened by path is one thing; unlinking one is another.
+ *
+ * `path` is workspace-relative throughout, matching every other file RPC.
+ */
+export const FileCreateRequestSchema = z.object({
+    type: z.literal("file.create.request"),
+    cwd: z.string(),
+    path: z.string(),
+    kind: FileEntryKindSchema,
+    requestId: z.string(),
+});
+/**
+ * Permanent delete — an unlink, not a move to the OS trash. The daemon may be
+ * headless, remote, or inside WSL, where there is no reliable trash to move to;
+ * a "deleted" file that silently stayed on disk in one environment and vanished
+ * in another would be worse than either. The client's confirmation says so.
+ */
+export const FileDeleteRequestSchema = z.object({
+    type: z.literal("file.delete.request"),
+    cwd: z.string(),
+    path: z.string(),
+    // Required to delete a directory that has children. Absent (the default) a
+    // non-empty directory comes back as `not_empty` and nothing is removed, so a
+    // client that never asks can never recursively wipe a tree by accident.
+    recursive: z.boolean().optional(),
+    requestId: z.string(),
+});
+/**
+ * Rename and move are the same operation — a move is a rename whose new path
+ * has a different parent. Never clobbers: an occupied destination comes back as
+ * `exists` and nothing moves. There is no overwrite flag on purpose, so this
+ * RPC cannot destroy a file the user did not name.
+ */
+export const FileRenameRequestSchema = z.object({
+    type: z.literal("file.rename.request"),
+    cwd: z.string(),
+    path: z.string(),
+    newPath: z.string(),
+    requestId: z.string(),
+});
+/**
+ * Refine — an AI rewrite the user reviews as a diff before anything is written.
+ * This RPC only *proposes*: it reads nothing from disk and writes nothing. The
+ * accepted result goes back through `file.write.request` like any other save,
+ * so the conditional-write precondition still guards it.
+ *
+ * `base` travels from the client rather than being re-read on the daemon, so
+ * the model rewrites exactly the document the user is looking at and the diff
+ * they review is the diff of what they saw.
+ */
+/**
+ * One document in a refine request. `id` is opaque and client-minted; the model
+ * never sees it and the daemon only echoes it back. That is deliberate: the
+ * client maps id -> absolute path itself, so a model that mangles or invents a
+ * filename cannot misroute a write. `label` is the only path-ish thing the
+ * model sees, and it exists purely so the prompt can say which file is which.
+ */
+export const FileRefineDocumentSchema = z.object({
+    id: z.string().min(1),
+    label: z.string(),
+    content: z.string(),
+});
+/** A file the model may read for context but must never rewrite. */
+export const FileRefineReferenceSchema = z.object({
+    label: z.string(),
+    content: z.string(),
+});
+export const FileRefineRequestSchema = z.object({
+    type: z.literal("file.refine.request"),
+    // Provider resolution only — which workspace's mini-task chain runs this.
+    // Documents are NOT read from disk here; they travel on the wire.
+    cwd: z.string(),
+    // What the model may rewrite. The blast radius of the whole request: a file
+    // absent from this list cannot be changed, whatever the model returns.
+    documents: z.array(FileRefineDocumentSchema).min(1),
+    // What it may read to understand the first list. Optional so an old client
+    // that only sends documents still parses.
+    references: z.array(FileRefineReferenceSchema).optional(),
+    // The user's plain-language instruction, possibly seeded from a preset.
+    instruction: z.string(),
+    requestId: z.string(),
+});
 // Subscriptions exist only for paths open in tabs; the daemon cleans them up
 // when the session ends.
 export const FileWatchSubscribeRequestSchema = z.object({
@@ -2904,10 +3751,179 @@ export const CodeOutlineRequestSchema = z.object({
     requestId: z.string(),
 });
 /**
- * Project-wide search ("Find in Files" semantics: explicit search, not
- * per-keystroke). Results stream as file.search.result events correlated by
- * searchId (= this requestId); a new search from the same session supersedes
- * any in-flight one.
+ * LSP-backed code intelligence (projects/lsp-code-intelligence). Distinct from the
+ * ctags `code.symbols` RPC above in the only way that matters: it carries a
+ * **position**, so the daemon can resolve the reference under the cursor instead of
+ * matching a name.
+ *
+ * Line and column are **1-based** here, matching `CodeSymbolLocation` and the rest of
+ * Otto. LSP itself is 0-based; that conversion is the daemon's business and does not
+ * reach the wire.
+ */
+export const CodeDefinitionRequestSchema = z.object({
+    type: z.literal("code.definition.request"),
+    cwd: z.string(),
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    requestId: z.string(),
+});
+/**
+ * The editor's current buffer text, so definitions resolve against unsaved edits
+ * rather than stale disk content. Sent debounced, not per keystroke.
+ */
+export const CodeDocumentSyncRequestSchema = z.object({
+    type: z.literal("code.document.sync.request"),
+    cwd: z.string(),
+    path: z.string(),
+    text: z.string(),
+    requestId: z.string(),
+});
+export const CodeDocumentCloseRequestSchema = z.object({
+    type: z.literal("code.document.close.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
+/**
+ * The rest of the position-based code-intelligence family. All three carry a 1-based
+ * position like `code.definition`, and all three are answered against the mirrored
+ * buffer rather than the file on disk.
+ */
+export const CodeHoverRequestSchema = z.object({
+    type: z.literal("code.hover.request"),
+    cwd: z.string(),
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    requestId: z.string(),
+});
+export const CodeReferencesRequestSchema = z.object({
+    type: z.literal("code.references.request"),
+    cwd: z.string(),
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    requestId: z.string(),
+});
+/**
+ * A rename **dry run**. Deliberately not "do the rename": the daemon computes every edit
+ * and returns them for the user to audit, because a rename's blast radius is the whole
+ * project. Nothing is written by this request.
+ */
+export const CodeRenamePreviewRequestSchema = z.object({
+    type: z.literal("code.rename.preview.request"),
+    cwd: z.string(),
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    newName: z.string().min(1),
+    requestId: z.string(),
+});
+/**
+ * Execute a rename the user has audited. **The edits are deliberately NOT on this request.**
+ *
+ * The client sends back only the `planId` it was shown; the daemon recomputes the plan and
+ * refuses unless the identity matches. A request that carried its own edit list would be a
+ * remote arbitrary-write primitive wearing a rename's name — any client could post any text
+ * at any path. This shape makes the daemon's own language server the sole author of what
+ * gets written, and the plan id the proof that the user saw it.
+ */
+export const CodeRenameApplyRequestSchema = z.object({
+    type: z.literal("code.rename.apply.request"),
+    cwd: z.string(),
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    newName: z.string().min(1),
+    /** From the preview response. Identity of the exact plan the user approved. */
+    planId: z.string().min(1),
+    requestId: z.string(),
+});
+/**
+ * Undo a run. Carries only the run's id — the daemon holds the before-images.
+ *
+ * Declared here, with the other inbound rename schemas, rather than beside its response
+ * further down: `SessionInboundMessageSchema` is a top-level const, so a schema it names
+ * must already be initialized when that line runs. Below the union it is a
+ * ReferenceError at import time, not a type error.
+ */
+export const CodeRenameUndoRequestSchema = z.object({
+    type: z.literal("code.rename.undo.request"),
+    cwd: z.string(),
+    runId: z.string().min(1),
+    requestId: z.string(),
+});
+/**
+ * Live language-server state for the Daemon → Code screen. Separate from the daemon
+ * config RPCs because none of it is configuration: which servers this machine can
+ * actually supply, and which are running right now.
+ *
+ * `cwd` scopes the availability check — a server can be present in one workspace's
+ * `node_modules` and absent in another's.
+ */
+export const LspServersListRequestSchema = z.object({
+    type: z.literal("lsp.servers.list.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+/** Stop one running server, so a user who suspects it of hogging memory can kill it. */
+export const LspServerStopRequestSchema = z.object({
+    type: z.literal("lsp.server.stop.request"),
+    rootPath: z.string(),
+    serverId: z.string(),
+    requestId: z.string(),
+});
+/**
+ * The Solution view (projects/solution-view). A second lens on the Files module showing the tree
+ * as the build system sees it rather than as the filesystem lays it out.
+ *
+ * **Independent of the LSP family above, despite sharing the `code.` domain.** There is no
+ * project-structure request in the Language Server Protocol — not one Otto has yet to wire, one
+ * that does not exist — so this subsystem builds its own model through Microsoft's solution
+ * libraries. Turning C# code intelligence off does not turn this off, and vice versa.
+ *
+ * Discovery is separate from loading on purpose: `list` decides whether the switcher appears at
+ * all, so it runs for every workspace and must stay cheap (a directory walk, no process). Only
+ * `get_tree` reaches the .NET sidecar.
+ *
+ * COMPAT(solutionView): added in v0.6.8; gate lives in features.solutionView.
+ */
+export const CodeSolutionListRequestSchema = z.object({
+    type: z.literal("code.solution.list.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+/**
+ * One solution's organisation: folders, the projects inside them, and the configurations. No file
+ * membership — that is `load_project`, paid per project on expand, because evaluating fifty
+ * projects to render a collapsed tree is the cost this design exists to avoid.
+ */
+export const CodeSolutionGetTreeRequestSchema = z.object({
+    type: z.literal("code.solution.get_tree.request"),
+    cwd: z.string(),
+    /** Workspace-relative, as reported by `list`. */
+    solutionPath: z.string(),
+    requestId: z.string(),
+});
+/**
+ * One project's evaluated file membership. `solutionPath` scopes the sidecar instance so two
+ * solutions in one repo never share a warm `ProjectCollection` — and so Phase 4 has the selection
+ * it needs for `--solution`.
+ */
+export const CodeSolutionLoadProjectRequestSchema = z.object({
+    type: z.literal("code.solution.load_project.request"),
+    cwd: z.string(),
+    solutionPath: z.string(),
+    /** Workspace-relative, or absolute when the solution names a project outside the workspace. */
+    projectPath: z.string(),
+    requestId: z.string(),
+});
+/**
+ * Project-wide search ("Find in Files" semantics: explicit search, not
+ * per-keystroke). Results stream as file.search.result events correlated by
+ * searchId (= this requestId); a new search from the same session supersedes
+ * any in-flight one.
  */
 export const FileSearchRequestSchema = z.object({
     type: z.literal("file.search.request"),
@@ -3091,6 +4107,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     DeleteAgentRequestMessageSchema,
     ArchiveAgentRequestMessageSchema,
     CloseItemsRequestMessageSchema,
+    HistoryAgentsClearArchivedRequestSchema,
     UpdateAgentRequestMessageSchema,
     ProjectRenameRequestSchema,
     ProjectRemoveRequestSchema,
@@ -3108,6 +4125,8 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigRequestMessageSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
+    SpeechTtsSpeakRequestSchema,
+    SpeechTtsSpeakCancelRequestSchema,
     VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
     ReadProjectConfigRequestMessageSchema,
@@ -3128,6 +4147,11 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     StatsActivityGetRequestMessageSchema,
     ContextReportGetRequestMessageSchema,
     ContextEdgeConvertRequestMessageSchema,
+    ContextFindingsFixRequestMessageSchema,
+    PersonalityMemoryListRequestMessageSchema,
+    PersonalityMemoryUpdateRequestMessageSchema,
+    PersonalityMemoryTransferRequestMessageSchema,
+    PersonalityMemoryStatsRequestMessageSchema,
     StatsActivityResetRequestMessageSchema,
     UsageLogGetRequestMessageSchema,
     AgentContextGetUsageRequestMessageSchema,
@@ -3152,6 +4176,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     TasksSuggestedDismissRequestMessageSchema,
     AgentPersonalitySetRequestMessageSchema,
     AgentRewindRequestMessageSchema,
+    AgentQueueRemoveRequestMessageSchema,
+    AgentQueueReorderRequestMessageSchema,
+    AgentQueueClearRequestMessageSchema,
     AgentPermissionResponseMessageSchema,
     CheckoutStatusRequestSchema,
     SubscribeCheckoutDiffRequestSchema,
@@ -3169,6 +4196,14 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     RunsGateRespondRequestSchema,
     RunsCancelRequestSchema,
     RunsClearRequestSchema,
+    RunsDeleteRequestSchema,
+    RunsGraphsListRequestSchema,
+    RunsGraphsSaveRequestSchema,
+    RunsGraphsDeleteRequestSchema,
+    RunsTemplatesListRequestSchema,
+    RunsTemplatesSaveRequestSchema,
+    RunsTemplatesDeleteRequestSchema,
+    RunsStartRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -3203,7 +4238,14 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     LegacyOpenInEditorRequestSchema,
     OpenProjectRequestSchema,
     ProjectAddRequestSchema,
+    ProjectScaffoldRequestSchema,
+    HostingListRepositoriesRequestSchema,
+    HostingListOwnersRequestSchema,
     ArchiveWorkspaceRequestSchema,
+    WorkspaceArchivePreflightRequestSchema,
+    WorktreeBaseRefSetRequestSchema,
+    WorktreeReattachListRequestSchema,
+    WorktreeReattachRequestSchema,
     WorkspaceCreateRequestSchema,
     WorkspaceClearAttentionRequestSchema,
     FileExplorerRequestSchema,
@@ -3211,6 +4253,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     FileDownloadTokenRequestSchema,
     FileUploadRequestSchema,
     FileWriteRequestSchema,
+    FileCreateRequestSchema,
+    FileDeleteRequestSchema,
+    FileRenameRequestSchema,
+    FileRefineRequestSchema,
     FileWatchSubscribeRequestSchema,
     FileWatchUnsubscribeRequestSchema,
     FileSearchRequestSchema,
@@ -3218,6 +4264,19 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CodeListFilesRequestSchema,
     CodeSymbolsRequestSchema,
     CodeOutlineRequestSchema,
+    CodeDefinitionRequestSchema,
+    CodeDocumentSyncRequestSchema,
+    CodeDocumentCloseRequestSchema,
+    CodeHoverRequestSchema,
+    CodeReferencesRequestSchema,
+    CodeRenamePreviewRequestSchema,
+    CodeRenameApplyRequestSchema,
+    CodeRenameUndoRequestSchema,
+    LspServersListRequestSchema,
+    LspServerStopRequestSchema,
+    CodeSolutionListRequestSchema,
+    CodeSolutionGetTreeRequestSchema,
+    CodeSolutionLoadProjectRequestSchema,
     ClearAgentAttentionMessageSchema,
     ClientHeartbeatMessageSchema,
     PingMessageSchema,
@@ -3425,6 +4484,12 @@ export const ServerInfoStatusPayloadSchema = z
         projectRemove: z.boolean().optional(),
         // COMPAT(projectAdd): added in v0.1.97, drop the gate when floor >= v0.1.97.
         projectAdd: z.boolean().optional(),
+        // COMPAT(projectScaffold): added in v0.6.9, drop the gate when floor >= v0.6.9.
+        // The daemon can create a project directory from scratch (mkdir, git
+        // init/clone, optional remote creation) instead of only adopting one
+        // that already exists. Without it the New project page offers the
+        // open-an-existing-folder path only.
+        projectScaffold: z.boolean().optional(),
         // COMPAT(worktreeRestore): added in v0.1.97, drop the gate when floor >= v0.1.97
         worktreeRestore: z.boolean().optional(),
         // COMPAT(providerUsageList): added in v0.1.98, drop the gate when daemon floor >= v0.1.98.
@@ -3453,6 +4518,25 @@ export const ServerInfoStatusPayloadSchema = z
         retainedTranscripts: z.boolean().optional(),
         // COMPAT(suggestedTasks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
         suggestedTasks: z.boolean().optional(),
+        // COMPAT(steerQueue): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        // Daemon owns a per-agent queue of steering messages, accepts
+        // `delivery: "queue"` on send, reports `queuedMessages` on the agent
+        // snapshot, and serves agent.queue.remove/clear. Without it the
+        // composer keeps its own local queue — that is the pre-existing
+        // behavior, not a degraded build of this feature.
+        steerQueue: z.boolean().optional(),
+        // Daemon serves agent.queue.reorder. Separate from `steerQueue`
+        // because a daemon on 0.6.8 owns a queue but cannot re-order it;
+        // without this the move controls are absent (the queue still works).
+        // COMPAT(steerQueueReorder): added in v0.6.9, drop the gate when daemon floor >= v0.6.9.
+        steerQueueReorder: z.boolean().optional(),
+        // Daemon reports `cumulativeUsage` (the lifetime in/cached/out split
+        // plus its own booked cost) on every agent snapshot, so a chat's total
+        // spend can be summed and priced honestly. Without it the client shows
+        // token totals only and no cost — NOT an estimated cost, which is the
+        // behavior this feature exists to remove.
+        // COMPAT(cumulativeUsage): added in v0.7.0, drop the gate when daemon floor >= v0.7.0.
+        cumulativeUsage: z.boolean().optional(),
         // Daemon can resolve and evaluate the provider's context graph, serve
         // context.report.* and push context_report_changed. Without it the
         // client hides both the Context Management tab and the composer
@@ -3462,10 +4546,38 @@ export const ServerInfoStatusPayloadSchema = z
         contextManagement: z.boolean().optional(),
         // COMPAT(textEditor): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
         textEditor: z.boolean().optional(),
+        // Refine — the daemon can turn a pinned document plus an instruction
+        // into a proposed rewrite (`file.refine.*`). Without it the Refine
+        // entry is absent: there is no client-side substitute for a model, and
+        // a degraded "open a chat instead" path is exactly the unreviewed edit
+        // Refine exists to replace.
+        // COMPAT(refine): added in v0.6.9, drop the gate when daemon floor >= v0.6.9.
+        refine: z.boolean().optional(),
+        // Personality memory — the daemon stores per-personality lessons, injects
+        // them at spawn, and serves personality.memory.*. Without it the client
+        // hides the Memory tab, the accrual indicator and the transfer-on-delete
+        // choice: storage is daemon-side by definition, so there is nothing a
+        // client-side fallback could read.
+        // COMPAT(personalityMemory): added in v0.7.0, drop the gate when daemon floor >= v0.7.0.
+        personalityMemory: z.boolean().optional(),
         // COMPAT(projectSearch): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
         projectSearch: z.boolean().optional(),
         // COMPAT(codeIndex): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
         codeIndex: z.boolean().optional(),
+        // Language-server-backed definitions (`code.definition`, `code.document.*`).
+        // Separate from `codeIndex`: that gate covers the ctags path, which stays as
+        // the outline/fuzzy-finder source and the no-server fallback.
+        // COMPAT(lsp): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        lsp: z.boolean().optional(),
+        // The Solution view — the daemon can discover solutions and serve
+        // `code.solution.*`. Deliberately NOT implied by `lsp`: there is no
+        // project-structure request in LSP, so this subsystem is independent of
+        // language servers and of the C# row's on/off state. Without the flag the
+        // client never shows the view switcher and never asks — there is no
+        // client-side substitute for reading a solution, and a hand-parsed
+        // half-tree is exactly the mistake this design exists to avoid.
+        // COMPAT(solutionView): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        solutionView: z.boolean().optional(),
         // COMPAT(artifactsToolGroup): added in v0.4.5, drop the gate when daemon floor >= v0.4.5.
         artifactsToolGroup: z.boolean().optional(),
         // COMPAT(speechSettings): added in v0.4.5, drop the gate when daemon floor >= v0.4.5.
@@ -3476,6 +4588,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.
@@ -3494,6 +4609,27 @@ export const ServerInfoStatusPayloadSchema = z
         // 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 can repoint a worktree's stored base branch
+        // (worktree.baseRef.set.*). Without it the client renders the base as a
+        // read-only "vs <base>" label — there is no client-side override, since only
+        // the daemon can write the worktree's metadata.
+        // COMPAT(worktreeDiffBase): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        worktreeDiffBase: 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.
@@ -3506,6 +4642,14 @@ 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(runsDelete): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        runsDelete: z.boolean().optional(),
+        // COMPAT(runsDraftEdit): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+        // The daemon accepts `runs.start` with `draft: true` AND a `runId`,
+        // re-saving that draft in place instead of minting a second one.
+        runsDraftEdit: 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.
@@ -3561,6 +4705,22 @@ export const ServerInfoStatusPayloadSchema = z
         // counters + the itemized ledger). The client gates the Metrics screen's
         // "Reset" button on this; an old daemon simply doesn't offer it.
         statsReset: z.boolean().optional(),
+        // COMPAT(historyDelete): added in v0.7.0, drop the gate when daemon floor >= v0.7.0.
+        // Set when the daemon offers hard delete for chat records: per-row via
+        // the existing `delete_agent_request`, and in bulk via
+        // `history.agents.clear_archived`. Archive has always been a soft delete
+        // with no counterpart; this is the counterpart. Deleting removes Otto's
+        // record only — provider transcripts are never touched (see the
+        // clear_archived schema). The client hides both affordances when this is
+        // absent rather than shipping a degraded path.
+        historyDelete: z.boolean().optional(),
+        // COMPAT(fileMutations): added in v0.7.0, drop the gate when daemon floor >= v0.7.0.
+        // Set when the daemon serves `file.create`, `file.delete` and
+        // `file.rename` — creating, removing and moving entries, as opposed to
+        // `file.write`, which only changes what is inside an existing file.
+        // There is no client-side substitute (the client never touches the
+        // filesystem), so an old daemon simply does not get the menu items.
+        fileMutations: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3643,7 +4803,70 @@ export const DaemonConfigChangedStatusPayloadSchema = z
     config: MutableDaemonConfigSchema,
 })
     .passthrough();
+/**
+ * Which workspaces currently have a language server starting up or indexing. Sent as
+ * the whole busy set rather than per-workspace transitions: the only consumer is a
+ * spinner, so an idempotent snapshot cannot drift out of sync the way a missed
+ * transition would.
+ *
+ * Separate from the workspace status bucket on purpose — indexing is not the workspace
+ * "working", and folding it in would mislabel a quiet workspace as busy with agent work.
+ */
+export const LspActivityChangedStatusPayloadSchema = z
+    .object({
+    status: z.literal("lsp_activity_changed"),
+    /** Absolute workspace roots with language-server work in flight. */
+    busyRoots: z.array(z.string()),
+})
+    .passthrough();
+/**
+ * Compiler severity, named rather than numbered. LSP uses 1–4; a magic number on the
+ * wire would have every consumer re-deriving which one is a warning.
+ */
+export const CodeDiagnosticSeveritySchema = z.enum(["error", "warning", "info", "hint"]);
+/** One problem the language server reported, 1-based like every other position. */
+export const CodeDiagnosticSchema = z.object({
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    endLine: z.number().int().positive(),
+    endColumn: z.number().int().positive(),
+    severity: CodeDiagnosticSeveritySchema,
+    message: z.string(),
+    /** Who says so — `ts`, `pyright`, a linter behind the server. */
+    source: z.string().optional(),
+    /** The server's own code for the rule or error, e.g. TypeScript's `2345`. */
+    code: z.string().optional(),
+    /** Documentation for that rule, when the server offers one — oxlint does. */
+    codeHref: z.string().optional(),
+    /** Which registry row published it, so two servers on one file stay attributable. */
+    serverId: z.string().optional(),
+});
+/**
+ * Diagnostics for one open document, pushed unsolicited.
+ *
+ * This is the one part of code intelligence that is not request/response:
+ * `textDocument/publishDiagnostics` arrives whenever the server has recomputed, which is
+ * whenever it feels like it. So it is a status broadcast, and the payload is the document's
+ * **whole** current set — never a delta. A missed delta would leave a stale squiggle on a
+ * line the user already fixed, and an idempotent snapshot cannot drift.
+ *
+ * Only documents a client has synced produce these. A server may know about every file in
+ * the project; pushing all of it would be unbounded, and nothing can render a marker in a
+ * file that is not open.
+ */
+export const LspDiagnosticsChangedStatusPayloadSchema = z
+    .object({
+    status: z.literal("lsp_diagnostics_changed"),
+    /** Workspace root the document belongs to. */
+    cwd: z.string(),
+    /** Absolute path of the document these describe. */
+    path: z.string(),
+    diagnostics: z.array(CodeDiagnosticSchema),
+})
+    .passthrough();
 export const KnownStatusPayloadSchema = z.discriminatedUnion("status", [
+    LspActivityChangedStatusPayloadSchema,
+    LspDiagnosticsChangedStatusPayloadSchema,
     AgentCreatedStatusPayloadSchema,
     AgentCreateFailedStatusPayloadSchema,
     AgentResumedStatusPayloadSchema,
@@ -3968,6 +5191,22 @@ export const WorkspaceUpdateMessageSchema = z.object({
         }),
     ]),
 });
+// A project's own metadata changed (today: the user renamed it). The workspace
+// channel can only carry a project's name inside its workspaces' descriptors, so
+// a project with no active workspaces had no live channel at all — its name only
+// refreshed on the next full workspace fetch. This is the project-level channel:
+// it fires whether or not the project currently has workspaces, and the daemon
+// fans it out to every connected session because project metadata is host-global.
+export const ProjectUpdatedNotificationSchema = z.object({
+    type: z.literal("project.updated.notification"),
+    payload: z.object({
+        project: WorkspaceProjectDescriptorPayloadSchema,
+        // False means the project has no active workspaces right now, so the client
+        // keeps it in the empty-project bucket instead of expecting a workspace
+        // descriptor to carry its name.
+        hasActiveWorkspaces: z.boolean(),
+    }),
+});
 export const ScriptStatusUpdateMessageSchema = z.object({
     type: z.literal("script_status_update"),
     payload: z.object({
@@ -4016,6 +5255,89 @@ export const ProjectAddResponseSchema = z.object({
         errorCode: z.enum(["directory_not_found"]).nullish().catch(null),
     }),
 });
+// COMPAT(projectScaffold): added in v0.6.9.
+export const ProjectScaffoldResponseSchema = z.object({
+    type: z.literal("project.scaffold.response"),
+    payload: z.object({
+        requestId: z.string(),
+        // Registered project on success. Null whenever any step failed — the
+        // daemon does not register a half-built directory.
+        project: WorkspaceProjectDescriptorPayloadSchema.nullable(),
+        // Absolute path of the created directory. Non-null even on a late failure
+        // (e.g. push rejected) so the UI can tell the user what is on disk.
+        path: z.string().nullable(),
+        // Remote the repo was wired to, when one was created or cloned from.
+        remoteUrl: z.string().nullable(),
+        error: z.string().nullable(),
+        // Unknown codes from newer daemons degrade to null; clients fall back to `error`.
+        errorCode: z
+            .enum([
+            "parent_not_found",
+            "invalid_name",
+            "already_exists",
+            "git_unavailable",
+            "git_failed",
+            "provider_unavailable",
+            "remote_failed",
+            "clone_failed",
+            "register_failed",
+        ])
+            .nullish()
+            .catch(null),
+        // Terminal state of every step the daemon ran, in run order.
+        steps: z.array(ProjectScaffoldStepSchema),
+    }),
+});
+// Uncorrelated progress stream for an in-flight scaffold, keyed by the request's
+// requestId. Purely advisory: the response carries the authoritative step list,
+// so a client that ignores these still gets a correct result.
+export const ProjectScaffoldProgressSchema = z.object({
+    type: z.literal("project.scaffold.progress"),
+    payload: z.object({
+        requestId: z.string(),
+        step: ProjectScaffoldStepIdSchema,
+        status: ProjectScaffoldStepStatusSchema,
+        detail: z.string().nullable(),
+    }),
+});
+export const HostingRepositorySummarySchema = z.object({
+    // Provider-unique identifier, e.g. "owner/name" or "workspace/slug".
+    fullName: z.string(),
+    name: z.string(),
+    owner: z.string(),
+    cloneUrl: z.string(),
+    isPrivate: z.boolean(),
+    description: z.string().nullable(),
+    // ISO-8601. Clients sort most-recent-first when present.
+    updatedAt: z.string().nullable(),
+});
+export const HostingOwnerSummarySchema = z.object({
+    // Value to send back as `owner` when creating a repository.
+    id: z.string(),
+    label: z.string(),
+    // Open string: providers name this differently (org, workspace, team).
+    kind: z.string(),
+});
+// COMPAT(projectScaffold): added in v0.6.9.
+export const HostingListRepositoriesResponseSchema = z.object({
+    type: z.literal("hosting.list_repositories.response"),
+    payload: z.object({
+        requestId: z.string(),
+        provider: GitHostingProviderIdWireSchema,
+        repositories: z.array(HostingRepositorySummarySchema),
+        error: z.string().nullable(),
+    }),
+});
+// COMPAT(projectScaffold): added in v0.6.9.
+export const HostingListOwnersResponseSchema = z.object({
+    type: z.literal("hosting.list_owners.response"),
+    payload: z.object({
+        requestId: z.string(),
+        provider: GitHostingProviderIdWireSchema,
+        owners: z.array(HostingOwnerSummarySchema),
+        error: z.string().nullable(),
+    }),
+});
 export const StartWorkspaceScriptResponseMessageSchema = z.object({
     type: z.literal("start_workspace_script_response"),
     payload: z.object({
@@ -4052,6 +5374,92 @@ 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(),
+    }),
+});
+// COMPAT(worktreeDiffBase): added in v0.6.8.
+export const WorktreeBaseRefSetResponseSchema = z.object({
+    type: z.literal("worktree.baseRef.set.response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        // The stored base branch after the write; null when the write failed.
+        baseRef: z.string().nullable(),
+        // The stored base is the repository default branch (no stacked-branch override).
+        isDefault: z.boolean(),
+        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({
@@ -4112,6 +5520,52 @@ export const AgentForkContextResponseMessageSchema = z.object({
         error: z.string().nullable(),
     }),
 });
+export const AgentQueueRemoveResponseMessageSchema = z.object({
+    type: z.literal("agent.queue.remove.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        /**
+         * The removed message's text, handed back so the composer can put it back
+         * in the box for editing or re-send it right away. Null when the id was
+         * already gone — the turn drained it while the tap was in flight.
+         * Attachments are not echoed: the client that queued the message keeps its
+         * own local copy keyed by `id` (see the composer's queued-attachment
+         * sidecar), and a client that never queued it has nothing to restore.
+         */
+        removed: z
+            .object({
+            id: z.string(),
+            text: z.string(),
+        })
+            .nullable(),
+        error: z.string().nullable(),
+    }),
+});
+export const AgentQueueReorderResponseMessageSchema = z.object({
+    type: z.literal("agent.queue.reorder.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        /**
+         * False when the id was already gone (the turn drained it while the tap was
+         * in flight) or the entry was already at that position. The authoritative
+         * order arrives on the agent snapshot either way, so a client only needs
+         * this to decide whether to surface an error.
+         */
+        moved: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const AgentQueueClearResponseMessageSchema = z.object({
+    type: z.literal("agent.queue.clear.response"),
+    payload: z.object({
+        requestId: z.string(),
+        agentId: z.string(),
+        clearedCount: z.number().int().nonnegative(),
+        error: z.string().nullable(),
+    }),
+});
 export const CancelAgentResponseMessageSchema = z.object({
     type: z.literal("cancel_agent_response"),
     payload: z.object({
@@ -4166,6 +5620,13 @@ export const SendAgentMessageResponseMessageSchema = z.object({
         agentId: z.string(),
         accepted: z.boolean(),
         error: z.string().nullable(),
+        // Set when the message was parked for the next turn rather than dispatched
+        // (`delivery: "queue"` against a busy agent). `queuedMessageId` is the
+        // entry's id in `AgentSnapshotPayload.queuedMessages` — the key the sender
+        // uses to find its own entry again. Absent ⇒ dispatched now (or old daemon).
+        // COMPAT(steerQueue): added in v0.6.8, drop the gate when floor >= v0.6.8.
+        queued: z.boolean().optional(),
+        queuedMessageId: z.string().optional(),
     }),
 });
 export const WaitForFinishResponseMessageSchema = z.object({
@@ -4243,6 +5704,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
@@ -4417,6 +5895,12 @@ const CheckoutStatusCommonSchema = z.object({
     cwd: z.string(),
     error: CheckoutErrorSchema.nullable(),
     requestId: z.string(),
+    // Daemon clock (epoch ms) at which the git-tracking fields below were measured.
+    // One writer stamps it, so clients can compare two payloads and drop an
+    // out-of-order push instead of clobbering newer git state.
+    // COMPAT(checkoutStatusGitStateAt): added in v0.6.8; absent from older daemons.
+    // Drop the optional marker when floor >= v0.6.8 (target 2027-01-24).
+    gitStateAt: z.number().optional(),
 });
 const CheckoutStatusNotGitSchema = CheckoutStatusCommonSchema.extend({
     isGit: z.literal(false),
@@ -4573,6 +6057,12 @@ const CheckoutPrStatusPayloadSchema = z.object({
 });
 const CheckoutStatusUpdateMetadataSchema = z.object({
     prStatus: CheckoutPrStatusPayloadSchema.optional(),
+    // True when the push refreshed only PR/check state (the hosting PR-status poll).
+    // The git block on such a payload is an unrefreshed echo of the last snapshot,
+    // so clients must apply `prStatus` and leave their git-tracking state alone.
+    // COMPAT(checkoutStatusPrStatusOnly): added in v0.6.8; absent from older daemons.
+    // Drop the default when floor >= v0.6.8 (target 2027-01-24).
+    prStatusOnly: z.boolean().optional().default(false),
 });
 export const CheckoutStatusUpdateSchema = z.object({
     type: z.literal("checkout_status_update"),
@@ -5343,6 +6833,110 @@ export const FileWriteResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+/**
+ * Create outcome. `exists` is its own status rather than an error string: it is
+ * the one failure the client can act on (offer a different name) instead of
+ * merely reporting.
+ */
+export const FileCreateResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        // Echoed back normalized (forward slashes, workspace-relative) so the client
+        // selects the entry it will actually see in the next listing.
+        path: z.string(),
+        kind: FileEntryKindSchema,
+        modifiedAt: z.string(),
+        size: z.number(),
+    }),
+    z.object({ status: z.literal("exists") }),
+    z.object({ status: z.literal("error"), message: z.string() }),
+]);
+export const FileCreateResponseSchema = z.object({
+    type: z.literal("file.create.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        result: FileCreateResultSchema,
+        requestId: z.string(),
+    }),
+});
+/**
+ * Delete outcome. `not_empty` means the target is a directory with children and
+ * the request did not set `recursive` — nothing was removed, and the client can
+ * re-ask with the stronger confirmation.
+ */
+export const FileDeleteResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        path: z.string(),
+        kind: FileEntryKindSchema,
+    }),
+    z.object({ status: z.literal("not_found") }),
+    z.object({ status: z.literal("not_empty") }),
+    z.object({ status: z.literal("error"), message: z.string() }),
+]);
+export const FileDeleteResponseSchema = z.object({
+    type: z.literal("file.delete.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        result: FileDeleteResultSchema,
+        requestId: z.string(),
+    }),
+});
+/** Rename/move outcome. `exists` means the destination was occupied; nothing moved. */
+export const FileRenameResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        from: z.string(),
+        to: z.string(),
+        kind: FileEntryKindSchema,
+    }),
+    z.object({ status: z.literal("not_found") }),
+    z.object({ status: z.literal("exists") }),
+    z.object({ status: z.literal("error"), message: z.string() }),
+]);
+export const FileRenameResponseSchema = z.object({
+    type: z.literal("file.rename.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        newPath: z.string(),
+        result: FileRenameResultSchema,
+        requestId: z.string(),
+    }),
+});
+/**
+ * A refine proposal: the whole rewritten text of each document the model chose
+ * to change, keyed by the id the request minted. Documents it left alone are
+ * simply absent, and ids the request never sent are dropped by the daemon.
+ *
+ * The client diffs each one against the base it pinned, so a truncated or
+ * chatty answer shows up as a diff the user can refuse rather than as a
+ * corrupted file.
+ */
+export const FileRefineFileSchema = z.object({
+    id: z.string().min(1),
+    content: z.string(),
+});
+export const FileRefineResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ok"),
+        files: z.array(FileRefineFileSchema),
+    }),
+    z.object({
+        status: z.literal("error"),
+        message: z.string(),
+    }),
+]);
+export const FileRefineResponseSchema = z.object({
+    type: z.literal("file.refine.response"),
+    payload: z.object({
+        cwd: z.string(),
+        result: FileRefineResultSchema,
+        requestId: z.string(),
+    }),
+});
 export const FileWatchSubscribeResponseSchema = z.object({
     type: z.literal("file.watch.subscribe.response"),
     payload: z.object({
@@ -5391,6 +6985,370 @@ export const CodeSymbolsResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+/** 1-based, like `CodeSymbolLocation`. The end pair is present when the server gave a range. */
+export const CodeDefinitionLocationSchema = z.object({
+    path: z.string(),
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    endLine: z.number().int().positive().optional(),
+    endColumn: z.number().int().positive().optional(),
+    /**
+     * Which registry row answered (`typescript`, `csharp`, …). The multi-hit picker
+     * shows it, so a user looking at two candidates can tell whether a language server
+     * resolved them or the name index guessed — which changes how much to trust the
+     * list. Absent from old daemons.
+     */
+    serverId: z.string().optional(),
+});
+/**
+ * Three-valued on purpose. `unavailable` (no server for this language on the host) and
+ * `indexing` (the server is up but still building its project model) are different
+ * answers to the user, and neither is "not found" — reporting either as an empty
+ * result is how a working feature reads as broken.
+ */
+export const CodeDefinitionStatusSchema = z.enum(["ok", "indexing", "unavailable"]);
+export const CodeDefinitionResponseSchema = z.object({
+    type: z.literal("code.definition.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        status: CodeDefinitionStatusSchema,
+        locations: z.array(CodeDefinitionLocationSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeDocumentSyncResponseSchema = z.object({
+    type: z.literal("code.document.sync.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeDocumentCloseResponseSchema = z.object({
+    type: z.literal("code.document.close.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/** 1-based, like every other position on the wire. */
+export const CodeHoverRangeSchema = z.object({
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    endLine: z.number().int().positive(),
+    endColumn: z.number().int().positive(),
+});
+export const CodeHoverResponseSchema = z.object({
+    type: z.literal("code.hover.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        status: CodeDefinitionStatusSchema,
+        /** Markdown, or null when the server had nothing to say about this position. */
+        markdown: z.string().nullable(),
+        range: CodeHoverRangeSchema.nullable(),
+        serverId: z.string().nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeReferencesResponseSchema = z.object({
+    type: z.literal("code.references.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        status: CodeDefinitionStatusSchema,
+        locations: z.array(CodeDefinitionLocationSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeRenameEditSchema = z.object({
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    endLine: z.number().int().positive(),
+    endColumn: z.number().int().positive(),
+    newText: z.string(),
+    /**
+     * The text this edit expects to replace. Carried so the dry run can show what is being
+     * changed rather than only what it becomes — and, on the daemon side, so the run can tell
+     * that a file moved under the plan. For a rename this is always one identifier.
+     */
+    oldText: z.string().default(""),
+});
+export const CodeRenameFilePlanSchema = z.object({
+    path: z.string(),
+    edits: z.array(CodeRenameEditSchema),
+});
+export const CodeRenamePreviewResponseSchema = z.object({
+    type: z.literal("code.rename.preview.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        newName: z.string(),
+        status: CodeDefinitionStatusSchema,
+        /** Sorted by path, and by position within each file, so an audit reads in order. */
+        files: z.array(CodeRenameFilePlanSchema),
+        /** Blast radius, so the dry-run tab can lead with it. */
+        fileCount: z.number().int().nonnegative(),
+        editCount: z.number().int().nonnegative(),
+        /**
+         * Identity of this exact plan, echoed back on apply. Computed by the daemon so there is
+         * one definition of "the same plan" rather than two that can drift apart.
+         */
+        planId: z.string().default(""),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Five-valued, because the ways a rename can fail to happen are things a user needs told
+ * apart: still loading, no server, the plan moved, or the server pointed outside the
+ * workspace. Collapsing them into one failure is how "nothing happened" becomes unexplainable.
+ */
+/**
+ * Whether the run HAPPENED — deliberately not whether everything applied.
+ *
+ * A run where two of fourteen edits no longer fit is still a run that took place, and the
+ * twelve that landed are real. Collapsing that into a failure would hide them, and hiding a
+ * write is the one thing an auditable edit surface must never do. Per-edit fate lives in the
+ * file outcomes; `complete` is the single-glance answer.
+ */
+export const CodeRenameApplyStatusSchema = z.enum(["ok", "expired", "escaped"]);
+export const CodeRenameFileOutcomeKindSchema = z.enum(["applied", "partial", "failed"]);
+/** What happened to one file in a run. */
+export const CodeRenameFileOutcomeSchema = z.object({
+    path: z.string(),
+    kind: CodeRenameFileOutcomeKindSchema,
+    appliedEdits: z.number().int().nonnegative(),
+    skippedEdits: z.number().int().nonnegative(),
+    /** Why, whenever anything was skipped or the file failed outright. */
+    reason: z.string().nullable(),
+});
+export const CodeRenameUndoStatusSchema = z.enum(["ok", "expired"]);
+export const CodeRenameUndoFileKindSchema = z.enum(["restored", "changedSince", "failed"]);
+/**
+ * What happened to one file during an undo. `changedSince` is the important one: the file was
+ * edited after the run, so restoring would have destroyed that work and it was left alone.
+ */
+export const CodeRenameUndoFileSchema = z.object({
+    path: z.string(),
+    kind: CodeRenameUndoFileKindSchema,
+    reason: z.string().nullable(),
+});
+export const CodeRenameUndoResponseSchema = z.object({
+    type: z.literal("code.rename.undo.response"),
+    payload: z.object({
+        cwd: z.string(),
+        runId: z.string(),
+        status: CodeRenameUndoStatusSchema,
+        files: z.array(CodeRenameUndoFileSchema),
+        restoredFiles: z.number().int().nonnegative(),
+        /** True only when every file the run wrote was put back. */
+        complete: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CodeRenameApplyResponseSchema = z.object({
+    type: z.literal("code.rename.apply.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        newName: z.string(),
+        status: CodeRenameApplyStatusSchema,
+        /** Identity of this run, for undo. Null when nothing ran. */
+        runId: z.string().nullable(),
+        files: z.array(CodeRenameFileOutcomeSchema),
+        appliedFiles: z.number().int().nonnegative(),
+        appliedEdits: z.number().int().nonnegative(),
+        skippedEdits: z.number().int().nonnegative(),
+        /** True only when every planned edit landed. */
+        complete: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const LspLanguageStateSchema = z.object({
+    id: z.string(),
+    enabled: z.boolean(),
+    /** Whether the host can actually supply this server right now. */
+    installed: z.boolean(),
+    running: z.boolean(),
+    /** Which discovery rung supplied it (`workspaceBin` / `bundled` / `path`), or null. */
+    rung: z.string().nullable(),
+    bin: z.string(),
+    extensions: z.array(z.string()),
+    /** Plain-words index cost, so the toggle states its own price. */
+    indexCost: z.string(),
+});
+export const LspRunningServerSchema = z.object({
+    rootPath: z.string(),
+    serverId: z.string(),
+    uptimeMs: z.number(),
+    lastUsedAt: z.number(),
+});
+export const LspServersListResponseSchema = z.object({
+    type: z.literal("lsp.servers.list.response"),
+    payload: z.object({
+        cwd: z.string(),
+        languages: z.array(LspLanguageStateSchema),
+        running: z.array(LspRunningServerSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const LspServerStopResponseSchema = z.object({
+    type: z.literal("lsp.server.stop.response"),
+    payload: z.object({
+        rootPath: z.string(),
+        serverId: z.string(),
+        ok: z.boolean(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Solution view responses (projects/solution-view).
+ *
+ * COMPAT(solutionView): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
+ */
+export const SolutionFormatSchema = z.enum(["sln", "slnx"]);
+/** One solution a workspace contains. Enough to populate the switcher's picker, nothing more. */
+export const SolutionRefSchema = z.object({
+    /** Workspace-relative, forward slashes — the identity used by every later request. */
+    path: z.string(),
+    /** File name without the extension, which is what a .NET developer calls the solution. */
+    name: z.string(),
+    format: SolutionFormatSchema,
+});
+export const CodeSolutionListResponseSchema = z.object({
+    type: z.literal("code.solution.list.response"),
+    payload: z.object({
+        cwd: z.string(),
+        /**
+         * Empty means the switcher never appears and the Files tab behaves exactly as it does today.
+         * That is also what a disabled feature, a host with no .NET SDK, and a workspace with no
+         * solution all return — the client has one silent case to handle, not four.
+         */
+        solutions: z.array(SolutionRefSchema),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Solution structure is flat on the wire with parent links, not nested.
+ *
+ * A recursive payload would have to be walked to be used, and every consumer would write that
+ * walk again; the file explorer already turns a flat listing plus an expanded-path set into rows,
+ * so this hands it the same shape it already consumes.
+ */
+export const SolutionTreeFolderSchema = z.object({
+    /** Solution-internal, e.g. `/Src/`. Folders are virtual: they have no filesystem location. */
+    path: z.string(),
+    name: z.string(),
+    parentPath: z.string().nullable(),
+});
+export const SolutionTreeProjectSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    /**
+     * Workspace-relative when the project sits inside the workspace, absolute (forward-slashed)
+     * when it does not. `outsideWorkspace` says which, so nothing has to guess by inspecting the
+     * string.
+     */
+    path: z.string(),
+    /**
+     * A project the solution names outside the workspace root. Shown and opened like any other —
+     * the solution file is the authority naming it, so this is not free browsing — but editing one
+     * warns, and it is absent from every git surface. See docs/solution-view.md.
+     */
+    outsideWorkspace: z.boolean(),
+    /** The solution folder containing it, or null for a project at the solution root. */
+    folderPath: z.string().nullable(),
+    /** Project type GUID, lowercased. Absent on old daemons. */
+    typeId: z.string().optional(),
+});
+export const CodeSolutionGetTreeResponseSchema = z.object({
+    type: z.literal("code.solution.get_tree.response"),
+    payload: z.object({
+        cwd: z.string(),
+        solutionPath: z.string(),
+        name: z.string().default(""),
+        format: SolutionFormatSchema.default("sln"),
+        folders: z.array(SolutionTreeFolderSchema),
+        projects: z.array(SolutionTreeProjectSchema),
+        /** Solution configurations and platforms — first-class .NET concepts no CLI surfaces. */
+        buildTypes: z.array(z.string()),
+        platforms: z.array(z.string()),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Three-valued for the same reason the code-intelligence family is: "the host cannot supply
+ * this", "MSBuild refused this project", and "here are its files" are different things to tell a
+ * user, and reporting the first two as an empty file list is how a working feature reads as
+ * broken. One project that fails must not blank the tree, so this status is per project.
+ */
+export const SolutionProjectStatusSchema = z.enum(["ok", "failed", "unavailable"]);
+/**
+ * One entry in a project's evaluated membership, flat with parent links like the folders above.
+ *
+ * `isImplicit` is what a filesystem tree structurally cannot show and what Phase 2 turns on: an
+ * item contributed by the SDK's default globs is one that creating the file already adds, while
+ * an item the project file itself declares needs a real `.csproj` edit.
+ */
+export const SolutionProjectNodeSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("directory"),
+        id: z.string(),
+        parentId: z.string().nullable(),
+        name: z.string(),
+        path: z.string(),
+        outsideWorkspace: z.boolean(),
+    }),
+    z.object({
+        kind: z.literal("file"),
+        id: z.string(),
+        parentId: z.string().nullable(),
+        name: z.string(),
+        path: z.string(),
+        outsideWorkspace: z.boolean(),
+        /** `Compile`, `Content`, `EmbeddedResource`, … — MSBuild's own item type. */
+        itemType: z.string(),
+        isImplicit: z.boolean(),
+    }),
+]);
+export const SolutionPackageReferenceSchema = z.object({
+    name: z.string(),
+    version: z.string().nullable(),
+});
+export const CodeSolutionLoadProjectResponseSchema = z.object({
+    type: z.literal("code.solution.load_project.response"),
+    payload: z.object({
+        cwd: z.string(),
+        solutionPath: z.string(),
+        projectPath: z.string(),
+        status: SolutionProjectStatusSchema,
+        nodes: z.array(SolutionProjectNodeSchema),
+        projectReferences: z.array(z.string()),
+        packageReferences: z.array(SolutionPackageReferenceSchema),
+        targetFrameworks: z.array(z.string()),
+        outputType: z.string().nullable(),
+        isSdkStyle: z.boolean(),
+        /** MSBuild's own message when `status` is `failed`, verbatim. */
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
 export const CodeOutlineResponseSchema = z.object({
     type: z.literal("code.outline.response"),
     payload: z.object({
@@ -5819,11 +7777,17 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     FetchRecentProviderSessionsResponseMessageSchema,
     FetchWorkspacesResponseMessageSchema,
     ProjectAddResponseSchema,
+    ProjectScaffoldResponseSchema,
+    ProjectScaffoldProgressSchema,
     OpenProjectResponseMessageSchema,
     StartWorkspaceScriptResponseMessageSchema,
     LegacyListAvailableEditorsResponseMessageSchema,
     LegacyOpenInEditorResponseMessageSchema,
     ArchiveWorkspaceResponseMessageSchema,
+    WorkspaceArchivePreflightResponseSchema,
+    WorktreeBaseRefSetResponseSchema,
+    WorktreeReattachListResponseSchema,
+    WorktreeReattachResponseSchema,
     FetchAgentResponseMessageSchema,
     FetchAgentTimelineResponseMessageSchema,
     AgentForkContextResponseMessageSchema,
@@ -5840,6 +7804,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigResponseMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
+    SpeechTtsSpeakResponseSchema,
+    SpeechTtsSpeakCancelResponseSchema,
     VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
     ReadProjectConfigResponseMessageSchema,
@@ -5849,6 +7815,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentThinkingResponseMessageSchema,
     SetAgentFeatureResponseMessageSchema,
     AgentDetachResponseMessageSchema,
+    AgentQueueRemoveResponseMessageSchema,
+    AgentQueueReorderResponseMessageSchema,
+    AgentQueueClearResponseMessageSchema,
     AgentSubagentStopResponseMessageSchema,
     AgentBackgroundTaskStopResponseMessageSchema,
     AgentBackgroundTaskClearResponseMessageSchema,
@@ -5861,6 +7830,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     AgentRewindResponseMessageSchema,
     UpdateAgentResponseMessageSchema,
     ProjectRenameResponseSchema,
+    ProjectUpdatedNotificationSchema,
     ProjectRemoveResponseSchema,
     ProjectLinksListResponseSchema,
     ProjectLinksSetResponseSchema,
@@ -5871,6 +7841,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     AgentPermissionRequestMessageSchema,
     AgentPermissionResolvedMessageSchema,
     AgentDeletedMessageSchema,
+    HistoryAgentsClearArchivedResponseSchema,
     AgentArchivedMessageSchema,
     CloseItemsResponseSchema,
     CheckoutStatusResponseSchema,
@@ -5892,7 +7863,17 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     RunsGateRespondResponseSchema,
     RunsCancelResponseSchema,
     RunsClearResponseSchema,
+    RunsDeleteResponseSchema,
     RunsClearedNotificationSchema,
+    RunsGraphsListResponseSchema,
+    RunsGraphsSaveResponseSchema,
+    RunsGraphsDeleteResponseSchema,
+    RunsGraphsChangedNotificationSchema,
+    RunsTemplatesListResponseSchema,
+    RunsTemplatesSaveResponseSchema,
+    RunsTemplatesDeleteResponseSchema,
+    RunsTemplatesChangedNotificationSchema,
+    RunsStartResponseSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,
@@ -5918,6 +7899,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     GitHubSearchResponseSchema,
     HostingSearchResponseSchema,
     HostingAuthStatusResponseSchema,
+    HostingListRepositoriesResponseSchema,
+    HostingListOwnersResponseSchema,
     DirectorySuggestionsResponseSchema,
     OttoWorktreeListResponseSchema,
     OttoWorktreeArchiveResponseSchema,
@@ -5927,6 +7910,10 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     FileDownloadTokenResponseSchema,
     FileUploadResponseSchema,
     FileWriteResponseSchema,
+    FileCreateResponseSchema,
+    FileDeleteResponseSchema,
+    FileRenameResponseSchema,
+    FileRefineResponseSchema,
     FileWatchSubscribeResponseSchema,
     FileWatchUnsubscribeResponseSchema,
     FileWatchEventSchema,
@@ -5936,6 +7923,19 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CodeListFilesResponseSchema,
     CodeSymbolsResponseSchema,
     CodeOutlineResponseSchema,
+    CodeDefinitionResponseSchema,
+    CodeDocumentSyncResponseSchema,
+    CodeDocumentCloseResponseSchema,
+    CodeHoverResponseSchema,
+    CodeReferencesResponseSchema,
+    CodeRenamePreviewResponseSchema,
+    CodeRenameApplyResponseSchema,
+    CodeRenameUndoResponseSchema,
+    LspServersListResponseSchema,
+    LspServerStopResponseSchema,
+    CodeSolutionListResponseSchema,
+    CodeSolutionGetTreeResponseSchema,
+    CodeSolutionLoadProjectResponseSchema,
     ListProviderModelsResponseMessageSchema,
     ListProviderModesResponseMessageSchema,
     ListProviderFeaturesResponseMessageSchema,
@@ -5948,6 +7948,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     StatsActivityGetResponseMessageSchema,
     ContextReportGetResponseMessageSchema,
     ContextEdgeConvertResponseMessageSchema,
+    ContextFindingsFixResponseMessageSchema,
+    PersonalityMemoryListResponseMessageSchema,
+    PersonalityMemoryUpdateResponseMessageSchema,
+    PersonalityMemoryTransferResponseMessageSchema,
+    PersonalityMemoryStatsResponseMessageSchema,
     StatsActivityResetResponseMessageSchema,
     UsageLogGetResponseMessageSchema,
     ActivityStatsChangedSchema,