@otto-code/protocol 0.7.5 → 0.8.0

package/dist/messages.js

@@ -51,7 +51,7 @@ const MutableMetadataGenerationConfigSchema = z
     // true preserves today's behavior. Read by the generation path (WP-B).
     enabled: z.boolean().default(true),
     // When true, metadata generation prefers a role-matched Writer personality
-    // over the cheap default tier. Default false — cheap-tier routing is the
+    // over the cheap default tier. Default false - cheap-tier routing is the
     // default. Read by the generation routing (WP-B).
     preferWriterPersonalities: z.boolean().default(false),
 })
@@ -97,11 +97,11 @@ const MutableBrowserToolsConfigSchema = z
     .passthrough();
 /**
  * Language-server code intelligence, host-scoped because the servers are processes
- * on the daemon's machine — they follow the host, not the client.
+ * 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
+ * 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.
  *
@@ -121,16 +121,16 @@ const MutableLspConfigSchema = z
 })
     .passthrough();
 /**
- * "Microsoft .NET Solution Management" — the Solution view's own switch.
+ * "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
+ * 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,
+ * 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.
  */
@@ -214,26 +214,26 @@ export const MutableGitHostingConfigSchema = z
     .passthrough();
 // Canonical personality roles, in display order. Kept as an exported const so
 // the daemon and app share one vocabulary, but the wire schema stores roles as
-// plain strings (below) — adding a role later must never break an older peer's
+// plain strings (below) - adding a role later must never break an older peer's
 // parsing. Consumers filter incoming role arrays to this known set. The retired
 // "worker" role is mapped to "coder" on the way in (see LEGACY_ROLE_ALIASES in
 // agent-personalities.ts) so personalities persisted before the split keep their
 // role rather than silently losing it.
 export const PERSONALITY_ROLES = [
-    // Surfaces — the interactive / host-facing entry points.
+    // Surfaces - the interactive / host-facing entry points.
     "chatter",
     "artificer",
     "scheduler",
-    // Thinking workers — read-only, return structured findings, never edit.
+    // Thinking workers - read-only, return structured findings, never edit.
     "researcher",
     "planner",
     "judger",
     "advisor",
-    // Making workers — produce code, design, or short text.
+    // Making workers - produce code, design, or short text.
     "coder",
     "designer",
     "writer",
-    // Conductor — the sole role whose whole job is planning and driving a team.
+    // Conductor - the sole role whose whole job is planning and driving a team.
     "orchestrator",
 ];
 // Two glow colors for the personality's thinking spinner (BlobLoader glowA/glowB).
@@ -243,8 +243,8 @@ const AgentPersonalitySpinnerSchema = z
     glowB: z.string().min(1),
 })
     .passthrough();
-// A TTS voice for the personality's spoken identity. Stored self-describing —
-// provider + model + voice name — because voice names are namespaced per TTS
+// A TTS voice for the personality's spoken identity. Stored self-describing -
+// provider + model + voice name - because voice names are namespaced per TTS
 // engine/model (the same speaker index maps to different names across models),
 // so a bare name is ambiguous across hosts. All plain strings (like the speech
 // config) for forward-compat. This is a soft binding: an unavailable voice
@@ -258,17 +258,17 @@ const AgentPersonalityVoiceSchema = z
 })
     .passthrough();
 // The Visualizer lifecycle moments a personality voice-cue line can belong to.
-// Protocol owns this vocabulary — the daemon's cue generator, the personality
+// Protocol owns this vocabulary - the daemon's cue generator, the personality
 // editor, and the Visualizer playback hook all import it from here.
 // "waiting" is the parent's turn ending while its observed sub-agents are still
 // running; it DEFERS "done" rather than replacing it (see docs/visualizer.md).
 export const CUE_MOMENTS = ["join", "thinking", "waiting", "done"];
 // Pre-generated (and user-editable) spoken "voice cue" lines for the personality
-// — a few short variations for each Visualizer moment (its node joins the graph,
+// - a few short variations for each Visualizer moment (its node joins the graph,
 // first starts thinking, finishes its turn but waits on sub-agents, completes).
 // Stored on the personality so they're deterministic and hand-tunable in the
 // editor; the Visualizer reads them directly (no runtime generation). All groups
-// optional/loose — a personality may have none, or only some (personalities
+// optional/loose - a personality may have none, or only some (personalities
 // authored before "waiting" existed simply stay silent for that moment).
 // See docs/visualizer.md "Voice cues".
 const AgentPersonalityVoiceCuesSchema = z
@@ -326,7 +326,7 @@ const MutableAgentPersonalitiesConfigPatchSchema = z
 })
     .passthrough();
 // A team's avatar. v1 ships only `color` (hex, validated at the editor like
-// spinner colors); `imageId` is reserved for the future themed avatar set —
+// spinner colors); `imageId` is reserved for the future themed avatar set -
 // when present it wins over color, and color stays the fallback so an old
 // client that doesn't know `imageId` keeps rendering the swatch. Plain
 // strings for forward compat.
@@ -340,7 +340,7 @@ const AgentTeamAvatarSchema = z
 // template: which personalities are on deck, plus a shared team prompt stacked
 // directly ahead of the member's personality prompt at spawn. `id` is the
 // stable identity everything binds to; `name` is a freely-renamable label.
-// `memberIds` bind personality ids (order = display order) — an entry pointing
+// `memberIds` bind personality ids (order = display order) - an entry pointing
 // at a deleted personality is tolerated and ignored everywhere, then pruned on
 // the next save of that team. Membership is many-to-many.
 export const AgentTeamSchema = z
@@ -376,7 +376,7 @@ export const ModelTierSchema = z.enum(["deep", "standard", "fast"]);
 // A user's explicit tier tag for one model of one provider. The daemon stamps
 // `model.tier` at ingest, preferring a matching override here over inference
 // (see model-tiers.ts). Stored as an array (not a nested record) so a patch
-// replaces it wholesale — that's how a tag gets cleared, since deep-merge can't
+// replaces it wholesale - that's how a tag gets cleared, since deep-merge can't
 // delete a record key.
 export const ModelTierOverrideSchema = z
     .object({
@@ -390,13 +390,13 @@ export const ModelTierOverrideSchema = z
 // pick instead of re-typing the key. Entries are scoped by the connection
 // env-var pair they belong to (OPENAI_BASE_URL/OPENAI_API_KEY vs
 // ANTHROPIC_BASE_URL/ANTHROPIC_AUTH_TOKEN), which is exactly what the provider
-// settings sheet keys its dropdown off — so every openai-compatible provider
+// settings sheet keys its dropdown off - so every openai-compatible provider
 // entry on the host shares one pool, and Claude-compatible entries share
 // another. Deliberately `z.string()` rather than an enum: a future env-var
 // family must not make old entries unparseable.
 export const SavedProviderEndpointSchema = z
     .object({
-    /** Stable identity, `${baseUrlKey}::${baseUrl}` — dedupes on re-save. */
+    /** Stable identity, `${baseUrlKey}::${baseUrl}` - dedupes on re-save. */
     id: z.string().min(1),
     baseUrlKey: z.string().min(1),
     apiKeyKey: z.string().min(1),
@@ -431,6 +431,12 @@ export const MutableBrainRemoteConfigSchema = z
     secure: z.boolean().default(false),
     // Secret: masked with DAEMON_CONFIG_SECRET_SENTINEL on the way out.
     authToken: z.string().nullable().default(null),
+    // SHA-256 fingerprint of the remote brain's TLS certificate (openssl's
+    // "AB:CD:..." form; colons optional). When set, the daemon pins HTTPS
+    // connections to exactly this certificate instead of the system trust
+    // store - required for a brain serving tls.mode=self-signed. When null,
+    // the certificate must validate against the system trust store.
+    certFingerprint: z.string().nullable().default(null),
 })
     .passthrough();
 export const MutableBrainConfigSchema = z
@@ -446,6 +452,7 @@ export const MutableBrainConfigSchema = z
         port: 1234,
         secure: false,
         authToken: null,
+        certFingerprint: null,
     }),
     listen: z
         .object({
@@ -477,13 +484,13 @@ export const MutableBrainConfigSchema = z
     }),
 })
     .passthrough();
-// The brain PATCH schema — deliberately NOT `MutableBrainConfigSchema.partial()`.
+// The brain PATCH schema - deliberately NOT `MutableBrainConfigSchema.partial()`.
 // Every field of the full schema carries a `.default()` (so an old daemon's
 // half-written config still parses as a well-formed OFF section), and Zod keeps
 // those defaults through `.partial()`: `MutableBrainConfigSchema.partial().parse(
 // { allowRemoteConfig: true })` expands to the FULL object with every other field
 // defaulted. The daemon deep-merges the parsed patch over the stored config, so a
-// single-field patch would silently reset the entire brain block to defaults —
+// single-field patch would silently reset the entire brain block to defaults -
 // turning sharing off (host back to loopback), wiping the auth token, and
 // disabling the server. Mirroring the shape WITHOUT defaults keeps an omitted
 // field omitted, so the deep-merge preserves it. Every level is deep-partial so a
@@ -507,6 +514,7 @@ const MutableBrainRemotePatchSchema = z
     port: z.number().int(),
     secure: z.boolean(),
     authToken: z.string().nullable(),
+    certFingerprint: z.string().nullable(),
 })
     .partial()
     .passthrough();
@@ -538,7 +546,7 @@ export const DEFAULT_MUTABLE_BRAIN_CONFIG = {
     enabled: false,
     autoStart: false,
     mode: "local",
-    remote: { host: "", port: 1234, secure: false, authToken: null },
+    remote: { host: "", port: 1234, secure: false, authToken: null, certFingerprint: null },
     listen: { host: "127.0.0.1", port: 1234 },
     defaultModel: null,
     lockModel: false,
@@ -567,7 +575,7 @@ export const MutableDaemonConfigSchema = z
         toolGroups: z.array(z.enum(OTTO_TOOL_GROUPS)).optional(),
     })
         .passthrough(),
-    // Defaults off, matching the daemon's own resolution — browser tools are an
+    // Defaults off, matching the daemon's own resolution - browser tools are an
     // explicit opt-in, so an omitted section must never read as on.
     browserTools: MutableBrowserToolsConfigSchema.default({ enabled: false }),
     // Daemon-wide agent behavior toggles (Claude-tier capabilities). Defaults to
@@ -659,11 +667,12 @@ export const MutableDaemonConfigPatchSchema = z
     // Gated by server_info features.agentBehaviorToggles; patches deep-merge.
     agentBehaviors: MutableAgentBehaviorsConfigSchema.partial().optional(),
     // A null entry removes the provider's config entirely (custom provider
-    // uninstall). Gated by server_info features.providerRemove — old daemons
+    // uninstall). Gated by server_info features.providerRemove - old daemons
     // reject null values.
     providers: z
         .record(z.string(), MutableDaemonProviderConfigSchema.partial().passthrough().nullable())
         .optional(),
+    removeProviders: z.array(z.string().min(1)).optional(),
     metadataGeneration: MutableMetadataGenerationConfigSchema.partial().optional(),
     autoArchiveAfterMerge: z.boolean().optional(),
     // Gated by server_info features.hideMergeIntoBaseSetting.
@@ -745,7 +754,7 @@ export const AgentRateLimitInfoSchema = z.object({
     // does not report it (Claude only includes it near the limit).
     utilizationPercent: z.number().optional(),
     // Provider-reported window identifier, e.g. "five_hour" | "seven_day".
-    // Open set — display code falls back to a generic label for unknown values.
+    // Open set - display code falls back to a generic label for unknown values.
     limitType: z.string().optional(),
     // ISO 8601 timestamp when the window resets.
     resetsAt: z.string().optional(),
@@ -796,6 +805,7 @@ export const ProviderSnapshotEntrySchema = z.object({
     provider: AgentProviderSchema,
     status: ProviderStatusSchema,
     enabled: z.boolean().optional().default(true),
+    source: z.enum(["builtin", "custom"]).optional(),
     error: z.string().optional(),
     models: z.array(AgentModelDefinitionSchema).optional(),
     modes: z.array(AgentModeSchema).optional(),
@@ -848,7 +858,7 @@ 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
+    // 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(),
@@ -1069,6 +1079,7 @@ export const AgentTimelineItemPayloadSchema = z.union([
         type: z.literal("user_message"),
         text: z.string(),
         messageId: z.string().optional(),
+        clientMessageId: z.string().optional(),
     }),
     z.object({
         type: z.literal("assistant_message"),
@@ -1095,7 +1106,9 @@ export const AgentTimelineItemPayloadSchema = z.union([
         type: z.literal("compaction"),
         // COMPAT(compactionFailedStatus): "failed" added in v0.4.3. Clients older
         // than that drop the whole timeline event on parse and keep showing the
-        // loading row — exactly their pre-"failed" behavior, so no gate is needed.
+        // loading row - exactly their pre-"failed" behavior, so no gate is needed.
+        // Nothing to remove: this tag records why the enum could be widened without
+        // a shim, so it has no cleanup date by design.
         status: z.enum(["loading", "completed", "failed"]),
         trigger: z.enum(["auto", "manual"]).optional(),
         preTokens: z.number().optional(),
@@ -1157,6 +1170,7 @@ export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
             body: z.string(),
             data: z.object({
                 serverId: z.string(),
+                workspaceId: z.string().optional(),
                 agentId: z.string(),
                 reason: z.enum(["finished", "error", "permission"]),
             }),
@@ -1199,7 +1213,7 @@ const AgentRuntimeInfoSchema = z.object({
 /**
  * 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
+ * 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({
@@ -1211,14 +1225,14 @@ export const QueuedAgentMessagePayloadSchema = z.object({
     /**
      * Who parked the message. Absent (from an older daemon) or "user" is a normal
      * user turn; "system" marks a system-injected entry (a chat mention, a
-     * scheduled fire) that the daemon's drain never merges into a user turn — the
+     * scheduled fire) that the daemon's drain never merges into a user turn - the
      * client must likewise exclude it from "Send all".
      */
     source: z.enum(["user", "system"]).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".
+ * 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
@@ -1227,12 +1241,12 @@ export const QueuedAgentMessagePayloadSchema = z.object({
  *
  * `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
+ * 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
+ * Declared above AgentSnapshotPayloadSchema - zod-aot emits schemas in source
  * order, so a forward reference is a build-time ReferenceError.
  */
 export const AgentCumulativeUsageSchema = z.object({
@@ -1243,9 +1257,9 @@ export const AgentCumulativeUsageSchema = z.object({
     /** 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.
+     * `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(),
 });
@@ -1270,7 +1284,7 @@ export const AgentSnapshotPayloadSchema = z.object({
     runtimeInfo: AgentRuntimeInfoSchema.optional(),
     lastUsage: AgentUsageSchema.optional(),
     // Honest cumulative token total (Σ across the whole run) from the provider,
-    // for the subagents-track cost readout — the only currency that works for
+    // for the subagents-track cost readout - the only currency that works for
     // cost-less local models. Observed subagents source it from the provider's
     // per-task usage.total_tokens (already cumulative-per-subagent). Purely
     // additive; absent ⇒ no readout. Old clients ignore it.
@@ -1287,16 +1301,18 @@ export const AgentSnapshotPayloadSchema = z.object({
     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 —
+    // (`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.
+    // COMPAT(subagentLiveness): added in v0.6.7, drop the optional gate when the
+    // floor is >= v0.6.7. Old clients ignore both fields and show the row without
+    // its liveness readouts, which is their pre-v0.6.7 behaviour.
     // 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
+    // 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(),
@@ -1309,7 +1325,7 @@ export const AgentSnapshotPayloadSchema = z.object({
     archivedAt: z.string().nullable().optional(),
     providerUnavailable: z.boolean().optional(),
     // Attendability. "observed" marks a provider-managed subagent (Claude Task /
-    // ultracode fan-out) that the user can watch but not prompt or reconfigure —
+    // ultracode fan-out) that the user can watch but not prompt or reconfigure -
     // the daemon refuses attended operations and the client renders it read-only.
     // COMPAT(observedSubagents): added in v0.4.3; absent ⇒ "attended". Drop the
     // gate when daemon floor >= v0.4.3. See projects/observed-subagents/observed-subagents.md.
@@ -1419,7 +1435,7 @@ export const CloseItemsRequestMessageSchema = z.object({
 // 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.
+// 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"),
@@ -1433,7 +1449,7 @@ export const HistoryAgentsClearArchivedRequestSchema = z.object({
 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
+        // 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(),
@@ -1490,7 +1506,7 @@ export const AttachmentsImagesClearRequestSchema = z.object({
     olderThanDays: z.number().int().min(0).default(0),
     // Safe by default: a request that omits the flag previews instead of deleting.
     // The client always sends it explicitly. Same contract as
-    // history.agents.clear_archived, and for the same reason — the client cannot
+    // history.agents.clear_archived, and for the same reason - the client cannot
     // enumerate the set, and there is no undo.
     dryRun: z.boolean().default(true),
     requestId: z.string(),
@@ -1511,6 +1527,27 @@ export const AttachmentsImagesClearResponseSchema = z.object({
 // server_info.features.brainControl (lifecycle) and features.brainStatus
 // (evals). Live status streaming (subscribe_brain_status + brain_status_changed)
 // is added alongside its client/daemon consumers.
+/**
+ * What the brain on the far side can actually serve. Passthrough so it can grow.
+ *
+ * Declared here rather than beside the Brain Console RPCs below because
+ * BrainHostStatusSchema carries it, and a zod const must be initialised before
+ * the schema that references it (see docs on the AOT validator's declaration
+ * ordering). Moving it back down produces a module-evaluation TDZ error.
+ */
+export const BrainCapabilitiesSchema = z
+    .object({
+    profiles: z.boolean().default(false),
+    budget: z.boolean().default(false),
+    logs: z.boolean().default(false),
+    delete: z.boolean().default(false),
+    load: z.boolean().default(false),
+    resources: z.boolean().default(false),
+    inventory: z.boolean().default(false),
+    /** Whether writes are permitted right now (the brain's allowRemoteConfig). */
+    writable: z.boolean().default(false),
+})
+    .passthrough();
 // The brain's host status, as the daemon derives it: liveness plus the fields
 // proxied from the brain's own `/__host/status`. Passthrough on the opaque
 // sub-objects so the brain can evolve them without a protocol bump.
@@ -1533,6 +1570,64 @@ export const BrainHostStatusSchema = z
     telemetry: z.record(z.string(), z.unknown()).nullable().optional(),
     scheduler: z.record(z.string(), z.unknown()).nullable().optional(),
     recent: z.array(z.record(z.string(), z.unknown())).optional(),
+    /**
+     * What the brain on the far side can serve. Carried here rather than fetched
+     * from /__host/capabilities so the client gets it with the status it is
+     * already polling, and so it cannot go stale when the owner toggles remote
+     * configuration. Null from a brain that predates the management API.
+     */
+    capabilities: BrainCapabilitiesSchema.nullable().optional(),
+    /** Live CPU/RAM/GPU/slot telemetry, only when the request asked for it. */
+    resources: z.record(z.string(), z.unknown()).nullable().optional(),
+    /** How many log lines the brain currently holds, for the Logs tab. */
+    logLineCount: z.number().nullable().optional(),
+    /**
+     * Which long-running op currently owns the brain, if any. Cheap to carry:
+     * the brain reads it from a small file beside its pid file, so this rides on
+     * the liveness poll rather than needing `resources: true`.
+     *
+     * `kind` is a plain string, not an enum: the brain may grow ops this client
+     * has never heard of, and the protocol contract forbids narrowing a field
+     * later. Unknown kinds fall through to the ordinary busy states.
+     */
+    activity: z
+        .object({
+        kind: z.string(),
+        target: z.string().nullable().optional(),
+        /** Completion in [0,1], for ops that can measure it. */
+        progress: z.number().nullable().optional(),
+        startedAt: z.string().nullable().optional(),
+    })
+        .passthrough()
+        .nullable()
+        .optional(),
+    /**
+     * Whether any in-flight completion is currently mid-reasoning: reasoning
+     * deltas have arrived and no content has yet. Also on the liveness poll,
+     * because it is one boolean the router already knows.
+     */
+    reasoning: z.boolean().nullable().optional(),
+    /**
+     * Slot occupancy split by phase, so a client can tell a prompt being
+     * ingested from a model that has started answering. Rides here rather than
+     * inside `resources` on purpose: `resources` costs an `nvidia-smi` spawn and
+     * is off by default, and this is the half the status rail needs every poll.
+     */
+    slots: z
+        .object({
+        total: z.number().nullable().optional(),
+        busy: z.number().nullable().optional(),
+        idle: z.number().nullable().optional(),
+        prefill: z.number().nullable().optional(),
+        decode: z.number().nullable().optional(),
+    })
+        .passthrough()
+        .nullable()
+        .optional(),
+    /** Jobs the scheduler is holding because no slot is free, or a swap is mid-flight. */
+    queued: z.number().nullable().optional(),
+    /** Whether the daemon reached the brain on its last probe. */
+    reachable: z.boolean().nullable().optional(),
 })
     .passthrough();
 const BrainHostStatusResultSchema = z.object({
@@ -1542,6 +1637,13 @@ const BrainHostStatusResultSchema = z.object({
 });
 export const BrainHostStatusRequestSchema = z.object({
     type: z.literal("brain.host.status.request"),
+    /**
+     * Ask for live CPU/RAM/GPU/slot telemetry alongside the status. Off by default
+     * on purpose: it costs an `nvidia-smi` spawn plus a /slots round trip on the
+     * brain, and this RPC is also the liveness poll. Only a surface actually
+     * rendering the numbers should turn it on.
+     */
+    resources: z.boolean().default(false),
     requestId: z.string(),
 });
 export const BrainHostStatusResponseSchema = z.object({
@@ -1779,7 +1881,7 @@ const BrainJobsResultSchema = z.object({
     error: z.string().nullable(),
     requestId: z.string(),
 });
-// Installed models — `otto-brain scan`.
+// Installed models - `otto-brain scan`.
 export const BrainModelsScanRequestSchema = z.object({
     type: z.literal("brain.models.scan.request"),
     requestId: z.string(),
@@ -1792,7 +1894,7 @@ export const BrainModelsScanResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// Downloadable catalog — `otto-brain catalog`.
+// Downloadable catalog - `otto-brain catalog`.
 export const BrainCatalogListRequestSchema = z.object({
     type: z.literal("brain.catalog.list.request"),
     requestId: z.string(),
@@ -1805,7 +1907,7 @@ export const BrainCatalogListResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// Installed runtimes — `otto-brain runtime list`.
+// Installed runtimes - `otto-brain runtime list`.
 export const BrainRuntimeListRequestSchema = z.object({
     type: z.literal("brain.runtime.list.request"),
     requestId: z.string(),
@@ -1818,7 +1920,7 @@ export const BrainRuntimeListResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// Download a catalog model — starts a `pull` job.
+// Download a catalog model - starts a `pull` job.
 export const BrainModelsPullRequestSchema = z.object({
     type: z.literal("brain.models.pull.request"),
     // Catalog id or name fragment.
@@ -1829,7 +1931,7 @@ export const BrainModelsPullResponseSchema = z.object({
     type: z.literal("brain.models.pull.response"),
     payload: BrainJobResultSchema,
 });
-// Install a llama.cpp runtime — starts a `runtime-install` job.
+// Install a llama.cpp runtime - starts a `runtime-install` job.
 export const BrainRuntimeInstallRequestSchema = z.object({
     type: z.literal("brain.runtime.install.request"),
     // Optional llama.cpp release build tag; null = the brain's default.
@@ -1840,7 +1942,7 @@ export const BrainRuntimeInstallResponseSchema = z.object({
     type: z.literal("brain.runtime.install.response"),
     payload: BrainJobResultSchema,
 });
-// Measure real KV bytes/token for a model — starts a `calibrate` job. Needs a
+// Measure real KV bytes/token for a model - starts a `calibrate` job. Needs a
 // runtime + GPU; refused with a helpful error otherwise.
 export const BrainCalibrateRequestSchema = z.object({
     type: z.literal("brain.calibrate.request"),
@@ -1851,7 +1953,7 @@ export const BrainCalibrateResponseSchema = z.object({
     type: z.literal("brain.calibrate.response"),
     payload: BrainJobResultSchema,
 });
-// Find the best reasoning budget for a model — starts a `sweep` job.
+// Find the best reasoning budget for a model - starts a `sweep` job.
 export const BrainSweepRequestSchema = z.object({
     type: z.literal("brain.sweep.request"),
     model: z.string(),
@@ -1861,7 +1963,7 @@ export const BrainSweepResponseSchema = z.object({
     type: z.literal("brain.sweep.response"),
     payload: BrainJobResultSchema,
 });
-// Run the agentic-coding benchmark — starts a `bench` job. `model` is an
+// Run the agentic-coding benchmark - starts a `bench` job. `model` is an
 // optional comma list of name fragments; null lets the brain pick.
 export const BrainBenchRequestSchema = z.object({
     type: z.literal("brain.bench.request"),
@@ -1908,7 +2010,7 @@ export const BrainHfSearchResultSchema = z
     installed: z.boolean().default(false),
 })
     .passthrough();
-// One downloadable quantization of a repo — `otto-brain add <repo> --list-quants`.
+// One downloadable quantization of a repo - `otto-brain add <repo> --list-quants`.
 export const BrainRepoQuantSchema = z
     .object({
     quant: z.string().default(""),
@@ -1919,7 +2021,7 @@ export const BrainRepoQuantSchema = z
     installed: z.boolean().default(false),
 })
     .passthrough();
-// Search Hugging Face for GGUF models — `otto-brain search <query>`.
+// Search Hugging Face for GGUF models - `otto-brain search <query>`.
 export const BrainHfSearchRequestSchema = z.object({
     type: z.literal("brain.hf.search.request"),
     query: z.string(),
@@ -1934,7 +2036,7 @@ export const BrainHfSearchResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// List the quantizations a repo offers — `otto-brain add <repo> --list-quants`.
+// List the quantizations a repo offers - `otto-brain add <repo> --list-quants`.
 export const BrainHfQuantsRequestSchema = z.object({
     type: z.literal("brain.hf.quants.request"),
     repo: z.string(),
@@ -1948,7 +2050,7 @@ export const BrainHfQuantsResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// Download a chosen quant of an arbitrary HF repo — starts a `pull` job.
+// Download a chosen quant of an arbitrary HF repo - starts a `pull` job.
 export const BrainModelsAddRequestSchema = z.object({
     type: z.literal("brain.models.add.request"),
     repo: z.string(),
@@ -1959,6 +2061,283 @@ export const BrainModelsAddResponseSchema = z.object({
     type: z.literal("brain.models.add.response"),
     payload: BrainJobResultSchema,
 });
+// --- Brain Console: the management API, proxied ---------------------------
+// Unlike the job RPCs above (which shell out to `otto-brain <verb> --json` and
+// are therefore local-only), these proxy the brain's own `/__host/*` HTTP API.
+// The daemon already resolves that endpoint by mode, so a local child and a
+// remote brain are reached by the same code with no branch on either side.
+// All gated by server_info.features.brainConsole.
+//
+// Two versions matter and they move independently: the daemon (does it know how
+// to proxy?) and the brain (does it serve it?). features.brainConsole answers
+// the first; `capabilities` on brain.host.status answers the second. A brain too
+// old for a capability is reported honestly rather than reimplemented.
+/**
+ * A model's hosting profile. Passthrough because the brain persists more than it
+ * exposes for editing (batchSize, extraArgs, the reasoning-budget message) and
+ * those must survive a round trip untouched rather than being dropped here.
+ */
+export const BrainProfileSchema = z
+    .object({
+    contextSize: z.number().default(0),
+    cacheTypeK: z.string().default(""),
+    cacheTypeV: z.string().default(""),
+    flashAttention: z.boolean().default(true),
+    gpuLayers: z.number().default(0),
+    vision: z.boolean().default(false),
+    reasoningBudget: z.number().default(0),
+    parallelSlots: z.number().default(1),
+})
+    .passthrough();
+/** One editable field, as the brain describes it, so the editor cannot drift. */
+export const BrainProfileFieldSchema = z
+    .object({
+    key: z.string(),
+    label: z.string().default(""),
+    kind: z.string().default("number"),
+    step: z.number().nullable().optional(),
+    min: z.number().nullable().optional(),
+    max: z.number().nullable().optional(),
+    options: z.array(z.union([z.string(), z.number()])).default([]),
+    optionLabels: z.array(z.string()).default([]),
+    available: z.boolean().default(true),
+    unavailableReason: z.string().nullable().optional(),
+})
+    .passthrough();
+/** A note on a field. `blocksStart` means this combination cannot load at all. */
+export const BrainProfileWarningSchema = z
+    .object({
+    field: z.string().nullable().default(null),
+    severity: z.string().default("info"),
+    message: z.string().default(""),
+    blocksStart: z.boolean().default(false),
+})
+    .passthrough();
+/**
+ * Where the KV bytes/token figure came from. `inherited` means it was measured
+ * on a relative with the same attention geometry and rescaled, which the UI must
+ * never present as measured on this file.
+ */
+export const BrainCalibrationInfoSchema = z
+    .object({
+    state: z.string().default("unknown"),
+    kvBytesPerToken: z.number().nullable().default(null),
+    measuredAt: z.string().nullable().default(null),
+    measuredOn: z.string().nullable().default(null),
+})
+    .passthrough();
+/** The VRAM breakdown for a profile. Raw bytes; the client formats at the edge. */
+export const BrainBudgetSchema = z
+    .object({
+    weightsBytes: z.number().default(0),
+    mmprojBytes: z.number().default(0),
+    kvBytes: z.number().default(0),
+    overheadBytes: z.number().default(0),
+    totalBytes: z.number().default(0),
+    usableBytes: z.number().default(0),
+    totalVramBytes: z.number().default(0),
+    reserveBytes: z.number().default(0),
+    kvBytesPerToken: z.number().default(0),
+    source: z.string().default("unknown"),
+    theoreticalKvBytesPerToken: z.number().nullable().default(null),
+    fits: z.boolean().default(false),
+    headroomBytes: z.number().default(0),
+    utilization: z.number().default(0),
+})
+    .passthrough();
+/** A model's benchmark standing, joined onto its inventory row. */
+export const BrainModelScoreSchema = z
+    .object({
+    id: z.string().nullable().default(null),
+    displayName: z.string().default(""),
+    overall: z.number().default(0),
+    runs: z.number().default(0),
+    std: z.number().default(0),
+    grade: z.string().default(""),
+    rank: z.number().nullable().optional(),
+})
+    .passthrough();
+/**
+ * One installed model with everything the Models tab shows, joined by the brain.
+ * The client must not have to correlate the scan, the metadata and the rankings
+ * itself: they key on different things and only the brain knows the file layout.
+ */
+export const BrainInventoryModelSchema = z
+    .object({
+    id: z.string(),
+    displayName: z.string().default(""),
+    publisher: z.string().nullable().default(null),
+    quant: z.string().nullable().default(null),
+    sizeBytes: z.number().default(0),
+    mmprojBytes: z.number().default(0),
+    origin: z.string().nullable().default(null),
+    arch: z.string().nullable().default(null),
+    contextLength: z.number().nullable().default(null),
+    blockCount: z.number().nullable().default(null),
+    headCountKv: z.number().nullable().default(null),
+    hasProjector: z.boolean().default(false),
+    reasoning: z.boolean().default(false),
+    mtp: z.boolean().default(false),
+    distilled: z.boolean().default(false),
+    useCases: z.array(z.string()).default([]),
+    tier: z.string().nullable().default(null),
+    profile: BrainProfileSchema.nullable().default(null),
+    calibration: BrainCalibrationInfoSchema.nullable().default(null),
+    budget: BrainBudgetSchema.nullable().default(null),
+    maxContextThatFits: z.number().nullable().default(null),
+    score: BrainModelScoreSchema.nullable().default(null),
+    state: z.string().default("not-loaded"),
+    warnings: z.array(BrainProfileWarningSchema).default([]),
+})
+    .passthrough();
+export const BrainDiskUsageSchema = z
+    .object({
+    freeBytes: z.number().default(0),
+    totalBytes: z.number().default(0),
+    modelBytes: z.number().default(0),
+})
+    .passthrough();
+// The joined inventory - GET /__host/models.
+export const BrainModelsInventoryRequestSchema = z.object({
+    type: z.literal("brain.models.inventory.request"),
+    requestId: z.string(),
+});
+export const BrainModelsInventoryResponseSchema = z.object({
+    type: z.literal("brain.models.inventory.response"),
+    payload: z.object({
+        models: z.array(BrainInventoryModelSchema).default([]),
+        disk: BrainDiskUsageSchema.nullable().default(null),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Read a model's profile plus the descriptors an editor renders from.
+export const BrainModelProfileGetRequestSchema = z.object({
+    type: z.literal("brain.model.profile.get.request"),
+    modelId: z.string(),
+    requestId: z.string(),
+});
+export const BrainModelProfileGetResponseSchema = z.object({
+    type: z.literal("brain.model.profile.get.response"),
+    payload: z.object({
+        profile: BrainProfileSchema.nullable().default(null),
+        fields: z.array(BrainProfileFieldSchema).default([]),
+        warnings: z.array(BrainProfileWarningSchema).default([]),
+        calibration: BrainCalibrationInfoSchema.nullable().default(null),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Write the editable fields. `patch` carries only the eight the brain accepts;
+// anything else is ignored there rather than rejected, so an older client that
+// sends a field a newer brain dropped still succeeds.
+export const BrainModelProfileSetRequestSchema = z.object({
+    type: z.literal("brain.model.profile.set.request"),
+    modelId: z.string(),
+    patch: z.record(z.string(), z.unknown()),
+    requestId: z.string(),
+});
+export const BrainModelProfileSetResponseSchema = z.object({
+    type: z.literal("brain.model.profile.set.response"),
+    payload: z.object({
+        profile: BrainProfileSchema.nullable().default(null),
+        /** Human-readable notes about anything clamped or ignored. */
+        adjustments: z.array(z.string()).default([]),
+        warnings: z.array(BrainProfileWarningSchema).default([]),
+        calibration: BrainCalibrationInfoSchema.nullable().default(null),
+        budget: BrainBudgetSchema.nullable().default(null),
+        maxContextThatFits: z.number().nullable().default(null),
+        /** True when the edited model is the resident one, so a restart applies it. */
+        requiresRestart: z.boolean().default(false),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// The budget for a hypothetical profile - GET /__host/model/budget. `overrides`
+// are string-encoded field values so the UI can preview a budget while a control
+// is mid-drag, without persisting a value the user is scrubbing past.
+export const BrainModelBudgetGetRequestSchema = z.object({
+    type: z.literal("brain.model.budget.get.request"),
+    modelId: z.string(),
+    overrides: z.record(z.string(), z.string()).default({}),
+    requestId: z.string(),
+});
+export const BrainModelBudgetGetResponseSchema = z.object({
+    type: z.literal("brain.model.budget.get.response"),
+    payload: z.object({
+        profile: BrainProfileSchema.nullable().default(null),
+        budget: BrainBudgetSchema.nullable().default(null),
+        maxContextThatFits: z.number().nullable().default(null),
+        gpu: z.record(z.string(), z.unknown()).nullable().default(null),
+        warnings: z.array(BrainProfileWarningSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Load a model into the running brain. Distinct from brain.host.start, which
+// restarts the daemon's child and has no remote equivalent.
+export const BrainModelLoadRequestSchema = z.object({
+    type: z.literal("brain.model.load.request"),
+    modelId: z.string(),
+    requestId: z.string(),
+});
+export const BrainModelLoadResponseSchema = z.object({
+    type: z.literal("brain.model.load.response"),
+    payload: z.object({
+        status: BrainHostStatusSchema.nullable().default(null),
+        /** The profile actually used: the brain clamps context to fit VRAM. */
+        profile: BrainProfileSchema.nullable().default(null),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const BrainModelUnloadRequestSchema = z.object({
+    type: z.literal("brain.model.unload.request"),
+    requestId: z.string(),
+});
+export const BrainModelUnloadResponseSchema = z.object({
+    type: z.literal("brain.model.unload.response"),
+    payload: z.object({
+        status: BrainHostStatusSchema.nullable().default(null),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Delete a model's files. The brain refuses while that model is loaded.
+export const BrainModelDeleteRequestSchema = z.object({
+    type: z.literal("brain.model.delete.request"),
+    modelId: z.string(),
+    requestId: z.string(),
+});
+export const BrainModelDeleteResponseSchema = z.object({
+    type: z.literal("brain.model.delete.response"),
+    payload: z.object({
+        deleted: z.array(z.string()).default([]),
+        freedBytes: z.number().default(0),
+        includesProjector: z.boolean().default(false),
+        /** How many models remain after the re-scan. */
+        remaining: z.number().default(0),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Tail the brain's llama-server log.
+export const BrainLogsTailRequestSchema = z.object({
+    type: z.literal("brain.logs.tail.request"),
+    limit: z.number().nullable().default(null),
+    requestId: z.string(),
+});
+export const BrainLogsTailResponseSchema = z.object({
+    type: z.literal("brain.logs.tail.response"),
+    payload: z.object({
+        lines: z.array(z.string()).default([]),
+        total: z.number().default(0),
+        state: z.string().nullable().default(null),
+        command: z.string().nullable().default(null),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
 export const ProjectRenameRequestSchema = z.object({
     type: z.literal("project.rename.request"),
     projectId: z.string(),
@@ -2002,6 +2381,22 @@ export const WorkspaceTitleSetRequestSchema = z.object({
     title: z.string().nullable(),
     requestId: z.string(),
 });
+export const WorkspacePinSetRequestSchema = z.object({
+    type: z.literal("workspace.pin.set.request"),
+    workspaceId: z.string(),
+    pinned: z.boolean(),
+    requestId: z.string(),
+});
+export const WorkspaceRecoveryInspectRequestSchema = z.object({
+    type: z.literal("workspace.recovery.inspect.request"),
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
+export const WorkspaceRecoveryRestoreRequestSchema = z.object({
+    type: z.literal("workspace.recovery.restore.request"),
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
 export const SetVoiceModeMessageSchema = z.object({
     type: z.literal("set_voice_mode"),
     enabled: z.boolean(),
@@ -2018,6 +2413,18 @@ export const GitHubPrAttachmentSchema = z.object({
     baseRefName: z.string().nullable().optional(),
     headRefName: z.string().nullable().optional(),
 });
+export const ForgeChangeRequestAttachmentSchema = z.object({
+    type: z.literal("forge_change_request"),
+    mimeType: z.literal("application/otto-forge-change-request"),
+    forge: z.string().optional().default("github"),
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+    projectPath: z.string().optional(),
+    baseRefName: z.string().nullable().optional(),
+    headRefName: z.string().nullable().optional(),
+});
 export const GitHubIssueAttachmentSchema = z.object({
     type: z.literal("github_issue"),
     mimeType: z.literal("application/github-issue"),
@@ -2026,10 +2433,13 @@ export const GitHubIssueAttachmentSchema = z.object({
     url: z.string(),
     body: z.string().nullable().optional(),
 });
-// Provider-neutral successors to github_pr/github_issue. New clients send
-// these when server_info features.gitHostingProviders is set; the github_*
-// kinds remain accepted forever (protocol contract) and are still what a new
-// client sends to an old daemon for GitHub projects.
+// COMPAT(hostingAttachments): added in v0.7.6, remove after 2027-02-01.
+// These were the provider-neutral successors to github_pr/github_issue. The
+// forge merge replaced them with forge_change_request/forge_issue, so no
+// current client sends them - they stay accepted (protocol contract) purely so
+// a client from before that merge can still attach a PR or an issue. The
+// daemon renders them at
+// server/src/server/agent/prompt-attachments.ts; retire both halves together.
 export const HostingPrAttachmentSchema = z.object({
     type: z.literal("hosting_pr"),
     mimeType: z.literal("application/otto-hosting-pr"),
@@ -2050,6 +2460,16 @@ export const HostingIssueAttachmentSchema = z.object({
     url: z.string(),
     body: z.string().nullable().optional(),
 });
+export const ForgeIssueAttachmentSchema = z.object({
+    type: z.literal("forge_issue"),
+    mimeType: z.literal("application/otto-forge-issue"),
+    forge: z.string().optional().default("github"),
+    number: z.number().int().positive(),
+    title: z.string(),
+    url: z.string(),
+    body: z.string().nullable().optional(),
+    projectPath: z.string().optional(),
+});
 export const TextAttachmentSchema = z
     .object({
     type: z.literal("text"),
@@ -2096,6 +2516,8 @@ export const UploadedFileAttachmentSchema = z.object({
     path: z.string(),
 });
 export const AgentAttachmentSchema = z.discriminatedUnion("type", [
+    ForgeChangeRequestAttachmentSchema,
+    ForgeIssueAttachmentSchema,
     GitHubPrAttachmentSchema,
     GitHubIssueAttachmentSchema,
     HostingPrAttachmentSchema,
@@ -2118,6 +2540,12 @@ function normalizeAgentAttachments(input) {
     return normalized;
 }
 const AgentAttachmentsSchema = z.unknown().transform(normalizeAgentAttachments).optional();
+export const ChangeRequestCheckoutSourceSchema = z.object({
+    kind: z.literal("change_request"),
+    forge: z.string().optional(),
+    number: z.number().int().positive(),
+    projectPath: z.string().optional(),
+});
 const ImageAttachmentSchema = z.object({
     data: z.string(), // base64 encoded image
     mimeType: z.string(), // e.g., "image/jpeg", "image/png"
@@ -2192,6 +2620,10 @@ export const FetchWorkspacesRequestMessageSchema = z.object({
     })
         .optional(),
 });
+export const ProjectListRequestMessageSchema = z.object({
+    type: z.literal("project.list.request"),
+    requestId: z.string(),
+});
 export const FetchAgentHistoryRequestMessageSchema = z.object({
     type: z.literal("fetch_agent_history_request"),
     requestId: z.string(),
@@ -2289,6 +2721,21 @@ export const DaemonGetPairingOfferRequestSchema = z.object({
     type: z.literal("daemon.get_pairing_offer.request"),
     requestId: z.string(),
 });
+export const HubManagementDaemonConnectRequestSchema = z.object({
+    type: z.literal("hub.management.daemon.connect.request"),
+    requestId: z.string(),
+    hubUrl: z.string(),
+    token: z.string(),
+});
+export const HubManagementDaemonGetStatusRequestSchema = z.object({
+    type: z.literal("hub.management.daemon.get_status.request"),
+    requestId: z.string(),
+});
+export const HubManagementDaemonDisconnectRequestSchema = z.object({
+    type: z.literal("hub.management.daemon.disconnect.request"),
+    requestId: z.string(),
+    force: z.boolean().optional(),
+});
 export const DiagnosticsRequestSchema = z.object({
     type: z.literal("diagnostics.request"),
     requestId: z.string(),
@@ -2302,11 +2749,11 @@ export const SetDaemonConfigRequestMessageSchema = z.object({
     requestId: z.string(),
     config: MutableDaemonConfigPatchSchema,
 });
-// Connectors — MCP servers surfaced as named, toggle-able integrations. The
+// Connectors - MCP servers surfaced as named, toggle-able integrations. The
 // registry itself (add/remove/enable/disable a connector or an individual tool)
 // lives in daemon config and is edited via set_daemon_config's `connectors`
 // patch. The one thing config can't answer is what tools a connector actually
-// exposes, which needs a live connect + listTools — that is this RPC. Gated by
+// exposes, which needs a live connect + listTools - that is this RPC. Gated by
 // features.connectors.
 export const ConnectorsListToolsRequestSchema = z.object({
     type: z.literal("connectors.list_tools.request"),
@@ -2329,6 +2776,61 @@ export const ConnectorsListToolsResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+// Connector OAuth - the "sign in" path for connectors whose MCP server
+// authenticates by login rather than by a pasted token. Three steps, because a
+// login is not a request/response: the client asks to authorize, the daemon
+// answers with a URL to open (or "already authorized"), and the actual result
+// arrives later as a pushed status once the user finishes in their browser.
+// Gated by features.connectorOauth.
+export const ConnectorsOauthAuthorizeRequestSchema = z.object({
+    type: z.literal("connectors.oauth.authorize.request"),
+    requestId: z.string(),
+    connectorId: z.string(),
+    /** Scopes to request, when the catalog entry names them. */
+    scope: z.string().optional(),
+});
+export const ConnectorsOauthAuthorizeResponseSchema = z.object({
+    type: z.literal("connectors.oauth.authorize.response"),
+    payload: z.object({
+        connectorId: z.string(),
+        /**
+         * Present when the user must sign in: the client opens this URL. Absent when
+         * the daemon already held a usable authorization, in which case status is
+         * "authorized" and there is nothing to open.
+         */
+        authorizationUrl: z.string().nullable().default(null),
+        status: z.enum(["redirect", "authorized", "error"]).default("error"),
+        error: z.string().nullable().default(null),
+        requestId: z.string(),
+    }),
+});
+export const ConnectorsOauthDisconnectRequestSchema = z.object({
+    type: z.literal("connectors.oauth.disconnect.request"),
+    requestId: z.string(),
+    connectorId: z.string(),
+});
+export const ConnectorsOauthDisconnectResponseSchema = z.object({
+    type: z.literal("connectors.oauth.disconnect.response"),
+    payload: z.object({
+        connectorId: z.string(),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Pushed when an in-flight authorization settles. Not correlated to a requestId:
+ * the browser round-trip outlives the request that started it, and more than one
+ * client may be watching the same connector.
+ */
+export const ConnectorsOauthStatusMessageSchema = z.object({
+    type: z.literal("connectors.oauth.status"),
+    payload: z.object({
+        connectorId: z.string(),
+        status: z.enum(["connected", "failed"]),
+        /** Account label to show once connected, when the server reveals one. */
+        account: z.string().nullable().default(null),
+        error: z.string().nullable().default(null),
+    }),
+});
 export const SpeechSettingsGetOptionsRequestSchema = z.object({
     type: z.literal("speech.settings.get_options.request"),
     requestId: z.string(),
@@ -2352,8 +2854,8 @@ export const SpeechTtsPreviewRequestSchema = z.object({
         .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
+// 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
@@ -2382,8 +2884,8 @@ export const SpeechTtsSpeakCancelRequestSchema = z.object({
 });
 // COMPAT(visualizerVoiceCues): added in v0.6.3; gate lives in
 // features.visualizerVoiceCues. Author short spoken "cue" lines for a
-// personality — a handful of variations each for three Visualizer moments
-// (join / thinking / done) — via the Writer mini-task chain, flavored by the
+// personality - a handful of variations each for three Visualizer moments
+// (join / thinking / done) - via the Writer mini-task chain, flavored by the
 // persona's `name` + `prompt`. The persona is passed inline (not a stored id)
 // so the personality editor can generate for an unsaved draft too; the result
 // is stored on the personality (`voiceCues`) and edited there, so this is an
@@ -2477,6 +2979,9 @@ const GitSetupOptionsSchema = z.object({
     worktreeSlug: z.string().optional(),
     refName: z.string().min(1).optional(),
     action: z.enum(["branch-off", "checkout"]).optional(),
+    checkoutSource: ChangeRequestCheckoutSourceSchema.optional(),
+    // COMPAT(githubPrNumber): added in v0.1.106, remove after 2026-12-28 once
+    // clients send checkoutSource.
     githubPrNumber: z.number().int().positive().optional(),
 });
 export const CreateAgentWorktreeTargetSchema = z.discriminatedUnion("mode", [
@@ -2499,12 +3004,15 @@ export const CreateAgentRequestMessageSchema = z.object({
     config: AgentSessionConfigSchema,
     // Optional personality id. When present the daemon resolves the personality
     // against this cwd's provider snapshot and snapshots its identity (spinner,
-    // voice, prompt) onto the agent — the brain (provider/model/mode/effort) still
+    // voice, prompt) onto the agent - the brain (provider/model/mode/effort) still
     // comes from `config`, so hand-deviations in the picker keep the identity.
     // COMPAT(agentPersonalities): added in v0.5.0; gate lives in features.agentPersonalities.
     personality: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),
     workspaceId: z.string().optional(),
+    // Optional caller context lets managed CLI invocations use the same daemon-owned
+    // workspace and parentage policy as agent-scoped MCP creation.
+    callerAgentId: z.string().optional(),
     worktreeName: z.string().optional(),
     initialPrompt: z.string().optional(),
     clientMessageId: z.string().optional(),
@@ -2553,7 +3061,7 @@ export const ProviderUsageListRequestMessageSchema = z.object({
     type: z.literal("provider.usage.list.request"),
     requestId: z.string(),
 });
-// Daemon-wide "fun stats" counters — see docs/data-model.md ActivityStatsStore.
+// Daemon-wide "fun stats" counters - see docs/data-model.md ActivityStatsStore.
 // Every field defaults to 0 so old and new daemons/clients stay compatible as
 // counters are added later.
 export const ActivityCountersSchema = z.object({
@@ -2572,7 +3080,7 @@ export const ActivityCountersSchema = z.object({
     // Usage & cost accounting (WP-G). Additive/defaulted like every counter above,
     // so old daemons emit 0 and old clients drop the unknown leaves. "In"/"Out"
     // are token totals; *CostMicroUsd are integer micro-USD (usd*1e6) to stay
-    // summable — populated only for turns reporting a real provider cost (Claude).
+    // summable - populated only for turns reporting a real provider cost (Claude).
     // The client detects whether the daemon actually populates these via
     // features.usageCostCategories (see below).
     costMicroUsd: z.number().default(0),
@@ -2605,10 +3113,10 @@ export const StatsActivityGetResponseMessageSchema = z.object({
         allTime: ActivityCountersSchema,
     }),
 });
-// Daemon-wide "activity counters moved" ping — broadcast to every client,
+// Daemon-wide "activity counters moved" ping - broadcast to every client,
 // coalesced at the daemon (at most once every few seconds) so bursts of
 // increments don't get chatty. Carries no payload: clients re-fetch the
-// rollups via stats.activity.get. Purely additive — old clients drop the
+// rollups via stats.activity.get. Purely additive - old clients drop the
 // unknown type with a warning, and against old daemons (which never send it)
 // the stats screen degrades to today's focus/manual refresh. Rides the
 // existing activityStats capability; no new feature flag needed because no
@@ -2616,12 +3124,12 @@ export const StatsActivityGetResponseMessageSchema = z.object({
 export const ActivityStatsChangedSchema = z.object({
     type: z.literal("activity_stats_changed"),
 });
-// One itemized row of the usage ledger — a single token/cost-bearing activity
+// One itemized row of the usage ledger - a single token/cost-bearing activity
 // (a chat turn, a sub-agent turn, or a background generation). The aggregate
 // ActivityCounters above are the rollup of this same event stream; the ledger is
 // the scrollable detail behind the tiles (usage-ledger project). `kind` and
 // `provider` are plain strings (not enums) so an OLD client still parses a NEW
-// daemon that emits a kind it hasn't heard of — it renders it generically rather
+// daemon that emits a kind it hasn't heard of - it renders it generically rather
 // than failing the whole message. All token/cost leaves default to 0.
 export const UsageEventSchema = z.object({
     /** Stable unique id for the row (daemon-generated). */
@@ -2657,20 +3165,20 @@ export const UsageEventSchema = z.object({
     /**
      * How many model round-trips this row aggregates. A chat row is one query, but
      * a sub-agent row covers a whole delegated task that internally ran many
-     * rounds — and each round re-reads the growing context, so `cachedTokensIn` is
+     * rounds - and each round re-reads the growing context, so `cachedTokensIn` is
      * cumulative cache-READS, not a cache size. Surfacing the count is what makes a
      * large cached figure legible instead of looking like a bug. Absent when the
      * provider doesn't report it.
      */
     rounds: z.number().optional(),
     /**
-     * Sub-agent rows only — the spawn-tree identity that lets the Log group rows
+     * Sub-agent rows only - the spawn-tree identity that lets the Log group rows
      * the way a human reads the run (chat turn → its sub-agents → their
      * sub-agents) instead of by settle time, which async sub-agents crossing turn
      * boundaries makes wrong. `startedAt` is when the sub-agent was first
      * observed (epoch ms; a row belongs to the turn that spawned it, not the turn
      * it happened to settle in), `subagentKey` is its stable observed key, and
-     * `parentSubagentKey` is the spawning sub-agent's key — absent for depth-1
+     * `parentSubagentKey` is the spawning sub-agent's key - absent for depth-1
      * sub-agents spawned by the chat itself.
      */
     startedAt: z.number().optional(),
@@ -2696,7 +3204,7 @@ export const UsageLogGetResponseMessageSchema = z.object({
     }),
 });
 // Wipe every daemon-wide usage counter AND the itemized usage ledger back to
-// zero — the "Reset" action on the Metrics screen. One RPC clears both sinks
+// zero - the "Reset" action on the Metrics screen. One RPC clears both sinks
 // (the day-bucketed ActivityStatsStore and the UsageLogStore) so the tiles and
 // the Log tab start fresh together. Gated behind features.statsReset so an old
 // daemon (no handler) never receives a request the client thinks it can send.
@@ -2776,9 +3284,29 @@ export const FetchAgentTimelineRequestMessageSchema = z.object({
     // Default should be projected for app timeline loading.
     projection: z.enum(["projected", "canonical"]).optional(),
 });
+export const ProviderSubagentListRequestMessageSchema = z.object({
+    type: z.literal("agent.provider_subagents.list.request"),
+    parentAgentId: z.string(),
+    requestId: z.string(),
+});
+export const ProviderSubagentTimelineRequestMessageSchema = z.object({
+    type: z.literal("agent.provider_subagents.timeline.get.request"),
+    parentAgentId: z.string(),
+    subagentId: z.string(),
+    requestId: z.string(),
+    direction: z.enum(["tail", "before", "after"]).optional(),
+    cursor: AgentTimelineCursorSchema.optional(),
+    limit: z.number().int().nonnegative().optional(),
+});
+export const SetAgentTimelineSubscriptionRequestMessageSchema = z.object({
+    type: z.literal("agent.timeline.set_subscription.request"),
+    agentIds: z.array(z.string()),
+    requestId: z.string(),
+});
 export const AgentForkContextRequestMessageSchema = z.object({
     type: z.literal("agent.fork_context.request"),
     agentId: z.string(),
+    boundaryCursor: AgentTimelineCursorSchema.optional(),
     boundaryMessageId: z.string().optional(),
     requestId: z.string(),
 });
@@ -2874,7 +3402,7 @@ export const AgentSubagentStopResponseMessageSchema = z.object({
     payload: AgentActionResponsePayloadSchema,
 });
 // A background shell task launched by a provider's own Bash tool (Claude:
-// run_in_background). Not an agent, not a subagent — a plain shell process
+// run_in_background). Not an agent, not a subagent - a plain shell process
 // the daemon tracks for the parent agent's Background Tasks track.
 // COMPAT(backgroundShellTasks): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
 export const BackgroundShellTaskInfoSchema = z.object({
@@ -2890,7 +3418,7 @@ export const BackgroundShellTaskInfoSchema = z.object({
     archivedAt: z.string().optional(),
 });
 // Pushed with the full current set of background shell tasks for a parent
-// agent whenever any of them changes (start/progress/settle/clear) — same
+// agent whenever any of them changes (start/progress/settle/clear) - same
 // full-list reconciliation shape as TerminalsChangedSchema.
 export const BackgroundShellTasksChangedSchema = z.object({
     type: z.literal("background_shell_tasks_changed"),
@@ -2926,7 +3454,7 @@ export const AgentBackgroundTaskClearResponseMessageSchema = z.object({
 // A suggested task an agent surfaced via the `spawn_task` tool (Claude Desktop
 // parity). Renders as a chip in the parent agent's session; the user starts it
 // (new worktree / local / this session) or dismisses it. The `prompt` is
-// deliberately NOT part of this wire shape — it stays server-side and is only
+// deliberately NOT part of this wire shape - it stays server-side and is only
 // used when the task is started ("not shown directly" in Claude Desktop).
 // COMPAT(suggestedTasks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
 export const SuggestedTaskStateSchema = z.enum(["pending", "started", "dismissed"]);
@@ -2941,7 +3469,7 @@ export const SuggestedTaskInfoSchema = z.object({
     updatedAt: z.string(),
 });
 // Pushed with the full current set of pending suggested tasks for a parent
-// agent whenever any of them changes (spawn/start/dismiss) — same full-list
+// agent whenever any of them changes (spawn/start/dismiss) - same full-list
 // reconciliation shape as BackgroundShellTasksChangedSchema.
 export const SuggestedTasksChangedSchema = z.object({
     type: z.literal("suggested_tasks_changed"),
@@ -2950,7 +3478,7 @@ export const SuggestedTasksChangedSchema = z.object({
         tasks: z.array(SuggestedTaskInfoSchema),
     }),
 });
-// Context Management — the daemon's accounting of everything a provider sends
+// Context Management - the daemon's accounting of everything a provider sends
 // before the user types (see docs/context-management.md).
 //
 // Two distinctions carry the whole feature and must not be collapsed on the
@@ -3011,7 +3539,7 @@ export const ContextFindingSchema = z.object({
     range: ContextRangeSchema.optional(),
     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
+    // node, load-bearing once the report flattens them all into one list - that
     // list is the "Issues" tab, and without this a row cannot say where it came
     // from or take you there.
     nodeId: z.string().optional(),
@@ -3022,9 +3550,9 @@ export const ContextFindingSchema = z.object({
     // 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
+    // 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
+    // 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`
@@ -3048,7 +3576,7 @@ export const ContextNodeSchema = z.object({
 });
 export const ContextEdgeSchema = z.object({
     fromNodeId: z.string(),
-    // Null when the target could not be resolved — pairs with a dead_* finding.
+    // Null when the target could not be resolved - pairs with a dead_* finding.
     toNodeId: z.string().nullable(),
     kind: z.enum(["import", "reference"]),
     rawTarget: z.string(),
@@ -3069,7 +3597,7 @@ export const ContextCategoryTotalSchema = z.object({
 export const ContextReportSchema = z.object({
     workspaceId: z.string(),
     provider: z.string(),
-    // The window the report was evaluated against — from the active model, or
+    // The window the report was evaluated against - from the active model, or
     // the client's what-if picker. Severity is meaningless without it.
     windowTokens: z.number(),
     scannedAt: z.string(),
@@ -3126,7 +3654,7 @@ export const ContextReportGetResponseMessageSchema = z.object({
     }),
 });
 // One readable block of the assembled prompt. `text` is absent exactly when
-// `visibility` is "not_visible" — the provider composes that part internally and
+// `visibility` is "not_visible" - the provider composes that part internally and
 // Otto has nothing to show, which the section states rather than hides.
 export const ContextPromptSectionSchema = z.object({
     category: ContextCategorySchema,
@@ -3149,8 +3677,8 @@ export const ContextPromptPreviewGetRequestMessageSchema = z.object({
     provider: z.string().optional(),
     windowTokens: z.number().optional(),
     personalityId: z.string().optional(),
-    // Assemble only this category. The tab reads one section at a time — the user
-    // clicked a row in the tree — and assembling the rest would re-read every
+    // Assemble only this category. The tab reads one section at a time - the user
+    // clicked a row in the tree - and assembling the rest would re-read every
     // context file on disk to build text nobody asked to see. Omitted means all,
     // which is what an older client sends.
     category: ContextCategorySchema.optional(),
@@ -3168,7 +3696,7 @@ export const ContextEdgeConvertRequestMessageSchema = z.object({
     type: z.literal("context.edge.convert.request"),
     requestId: z.string(),
     workspaceId: z.string(),
-    // The parent file holding the reference — its `ContextNode.path`, not its
+    // The parent file holding the reference - its `ContextNode.path`, not its
     // id: ids are case-folded on Windows and are not safe to write through.
     filePath: z.string(),
     rawTarget: z.string(),
@@ -3183,7 +3711,7 @@ export const ContextEdgeConvertResponseMessageSchema = z.object({
         error: z.string().optional(),
     }),
 });
-// Deletes every mechanically-fixable finding's range in one pass — the
+// 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).
@@ -3207,7 +3735,7 @@ export const ContextFindingsFixResponseMessageSchema = z.object({
     }),
 });
 // ---------------------------------------------------------------------------
-// Personality memory — the lessons a named personality accrues across sessions.
+// 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
@@ -3250,7 +3778,7 @@ export const PersonalityMemoryListResponseMessageSchema = z.object({
         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. */
+        /** 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
@@ -3318,7 +3846,7 @@ export const PersonalityMemoryTransferResponseMessageSchema = z.object({
     }),
 });
 // Per-personality lesson counts. Its own RPC over its own file, mirroring
-// agentPersonalities.get_stats — counts must not ride the daemon-config
+// 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"),
@@ -3342,14 +3870,14 @@ const SuggestedTaskActionResponsePayloadSchema = z.object({
     failed: z.number(),
     error: z.string().nullable(),
 });
-// Start one or more suggested tasks, applying the SAME mode to each — no
+// Start one or more suggested tasks, applying the SAME mode to each - no
 // combining. Four modes, only `subagent` links the new agent to the parent:
 //  - `new_chat`:   a fresh independent agent in its own tab, same repo/cwd, NO
-//                  parent link — survives the parent's cancel/archive.
+//                  parent link - survives the parent's cancel/archive.
 //  - `subagent`:   a bound child agent that shows in the parent's Subagents
 //                  track and archive-cascades with it.
 //  - `worktree`:   an independent agent on a new git worktree (auto branch-off),
-//                  isolated workspace — also unlinked from the parent.
+//                  isolated workspace - also unlinked from the parent.
 //  - `in_session`: steers the parent agent with the task prompt (no new agent).
 // The daemon resolves the parent agent's brain (provider/model/personality) so a
 // started task continues the suggesting agent.
@@ -3382,8 +3910,8 @@ export const TasksSuggestedDismissResponseMessageSchema = z.object({
 });
 // Switch a running agent to an Agent Personality (or clear with null). The
 // daemon re-resolves the id against the roster + the agent's cwd provider
-// snapshot and applies the full personality live — system prompt, identity
-// (name/spinner), and brain (model/mode/effort) — restarting the provider query
+// snapshot and applies the full personality live - system prompt, identity
+// (name/spinner), and brain (model/mode/effort) - restarting the provider query
 // so the new prompt takes effect on the next turn. Providers that cannot apply
 // a prompt mid-session reject. COMPAT(setAgentPersonality): added in v0.5.0;
 // gate lives in features.setAgentPersonality.
@@ -3498,6 +4026,48 @@ export const AgentWorkspaceTransferResponseMessageSchema = z.object({
     type: z.literal("agent.workspace.transfer.response"),
     payload: AgentWorkspaceTransferResponsePayloadSchema,
 });
+export const WorkspacePinSetResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    workspaceId: z.string(),
+    accepted: z.boolean(),
+    pinnedAt: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const WorkspacePinSetResponseSchema = z.object({
+    type: z.literal("workspace.pin.set.response"),
+    payload: WorkspacePinSetResponsePayloadSchema,
+});
+export const WorkspaceRecoveryStateSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("recoverable"),
+        workspaceId: z.string(),
+        workspaceName: z.string(),
+        action: z.string(),
+        branch: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("unavailable"),
+        workspaceId: z.string(),
+        reason: z.string(),
+        message: z.string(),
+    }),
+]);
+export const WorkspaceRecoveryInspectResponseSchema = z.object({
+    type: z.literal("workspace.recovery.inspect.response"),
+    payload: z.object({
+        requestId: z.string(),
+        state: WorkspaceRecoveryStateSchema,
+    }),
+});
+export const WorkspaceRecoveryRestoreResponseSchema = z.object({
+    type: z.literal("workspace.recovery.restore.response"),
+    payload: z.object({
+        requestId: z.string(),
+        workspaceId: z.string(),
+        accepted: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
 export const SetVoiceModeResponseMessageSchema = z.object({
     type: z.literal("set_voice_mode_response"),
     payload: z.object({
@@ -3659,7 +4229,7 @@ export const RunsClearResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
-// Delete one run by id. Terminal (done/failed/canceled) and draft runs only —
+// 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({
@@ -3671,7 +4241,7 @@ 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.
+        // active) - `error` then carries why.
         runId: z.string().optional(),
         error: z.string().optional(),
         requestId: z.string(),
@@ -3786,11 +4356,11 @@ export const RunsTemplatesChangedNotificationSchema = z.object({
     }),
 });
 // Start (or draft) a user-initiated orchestration from the New Orchestration
-// dialog. `flavor` is an open vocabulary: "ai" (prompt-and-go — the daemon
+// 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`).
+// "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
+// `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"),
@@ -3842,7 +4412,7 @@ export const CheckoutGitCommitRequestSchema = z.object({
 });
 // Resolve which agent the daemon would use to author a commit message for this
 // checkout (the "writer" role) so the client can name it in a confirmation
-// before running the AI-authored commit. A pure query — it never commits. Gated
+// before running the AI-authored commit. A pure query - it never commits. Gated
 // by server_info.features.checkoutGitCommitAgent.
 export const CheckoutGitCommitAgentRequestSchema = z.object({
     type: z.literal("checkout.git.commit_agent.request"),
@@ -3894,8 +4464,8 @@ export const CheckoutGitFileCommitDiffRequestSchema = z.object({
     ignoreWhitespace: z.boolean().optional(),
     requestId: z.string(),
 });
-// One page of blame. Always paged — blaming a large file whole would block the
-// daemon — so the client walks the file a page at a time.
+// One page of blame. Always paged - blaming a large file whole would block the
+// daemon - so the client walks the file a page at a time.
 export const CheckoutGitFileBlameRequestSchema = z.object({
     type: z.literal("checkout.git.get_file_blame.request"),
     cwd: z.string(),
@@ -3958,6 +4528,15 @@ export const CheckoutPrMergeRequestSchema = z.object({
     mergeMethod: z.enum(["merge", "squash", "rebase"]),
     requestId: z.string(),
 });
+export const CheckoutForgeSetAutoMergeRequestSchema = z.object({
+    type: z.literal("checkout.forge.set_auto_merge.request"),
+    cwd: z.string(),
+    enabled: z.boolean(),
+    mergeMethod: z.enum(["merge", "squash", "rebase"]).optional(),
+    requestId: z.string(),
+});
+// COMPAT(githubAutoMergeRpc): added in v0.1.106, remove after 2026-12-28 once
+// all supported clients use checkout.forge.set_auto_merge.*.
 export const CheckoutGithubSetAutoMergeRequestSchema = z.object({
     type: z.literal("checkout.github.set_auto_merge.request"),
     cwd: z.string(),
@@ -3965,16 +4544,63 @@ export const CheckoutGithubSetAutoMergeRequestSchema = z.object({
     mergeMethod: z.enum(["merge", "squash", "rebase"]).optional(),
     requestId: z.string(),
 });
+const CheckoutCommitFileSchema = z.object({
+    path: z.string(),
+    additions: z.number(),
+    deletions: z.number(),
+    status: z.enum(["added", "modified", "deleted", "renamed"]).optional(),
+});
+const CheckoutCommitSchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    subject: z.string(),
+    authorName: z.string(),
+    authorDate: z.string(), // ISO 8601
+    isOnRemote: z.boolean(), // false = local-only (unpushed)
+    // COMPAT(commitBaseClassification): added in v0.2.0, remove optional after 2027-01-23.
+    isOnBase: z.boolean().optional(),
+    files: z.array(CheckoutCommitFileSchema),
+});
+export const CheckoutCommitsListRequestSchema = z.object({
+    type: z.literal("checkout.commits.list.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutCommitFileDiffRequestSchema = z.object({
+    type: z.literal("checkout.commits.file_diff.request"),
+    cwd: z.string(),
+    sha: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
 const GitHubRepoSegmentSchema = z.string().regex(/^[A-Za-z0-9._-]+$/);
-export const CheckoutGithubGetCheckDetailsRequestSchema = z.object({
-    type: z.literal("checkout.github.get_check_details.request"),
+const CheckoutCheckDetailsRequestPayloadSchema = z.object({
     cwd: z.string(),
-    repoOwner: GitHubRepoSegmentSchema,
-    repoName: GitHubRepoSegmentSchema,
-    checkRunId: z.number().int().positive(),
+    // GitHub addresses check runs by owner/name. GitLab resolves the project from
+    // cwd and omits these GitHub-only single-segment fields.
+    repoOwner: GitHubRepoSegmentSchema.optional(),
+    repoName: GitHubRepoSegmentSchema.optional(),
+    // Permanently optional: a check addressed only by workflowRunId (Gitea
+    // Actions runs carry no check-run id) is fetchable. Callers send at least one
+    // of checkRunId/workflowRunId; the gated forge RPC only reaches daemons that
+    // understand this.
+    checkRunId: z.number().int().positive().optional(),
     workflowRunId: z.number().int().positive().optional(),
+    // Permanent forge-routing field, optional because only some forges need it:
+    // GitLab routes check details to the MR's head pipeline; Gitea-family adapters
+    // resolve the PR head SHA by number, including after merge/close. GitHub
+    // ignores it.
+    changeRequestNumber: z.number().int().positive().optional(),
     requestId: z.string(),
 });
+export const CheckoutForgeGetCheckDetailsRequestSchema = CheckoutCheckDetailsRequestPayloadSchema.extend({
+    type: z.literal("checkout.forge.get_check_details.request"),
+});
+// COMPAT(githubCheckDetailsRpc): added in v0.1.106, remove after 2026-12-28 once
+// all supported clients use checkout.forge.get_check_details.*.
+export const CheckoutGithubGetCheckDetailsRequestSchema = CheckoutCheckDetailsRequestPayloadSchema.extend({
+    type: z.literal("checkout.github.get_check_details.request"),
+});
 export const CheckoutPrStatusRequestSchema = z.object({
     type: z.literal("checkout_pr_status_request"),
     cwd: z.string(),
@@ -4063,17 +4689,41 @@ export const BranchSuggestionsRequestSchema = z.object({
 });
 export const GitHubSearchItemSchema = z.object({
     kind: z.enum(["issue", "pr"]),
+    forge: z.string().optional(),
     number: z.number(),
     title: z.string(),
     url: z.string(),
     state: z.string(),
     body: z.string().nullable(),
     labels: z.array(z.string()),
+    projectPath: z.string().optional(),
     baseRefName: z.string().nullable().optional(),
     headRefName: z.string().nullable().optional(),
     updatedAt: z.string().optional(),
 });
-export const GitHubSearchKindSchema = z.enum(["github-issue", "github-pr"]);
+export const ForgeSearchItemSchema = GitHubSearchItemSchema.extend({
+    kind: z.enum(["issue", "change_request"]),
+});
+// COMPAT(githubSearchKind): added in v0.1.106, remove with the legacy
+// github_search_request RPC after 2026-12-28.
+export const ForgeSearchKindSchema = z.enum([
+    "issue",
+    "change_request",
+    "github-issue",
+    "github-pr",
+    "pr",
+]);
+export const GitHubSearchKindSchema = ForgeSearchKindSchema;
+export const ForgeSearchRequestSchema = z.object({
+    type: z.literal("forge.search.request"),
+    cwd: z.string(),
+    query: z.string(),
+    limit: z.number().int().min(1).max(50).optional(),
+    kinds: z.array(ForgeSearchKindSchema).optional(),
+    requestId: z.string(),
+});
+// COMPAT(githubSearchRpc): added in v0.1.106, remove after 2026-12-28 once
+// clients use forge.search.*.
 export const GitHubSearchRequestSchema = z.object({
     type: z.literal("github_search_request"),
     cwd: z.string(),
@@ -4094,7 +4744,7 @@ export const HostingSearchRequestSchema = z.object({
     kinds: z.array(HostingSearchKindSchema).optional(),
     requestId: z.string(),
 });
-// Reports whether a host-level provider's credentials are valid — drives the
+// Reports whether a host-level provider's credentials are valid - drives the
 // connection-status row in the host Git providers settings section.
 export const HostingAuthStatusRequestSchema = z.object({
     type: z.literal("hosting.auth_status.request"),
@@ -4154,6 +4804,9 @@ export const CreateOttoWorktreeRequestSchema = z.object({
     firstAgentContext: FirstAgentContextSchema.optional(),
     refName: z.string().min(1).optional(),
     action: z.enum(["branch-off", "checkout"]).optional(),
+    checkoutSource: ChangeRequestCheckoutSourceSchema.optional(),
+    // COMPAT(githubPrNumber): added in v0.1.106, remove after 2026-12-28 once
+    // clients send checkoutSource: { kind: "change_request", forge, number }.
     githubPrNumber: z.number().int().positive().optional(),
     requestId: z.string(),
 });
@@ -4181,6 +4834,8 @@ export const OpenProjectRequestSchema = z.object({
     cwd: z.string(),
     requestId: z.string(),
 });
+// Smallest shorthand repo path is "a/b": owner, slash, repository.
+const MIN_REPOSITORY_PATH_LENGTH = 3;
 export const ProjectAddRequestSchema = z.object({
     type: z.literal("project.add.request"),
     cwd: z.string(),
@@ -4192,10 +4847,10 @@ export const ProjectAddRequestSchema = z.object({
 // 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.
+// 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
+// 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 = [
@@ -4276,12 +4931,41 @@ export const HostingListOwnersRequestSchema = z.object({
     provider: GitHostingProviderIdWireSchema,
     requestId: z.string(),
 });
+export const ProjectCreateDirectoryRequestSchema = z.object({
+    type: z.literal("project.create_directory.request"),
+    parentPath: z.string(),
+    name: z.string(),
+    requestId: z.string(),
+});
+export const GithubRepositorySchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    nameWithOwner: z.string().min(MIN_REPOSITORY_PATH_LENGTH),
+    description: z.string().nullable(),
+    visibility: z.enum(["public", "private", "internal"]),
+    updatedAt: z.string(),
+    cloneUrl: z.string().min(MIN_REPOSITORY_PATH_LENGTH),
+});
+export const WorkspaceGithubSearchRepositoriesRequestSchema = z.object({
+    type: z.literal("workspace.github.search_repositories.request"),
+    query: z.string(),
+    limit: z.number().int().min(1).max(50).optional(),
+    requestId: z.string(),
+});
+export const ProjectGithubCloneProtocolSchema = z.enum(["https", "ssh"]);
+export const ProjectGithubCloneRequestSchema = z.object({
+    type: z.literal("project.github.clone.request"),
+    repo: z.string().trim().min(MIN_REPOSITORY_PATH_LENGTH),
+    cloneProtocol: ProjectGithubCloneProtocolSchema.optional(),
+    targetDirectory: z.string().trim().min(1),
+    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
+    // 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
@@ -4303,7 +4987,7 @@ export const WorkspaceArchivePreflightRequestSchema = z.object({
 // record the answer, and it has to look like one or a wrong guess reads as a bug in the diff.
 // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
 export const CheckoutBaseSourceSchema = z.enum(["user", "inferred", "worktree", "default"]);
-// Repoint a worktree-backed workspace's base branch — what the Changes view diffs
+// 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.
@@ -4313,7 +4997,7 @@ export const WorktreeBaseRefSetRequestSchema = z.object({
     requestId: z.string(),
     workspaceId: z.string(),
     // Branch name; null resets to the default branch. An `origin/` prefix is meaningful and is
-    // kept — `main` and `origin/main` are different comparisons whenever the two have drifted.
+    // kept - `main` and `origin/main` are different comparisons whenever the two have drifted.
     baseRef: z.string().nullable(),
     // Forget the remembered base and detect the branch's parent again, ignoring `baseRef`.
     // The escape hatch for a wrong guess: parent detection is a heuristic over a graph that does
@@ -4350,6 +5034,11 @@ export const WorkspaceCreateRequestSchema = z.object({
             // the repository default.
             refName: z.string().min(1).optional(),
             baseBranch: z.string().optional(),
+            // New branch name for branch-off. The worktree path may use a different slug.
+            branchName: z.string().min(1).optional(),
+            checkoutSource: ChangeRequestCheckoutSourceSchema.optional(),
+            // COMPAT(githubPrNumber): added in v0.1.106, remove after 2026-12-28 once
+            // clients send checkoutSource.
             githubPrNumber: z.number().int().positive().optional(),
             worktreeSlug: z.string().optional(),
         }),
@@ -4439,6 +5128,7 @@ const FileExplorerFileSchema = z.object({
     // inline JSON read path only); old daemons omit both fields.
     eol: FileEolSchema.optional(),
     hash: z.string().optional(),
+    revision: z.string().optional(),
 });
 const FileExplorerDirectorySchema = z.object({
     path: z.string(),
@@ -4452,6 +5142,103 @@ export const FileExplorerRequestSchema = z.object({
     requestId: z.string(),
     acceptBinary: z.boolean().optional(),
 });
+export const FileVersionSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("ready"),
+        cwd: z.string(),
+        path: z.string(),
+        size: z.number().int().nonnegative(),
+        modifiedAt: z.string(),
+        revision: z.string().optional(),
+    }),
+    z.object({
+        status: z.literal("missing"),
+        cwd: z.string(),
+        path: z.string(),
+    }),
+    z.object({
+        status: z.literal("error"),
+        cwd: z.string(),
+        path: z.string(),
+        error: z.string(),
+    }),
+]);
+export const FileSubscribeRequestSchema = z.object({
+    type: z.literal("fs.file.subscribe.request"),
+    cwd: z.string(),
+    path: z.string(),
+    subscriptionId: z.string(),
+    requestId: z.string(),
+});
+export const FileUnsubscribeRequestSchema = z.object({
+    type: z.literal("fs.file.unsubscribe.request"),
+    subscriptionId: z.string(),
+    requestId: z.string(),
+});
+export const FsFileWriteRequestSchema = z.object({
+    type: z.literal("fs.file.write.request"),
+    cwd: z.string(),
+    path: z.string(),
+    content: z.string(),
+    expectedModifiedAt: z.string(),
+    expectedRevision: z.string().optional(),
+    requestId: z.string(),
+});
+/**
+ * Write bytes to a workspace file.
+ *
+ * The counterpart to `fs.file.write`, which is text only: it LF-normalizes,
+ * re-applies the file's detected EOL, and outright refuses to overwrite a file
+ * whose current bytes look binary. None of that can carry a PDF, an image or
+ * any other generated artifact, so those go through here instead - the bytes
+ * land verbatim.
+ *
+ * Deliberately not a conditional write. Callers are producing a generated file
+ * from a source they already hold, so there is no "the file changed under you"
+ * to reconcile: either the caller means to replace what is there or it does
+ * not, and `overwrite` says which. Keeping that explicit is what stops this
+ * from being a clobber-any-path primitive.
+ *
+ * Workspace-bounded, like the create/delete/rename surface and unlike
+ * `file.write`. `file.write` is unbounded because a tab may edit a file the
+ * user opened from anywhere; putting new bytes at an arbitrary path on the host
+ * is a different power and does not need to be that wide.
+ *
+ * The bytes themselves do not ride in this message. They follow it as
+ * `FileTransfer` binary frames correlated on `requestId` - FileBegin, then
+ * FileChunk, then FileEnd - the same transport `file.upload` uses. This request
+ * is the metadata half: where the bytes go and how many of them to expect.
+ * Everything here writes multi-megabyte files (a printed PDF, a dropped image),
+ * and base64 in a JSON message costs a third again on the wire plus the whole
+ * encoded string allocated on both sides and walked by the validator.
+ */
+export const FsFileWriteBinaryRequestSchema = z.object({
+    type: z.literal("fs.file.write_binary.request"),
+    cwd: z.string(),
+    path: z.string(),
+    /**
+     * Byte length of the payload to follow. The daemon refuses a transfer that
+     * overruns it and refuses one that ends short, so a truncated stream fails
+     * loudly instead of landing a half file. Optional only because the base64
+     * form below predates it and carries its own length.
+     */
+    size: z.number().int().nonnegative().optional(),
+    /**
+     * base64. Decoded and written as-is: no EOL translation, no re-encoding.
+     *
+     * COMPAT(binaryWriteBase64): added in v0.7.6, drop this field and its daemon
+     * branch on 2027-02-02. Superseded by `size` plus file-transfer frames. The
+     * daemon still reads it - a field we stopped sending is not a field we stop
+     * accepting - and picks the branch from which of the two is present.
+     */
+    contentBase64: z.string().optional(),
+    /**
+     * Replace an existing file. Absent (the default) an existing target comes
+     * back as `exists` and nothing is written.
+     */
+    overwrite: z.boolean().optional(),
+    requestId: z.string(),
+});
 export const ProjectIconRequestSchema = z.object({
     type: z.literal("project_icon_request"),
     cwd: z.string(),
@@ -4474,7 +5261,7 @@ export const FileUploadRequestSchema = z.object({
 /**
  * Text-editor save. A conditional write: the request carries the client's
  * last-known file identity and the daemon refuses to clobber content it did
- * not hand out — a mismatch comes back as a typed conflict, never a write.
+ * not hand out - a mismatch comes back as a typed conflict, never a write.
  */
 export const FileWriteRequestSchema = z.object({
     type: z.literal("file.write.request"),
@@ -4512,7 +5299,7 @@ export const FileCreateRequestSchema = z.object({
     requestId: z.string(),
 });
 /**
- * Permanent delete — an unlink, not a move to the OS trash. The daemon may be
+ * 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.
@@ -4528,7 +5315,7 @@ export const FileDeleteRequestSchema = z.object({
     requestId: z.string(),
 });
 /**
- * Rename and move are the same operation — a move is a rename whose new path
+ * 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.
@@ -4541,7 +5328,7 @@ export const FileRenameRequestSchema = z.object({
     requestId: z.string(),
 });
 /**
- * Refine — an AI rewrite the user reviews as a diff before anything is written.
+ * 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.
@@ -4569,7 +5356,7 @@ export const FileRefineReferenceSchema = z.object({
 });
 export const FileRefineRequestSchema = z.object({
     type: z.literal("file.refine.request"),
-    // Provider resolution only — which workspace's mini-task chain runs this.
+    // 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
@@ -4690,7 +5477,7 @@ export const CodeRenamePreviewRequestSchema = z.object({
  *
  * 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
+ * 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.
  */
@@ -4706,7 +5493,7 @@ export const CodeRenameApplyRequestSchema = z.object({
     requestId: z.string(),
 });
 /**
- * Undo a run. Carries only the run's id — the daemon holds the before-images.
+ * 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
@@ -4750,8 +5537,8 @@ export const LspServerStopRequestSchema = z.object({
  * 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
+ * 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
@@ -4767,7 +5554,7 @@ export const CodeSolutionListRequestSchema = z.object({
 });
 /**
  * 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
+ * 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({
@@ -4779,7 +5566,7 @@ export const CodeSolutionGetTreeRequestSchema = z.object({
 });
 /**
  * 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
+ * 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({
@@ -4817,7 +5604,7 @@ const FileReplaceMatchSchema = z.object({
 });
 /**
  * Preview-first project replace. Each file carries the hash the preview was
- * built against — files changed since are skipped and reported, never
+ * built against - files changed since are skipped and reported, never
  * corrupted. The replacement string is literal (no capture references in v1).
  */
 export const FileReplaceRequestSchema = z.object({
@@ -4901,6 +5688,16 @@ export const CreateTerminalRequestSchema = z.object({
     agentId: z.string().optional(),
     command: z.string().optional(),
     args: z.array(z.string()).optional(),
+    // Initial PTY size. Added in v0.1.107; the app no longer sends it (the estimate cache that fed
+    // it was removed - the pane-focus resize claim sizes the PTY instead). Kept and honored
+    // permanently: released v0.1.107 clients still send it, and programmatic callers may pass an
+    // exact size. Daemons without it start at 80x24 and the first resize corrects that.
+    size: z
+        .object({
+        rows: z.number().int().positive(),
+        cols: z.number().int().positive(),
+    })
+        .optional(),
     requestId: z.string(),
 });
 export const RenameTerminalRequestSchema = z.object({
@@ -4915,6 +5712,31 @@ export const StartWorkspaceScriptRequestSchema = z.object({
     scriptName: z.string(),
     requestId: z.string(),
 });
+export const WorkspaceScriptListRequestSchema = z.object({
+    type: z.literal("workspace.script.list.request"),
+    workspaceId: z.string(),
+    requestId: z.string(),
+    /**
+     * Also return the Scripts the workspace's own project files declare
+     * (`package.json` scripts, and later Makefile targets, .NET launch profiles),
+     * each tagged with the `source` it came from. Off by default so a client that
+     * predates discovery gets exactly the otto.json list it asked for.
+     * COMPAT(workspaceScriptDiscovery): added in v0.7.6.
+     */
+    includeDiscovered: z.boolean().optional().default(false),
+});
+export const WorkspaceScriptStartRequestSchema = z.object({
+    type: z.literal("workspace.script.start.request"),
+    workspaceId: z.string(),
+    scriptName: z.string(),
+    requestId: z.string(),
+});
+export const WorkspaceScriptStopRequestSchema = z.object({
+    type: z.literal("workspace.script.stop.request"),
+    workspaceId: z.string(),
+    scriptName: z.string(),
+    requestId: z.string(),
+});
 export const SubscribeTerminalRequestSchema = z.object({
     type: z.literal("subscribe_terminal_request"),
     terminalId: z.string(),
@@ -4957,15 +5779,39 @@ export const KillTerminalRequestSchema = z.object({
     terminalId: z.string(),
     requestId: z.string(),
 });
-export const CaptureTerminalRequestSchema = z.object({
-    type: z.literal("capture_terminal_request"),
-    terminalId: z.string(),
-    start: z.number().int().optional(),
-    end: z.number().int().optional(),
-    stripAnsi: z.boolean().default(true),
+export const CaptureTerminalRequestSchema = z.object({
+    type: z.literal("capture_terminal_request"),
+    terminalId: z.string(),
+    start: z.number().int().optional(),
+    end: z.number().int().optional(),
+    stripAnsi: z.boolean().default(true),
+    requestId: z.string(),
+});
+export const HubExecutionAgentCreateRequestSchema = z.object({
+    type: z.literal("hub.execution.agent.create.request"),
+    requestId: z.string(),
+    executionId: z.string(),
+    provider: z.string(),
+    cwd: z.string(),
+    prompt: z.string(),
+    workspaceId: z.string().optional(),
+    model: z.string().optional(),
+    modeId: z.string().optional(),
+    thinkingOptionId: z.string().optional(),
+    featureValues: z.record(z.string(), z.unknown()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    worktree: CreateAgentWorktreeTargetSchema.optional(),
+});
+export const HubExecutionControlActionSchema = z.enum(["interrupt", "archive"]);
+export const HubExecutionControlRequestSchema = z.object({
+    type: z.literal("hub.execution.control.request"),
     requestId: z.string(),
+    executionId: z.string(),
+    action: HubExecutionControlActionSchema,
 });
 export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
+    HubExecutionAgentCreateRequestSchema,
+    HubExecutionControlRequestSchema,
     BrowserAutomationExecuteResponseSchema,
     VoiceAudioChunkMessageSchema,
     AbortRequestMessageSchema,
@@ -4974,6 +5820,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     FetchAgentHistoryRequestMessageSchema,
     FetchRecentProviderSessionsRequestMessageSchema,
     FetchWorkspacesRequestMessageSchema,
+    ProjectListRequestMessageSchema,
     FetchAgentRequestMessageSchema,
     DeleteAgentRequestMessageSchema,
     ArchiveAgentRequestMessageSchema,
@@ -5003,6 +5850,14 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     BrainHfSearchRequestSchema,
     BrainHfQuantsRequestSchema,
     BrainModelsAddRequestSchema,
+    BrainModelsInventoryRequestSchema,
+    BrainModelProfileGetRequestSchema,
+    BrainModelProfileSetRequestSchema,
+    BrainModelBudgetGetRequestSchema,
+    BrainModelLoadRequestSchema,
+    BrainModelUnloadRequestSchema,
+    BrainModelDeleteRequestSchema,
+    BrainLogsTailRequestSchema,
     UpdateAgentRequestMessageSchema,
     ProjectRenameRequestSchema,
     ProjectRemoveRequestSchema,
@@ -5010,15 +5865,23 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProjectLinksSetRequestSchema,
     ProjectLinksUnsetRequestSchema,
     WorkspaceTitleSetRequestSchema,
+    WorkspacePinSetRequestSchema,
+    WorkspaceRecoveryInspectRequestSchema,
+    WorkspaceRecoveryRestoreRequestSchema,
     SetVoiceModeMessageSchema,
     SendAgentMessageRequestSchema,
     WaitForFinishRequestSchema,
     DaemonGetStatusRequestSchema,
     DaemonGetPairingOfferRequestSchema,
+    HubManagementDaemonConnectRequestSchema,
+    HubManagementDaemonGetStatusRequestSchema,
+    HubManagementDaemonDisconnectRequestSchema,
     DiagnosticsRequestSchema,
     GetDaemonConfigRequestMessageSchema,
     SetDaemonConfigRequestMessageSchema,
     ConnectorsListToolsRequestSchema,
+    ConnectorsOauthAuthorizeRequestSchema,
+    ConnectorsOauthDisconnectRequestSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
     SpeechTtsSpeakRequestSchema,
@@ -5061,6 +5924,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     RestartServerRequestMessageSchema,
     DaemonUpdateRequestMessageSchema,
     FetchAgentTimelineRequestMessageSchema,
+    ProviderSubagentListRequestMessageSchema,
+    ProviderSubagentTimelineRequestMessageSchema,
+    SetAgentTimelineSubscriptionRequestMessageSchema,
     AgentForkContextRequestMessageSchema,
     SetAgentModeRequestMessageSchema,
     SetAgentModelRequestMessageSchema,
@@ -5110,7 +5976,11 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutRefreshRequestSchema,
     CheckoutPrCreateRequestSchema,
     CheckoutPrMergeRequestSchema,
+    CheckoutForgeSetAutoMergeRequestSchema,
     CheckoutGithubSetAutoMergeRequestSchema,
+    CheckoutCommitsListRequestSchema,
+    CheckoutCommitFileDiffRequestSchema,
+    CheckoutForgeGetCheckDetailsRequestSchema,
     CheckoutGithubGetCheckDetailsRequestSchema,
     PreviewListConfigRequestSchema,
     PreviewStartRequestSchema,
@@ -5125,6 +5995,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     StashListRequestSchema,
     ValidateBranchRequestSchema,
     BranchSuggestionsRequestSchema,
+    ForgeSearchRequestSchema,
     GitHubSearchRequestSchema,
     HostingSearchRequestSchema,
     HostingAuthStatusRequestSchema,
@@ -5140,6 +6011,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProjectScaffoldRequestSchema,
     HostingListRepositoriesRequestSchema,
     HostingListOwnersRequestSchema,
+    ProjectCreateDirectoryRequestSchema,
+    WorkspaceGithubSearchRepositoriesRequestSchema,
+    ProjectGithubCloneRequestSchema,
     ArchiveWorkspaceRequestSchema,
     WorkspaceArchivePreflightRequestSchema,
     WorktreeBaseRefSetRequestSchema,
@@ -5148,6 +6022,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     WorkspaceCreateRequestSchema,
     WorkspaceClearAttentionRequestSchema,
     FileExplorerRequestSchema,
+    FileSubscribeRequestSchema,
+    FileUnsubscribeRequestSchema,
+    FsFileWriteRequestSchema,
+    FsFileWriteBinaryRequestSchema,
     ProjectIconRequestSchema,
     FileDownloadTokenRequestSchema,
     FileUploadRequestSchema,
@@ -5187,6 +6065,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CreateTerminalRequestSchema,
     RenameTerminalRequestSchema,
     StartWorkspaceScriptRequestSchema,
+    WorkspaceScriptListRequestSchema,
+    WorkspaceScriptStartRequestSchema,
+    WorkspaceScriptStopRequestSchema,
     SubscribeTerminalRequestSchema,
     UnsubscribeTerminalRequestSchema,
     TerminalInputSchema,
@@ -5361,14 +6242,23 @@ export const ServerInfoStatusPayloadSchema = z
     serverId: z.string().trim().min(1),
     hostname: ServerInfoHostnameSchema.optional(),
     version: ServerInfoVersionSchema.optional(),
+    // COMPAT(desktopManaged): added in v0.1.X, remove optional parsing after 2027-01-16.
+    desktopManaged: z.boolean().optional(),
     capabilities: ServerCapabilitiesFromUnknownSchema.optional(),
     // COMPAT(providersSnapshot): added in v0.1.48, remove gating when all clients use snapshot
     features: z
         .object({
         providersSnapshot: z.boolean().optional(),
+        // COMPAT(checkoutForgeSetAutoMerge): added in v0.1.106, remove old
+        // checkoutGithubSetAutoMerge fallback after 2026-12-28.
+        checkoutForgeSetAutoMerge: z.boolean().optional(),
         checkoutGithubSetAutoMerge: z.boolean().optional(),
         // COMPAT(githubCheckDetails): added in v0.1.92, remove gate after 2026-12-08.
         githubCheckDetails: z.boolean().optional(),
+        // COMPAT(forgeCheckDetails): added in v0.1.106, remove githubCheckDetails fallback after 2026-12-28.
+        forgeCheckDetails: z.boolean().optional(),
+        // COMPAT(forgeSearch): added in v0.1.106, remove github_search fallback after 2026-12-28.
+        forgeSearch: z.boolean().optional(),
         // COMPAT(daemonStatusRpc): added in v0.1.76, remove gate after 2026-11-18.
         daemonStatusRpc: z.boolean().optional(),
         // COMPAT(terminalRestoreModes): added in v0.1.81, remove gate after 2026-11-23.
@@ -5391,10 +6281,16 @@ export const ServerInfoStatusPayloadSchema = z
         projectScaffold: z.boolean().optional(),
         // COMPAT(worktreeRestore): added in v0.1.97, drop the gate when floor >= v0.1.97
         worktreeRestore: z.boolean().optional(),
+        // COMPAT(workspaceRecovery): added in v0.1.105, remove after 2027-01-11 once daemon floor >= v0.1.105.
+        workspaceRecovery: z.boolean().optional(),
+        // COMPAT(workspaceFileEditing): added in v0.2.0, remove after 2027-01-18 once daemon floor >= v0.2.0.
+        workspaceFileEditing: z.boolean().optional(),
         // COMPAT(providerUsageList): added in v0.1.98, drop the gate when daemon floor >= v0.1.98.
         providerUsageList: z.boolean().optional(),
         // COMPAT(agentDetach): added in v0.1.98, remove gate after 2026-12-19 once daemon floor >= v0.1.98.
         agentDetach: z.boolean().optional(),
+        // COMPAT(agentThinkingUpdate): added in v0.2.4, remove gate after 2027-01-28.
+        agentThinkingUpdate: z.boolean().optional(),
         // COMPAT(daemonDiagnostics): added in v0.1.100, remove gate after 2026-12-25 once daemon floor >= v0.1.100.
         daemonDiagnostics: z.boolean().optional(),
         // COMPAT(daemonSelfUpdate): added in v0.1.93, remove gate after 2026-12-13.
@@ -5434,6 +6330,16 @@ export const ServerInfoStatusPayloadSchema = z
         // Without it the Brain "Models" section hides the Hugging Face search box.
         // COMPAT(brainHfSearch): added in v0.7.5, remove gate after 2026-07-30 once daemon floor >= v0.7.5.
         brainHfSearch: z.boolean().optional(),
+        // Daemon proxies the brain's own /__host/* management API: the joined
+        // model inventory, per-model profiles, the VRAM budget, load/unload,
+        // delete, and the log tail. Unlike brainManage (which shells out to the
+        // CLI and is therefore local-only) these work against a remote brain too.
+        // Without it the Brain page is not offered at all. Which of those the
+        // brain on the far side actually serves is a separate question, answered
+        // by `capabilities` on brain.host.status, because the daemon and the
+        // brain version independently.
+        // COMPAT(brainConsole): added in v0.7.7, drop the gate when daemon floor >= v0.7.7.
+        brainConsole: z.boolean().optional(),
         // COMPAT(agentForkContext): added in v0.1.102, remove gate after 2026-12-28.
         agentForkContext: z.boolean().optional(),
         // COMPAT(providerRemove): added in v0.1.105, drop the gate when daemon floor >= v0.1.105.
@@ -5456,7 +6362,7 @@ export const ServerInfoStatusPayloadSchema = z
         // 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
+        // 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`
@@ -5467,33 +6373,43 @@ export const ServerInfoStatusPayloadSchema = z
         // 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
+        // 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
-        // warning entirely — there is no degraded client-side fallback, since
+        // warning entirely - there is no degraded client-side fallback, since
         // only the daemon can see the files a provider loads.
         // COMPAT(contextManagement): added in v0.6.5, drop the gate when daemon floor >= v0.6.5.
         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
+        // 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
+        // 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(),
+        // Script discovery - the daemon scans a workspace for the Scripts its
+        // project files already declare (package.json scripts, and later
+        // Makefile targets, .NET launch profiles) and serves them from
+        // `workspace.script.list` with `includeDiscovered`. Without it the
+        // Scripts dropdown shows only what otto.json declares, which is the
+        // pre-existing behavior and not a degraded build of this feature: only
+        // the daemon can read the workspace's files, so there is no client-side
+        // scan to fall back to.
+        // COMPAT(workspaceScriptDiscovery): added in v0.7.6, drop the gate when daemon floor >= v0.7.6.
+        workspaceScriptDiscovery: 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.
@@ -5510,11 +6426,11 @@ export const ServerInfoStatusPayloadSchema = z
         // flag the client says to update the host rather than showing an empty screen.
         // COMPAT(lspHostServers): added in v0.7.3, drop the gate when daemon floor >= v0.7.3.
         lspHostServers: z.boolean().optional(),
-        // The Solution view — the daemon can discover solutions and serve
+        // 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 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.
@@ -5549,7 +6465,7 @@ export const ServerInfoStatusPayloadSchema = z
         // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
         checkoutGitLog: z.boolean().optional(),
         // Local-git file investigation: history, per-commit diff, blame, origin
-        // commit — for a whole file or a line range. No forge connection needed
+        // commit - for a whole file or a line range. No forge connection needed
         // and no per-provider rollout; it is git, so every provider gets it at
         // once.
         // COMPAT(checkoutGitFileHistory): added in v0.6.6, drop the gate when daemon floor >= v0.6.6.
@@ -5558,19 +6474,19 @@ export const ServerInfoStatusPayloadSchema = z
         // 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.
+        // 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
+        // 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 stores the diff base *per branch*, which is what lets any git
-        // checkout repoint it rather than only an Otto worktree — a plain checkout's gitdir is
+        // checkout repoint it rather than only an Otto worktree - a plain checkout's gitdir is
         // shared by every branch in it, so a single stored base would bleed across branch
         // switches. Also gates parent-branch detection, the `origin/`-qualified pin, and the
         // re-detect action. Without it the client keeps the worktree-only picker.
@@ -5626,24 +6542,30 @@ export const ServerInfoStatusPayloadSchema = z
         // cap) shows "Update the host" instead of a knob that does nothing.
         openaiCompatMaxToolRounds: z.boolean().optional(),
         // COMPAT(mcpToolGroups): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
-        // Set when the daemon honors `mcp.toolGroups` — per-group gating of the
+        // Set when the daemon honors `mcp.toolGroups` - per-group gating of the
         // Otto tool catalog on the MCP (Claude) path. Old daemons register every
         // group regardless, so the client hides the categorized section instead
         // of showing category switches that do nothing.
         mcpToolGroups: z.boolean().optional(),
         // COMPAT(connectors): added in v0.7.5, drop the gate when daemon floor >= v0.7.5.
-        // Set when the daemon persists and honors `connectors` — MCP servers
+        // Set when the daemon persists and honors `connectors` - MCP servers
         // surfaced as named, toggle-able integrations with per-tool disable,
         // enforced today on the openai-compat path. Old daemons ignore the
         // section, so the client hides the Connectors settings entirely.
         connectors: z.boolean().optional(),
+        // COMPAT(connectorOauth): added in v0.7.7, drop the gate when daemon floor >= v0.7.7.
+        // Set when the daemon can run the OAuth authorization-code flow for a
+        // connector and attach the resulting token to its MCP transport. Old
+        // daemons have no broker and no way to hold a token, so the client hides
+        // Connect / Disconnect and offers only the paste-a-token connectors.
+        connectorOauth: z.boolean().optional(),
         // COMPAT(agentBehaviorToggles): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
         // Set when the daemon persists `agentBehaviors.*` (promptSuggestions,
         // agentProgressSummaries, notifyOnFinishDefault). The reads are wired by
         // Claude-tier providers (WP-E); the client gates the toggle cards on this.
         agentBehaviorToggles: z.boolean().optional(),
         // COMPAT(todoReminders): added in v0.7.5, drop the gate when daemon floor >= v0.7.5.
-        // Set when the daemon acts on `agentBehaviors.{todoNudge,todoReconcileOnIdle}` —
+        // Set when the daemon acts on `agentBehaviors.{todoNudge,todoReconcileOnIdle}` -
         // the provider-agnostic stale-todo nudge (next turn) and idle reconcile pass.
         // The client gates the task-list toggle cards on this so an old daemon never
         // shows switches that do nothing.
@@ -5674,20 +6596,27 @@ export const ServerInfoStatusPayloadSchema = z
         // 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
+        // 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.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(),
+        // COMPAT(binaryFileWrite): added in v0.7.6, drop the gate when daemon
+        // floor >= v0.7.6. Set when the daemon serves
+        // `fs.file.write_binary` - bytes to a workspace path, as opposed to
+        // `fs.file.write`, which is text and refuses binary targets outright.
+        // The client cannot write a workspace file itself on any platform, so
+        // an old daemon simply does not offer the exports that produce bytes.
+        binaryFileWrite: z.boolean().optional(),
         // COMPAT(attachmentStorage): added in v0.7.1, drop the gate when daemon floor >= v0.7.1.
         // Set when the daemon serves `attachments.images.get_stats` and
-        // `attachments.images.clear` — the readout and reclaim for the images it
+        // `attachments.images.clear` - the readout and reclaim for the images it
         // materializes on the agent's behalf. The client has no way to size or
         // clear a directory on the host, so an old daemon simply does not get
         // the daemon half of the Storage section; the app-side preview cache row
@@ -5695,10 +6624,44 @@ export const ServerInfoStatusPayloadSchema = z
         attachmentStorage: z.boolean().optional(),
         // COMPAT(agentWorkspaceTransfer): added in v0.7.4, drop the gate when
         // daemon floor >= v0.7.4. Set when the daemon serves
-        // `agent.workspace.transfer` — moving a chat to another workspace over
+        // `agent.workspace.transfer` - moving a chat to another workspace over
         // the same directory. The client cannot restamp ownership itself (it is
         // daemon state), so an old daemon simply does not get the menu item.
         agentWorkspaceTransfer: z.boolean().optional(),
+        // COMPAT(agentForkContextCursor): added in v0.1.108, remove gate after 2027-01-14.
+        agentForkContextCursor: z.boolean().optional(),
+        // COMPAT(providerSubagents): added in v0.1.107, remove gate after 2027-01-12.
+        providerSubagents: z.boolean().optional(),
+        // COMPAT(workspacePinning): added in v0.1.107, remove gate after 2027-01-12.
+        workspacePinning: z.boolean().optional(),
+        // COMPAT(hubRelationship): added in v0.1.X, drop the gate when floor >= v0.1.X.
+        hubRelationship: z.boolean().optional(),
+        // COMPAT(projectGithubClone): added in v0.1.108, remove gate after 2027-01-15.
+        projectGithubClone: z.boolean().optional(),
+        // COMPAT(workspaceGithubRepositorySearch): added in v0.1.108, remove gate after 2027-01-15.
+        workspaceGithubRepositorySearch: z.boolean().optional(),
+        // COMPAT(projectCreateDirectory): added in v0.1.108, remove gate after 2027-01-15.
+        projectCreateDirectory: z.boolean().optional(),
+        // COMPAT(projectList): added in v0.2.4, drop the gate when floor >= v0.2.4.
+        projectList: z.boolean().optional(),
+        // COMPAT(commitsList): added in v0.1.110, remove gate after 2027-01-16.
+        commitsList: z.boolean().optional(),
+        // COMPAT(commitBaseClassification): added in v0.2.0, remove gate after 2027-01-23.
+        commitBaseClassification: z.boolean().optional(),
+        // COMPAT(providerRemoval): added in v0.1.105, drop the gate when floor >= v0.1.105.
+        providerRemoval: z.boolean().optional(),
+        // COMPAT(importSessionWorkspaceTarget): added in v0.1.110, remove gate after 2027-01-16.
+        importSessionWorkspaceTarget: z.boolean().optional(),
+        // COMPAT(forgeProviders): added in v0.1.106, drop the gate when daemon floor >= v0.1.106.
+        // Daemon advertises pluggable non-GitHub forge support (the forge registry);
+        // the client gates non-GitHub setup UI on it.
+        forgeProviders: z.boolean().optional(),
+        // COMPAT(selectiveAgentTimeline): added in v0.1.106, remove after 2027-01-12.
+        selectiveAgentTimeline: z.boolean().optional(),
+        // COMPAT(stableProjectIdentity): added in v0.1.109, remove gate after 2027-01-15.
+        stableProjectIdentity: z.boolean().optional(),
+        // COMPAT(workspaceScriptManagement): added in v0.1.105, remove gate after 2027-01-10.
+        workspaceScriptManagement: z.boolean().optional(),
     })
         .optional(),
 })
@@ -5787,7 +6750,7 @@ export const DaemonConfigChangedStatusPayloadSchema = z
  * 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
+ * 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
@@ -5810,11 +6773,11 @@ export const CodeDiagnosticSchema = z.object({
     endColumn: z.number().int().positive(),
     severity: CodeDiagnosticSeveritySchema,
     message: z.string(),
-    /** Who says so — `ts`, `pyright`, a linter behind the server. */
+    /** 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. */
+    /** 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(),
@@ -5825,7 +6788,7 @@ export const CodeDiagnosticSchema = z.object({
  * 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
+ * **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
@@ -5918,8 +6881,50 @@ export const ProjectPlacementPayloadSchema = z.object({
 });
 export const WorkspaceScriptLifecycleSchema = z.enum(["running", "stopped"]);
 export const WorkspaceScriptHealthSchema = z.enum(["healthy", "unhealthy"]);
+export const WorkspaceScriptSourcePayloadSchema = z.object({
+    /** Stable provider id; also the prefix of every `scriptName` it produces. */
+    id: z.string(),
+    /** The tool half of the dropdown's group header, e.g. "npm" or "pnpm". */
+    label: z.string(),
+    /**
+     * Repo-relative file the script was read from, e.g. "package.json".
+     *
+     * Plain-optional rather than defaulted, matching `label` and `command` on the
+     * payload: absent means unknown. A discovery run knows the file, but the
+     * descriptor's orphan path recovers a source from a qualified runtime name
+     * alone (`npm:dev`) and has no discovery behind it to ask. A `.default(null)`
+     * here would make the field required on the output type and force that path
+     * to invent an answer it does not have.
+     */
+    file: z.string().nullable().optional(),
+});
 export const WorkspaceScriptPayloadSchema = z.object({
+    /**
+     * The launch/stop key, unique within a workspace. Otto's own otto.json
+     * scripts use their bare name; a discovered one is qualified by its source
+     * ("npm:build") so two sources offering "build" cannot collide in the
+     * runtime store or the service-proxy hostname.
+     */
     scriptName: z.string(),
+    /**
+     * What to show instead of `scriptName` - the name the project itself uses.
+     * COMPAT(workspaceScriptDiscovery): added in v0.7.6; absent ⇒ show `scriptName`.
+     */
+    label: z.string().optional(),
+    /**
+     * Where this Script came from. Absent ⇒ declared in otto.json, which is the
+     * only kind that existed before discovery and the only kind that may own a
+     * service-proxy route.
+     * COMPAT(workspaceScriptDiscovery): added in v0.7.6.
+     */
+    source: WorkspaceScriptSourcePayloadSchema.optional(),
+    /**
+     * The command the Script runs, for the row's subtitle. Left plain-optional
+     * rather than defaulted so an existing payload that never carried a command
+     * stays valid without gaining a field it has no answer for.
+     * COMPAT(workspaceScriptDiscovery): added in v0.7.6; absent ⇒ no subtitle.
+     */
+    command: z.string().nullable().optional(),
     type: z.enum(["script", "service"]).optional().default("service"),
     hostname: z.string(),
     port: z.number().int().positive().nullable(),
@@ -6003,7 +7008,9 @@ export const WorkspaceDescriptorPayloadSchema = z
     projectRootPath: z.string(),
     workspaceDirectory: z.string().optional(),
     projectKind: z.enum(["git", "non_git", "directory"]),
-    // COMPAT(workspaces): keep legacy directory workspace kind parseable.
+    // COMPAT(workspaces): keep the legacy "directory" workspace kind parseable.
+    // Persisted registries still carry it and there is no migration, so this
+    // stays until a migration retires the kind rather than expiring on a date.
     workspaceKind: z.enum(["directory", "local_checkout", "checkout", "worktree"]),
     name: z.string(),
     // COMPAT(workspaceTitles): added in v0.1.97, drop the optional gate when floor >= v0.1.97.
@@ -6012,6 +7019,8 @@ export const WorkspaceDescriptorPayloadSchema = z
     // its input and offer a "reset to branch name" action. Null means the name
     // is derived from the branch/directory.
     title: z.string().nullable().optional(),
+    // COMPAT(workspacePinning): added in v0.1.107, remove optional after 2027-01-12.
+    pinnedAt: z.string().nullable().optional(),
     archivingAt: z.string().nullable().optional().default(null),
     status: WorkspaceStateBucketSchema,
     // Best-effort workspace status entry timestamp. Old daemons omit the
@@ -6033,6 +7042,10 @@ export const WorkspaceDescriptorPayloadSchema = z
     scripts: z.array(WorkspaceScriptPayloadSchema).default([]),
     gitRuntime: WorkspaceGitRuntimePayloadSchema,
     githubRuntime: WorkspaceGitHubRuntimePayloadSchema,
+    // COMPAT(forge): added in v0.1.106, remove after 2026-12-27. The forge resolved
+    // for this workspace, so the sidebar/hover-card render the right brand mark.
+    // Old daemons omit it; absent means the client falls back to GitHub.
+    forge: z.string().optional(),
     project: ProjectPlacementPayloadSchema.optional(),
 })
     .transform((workspace) => ({
@@ -6124,6 +7137,8 @@ export const FetchRecentProviderSessionsResponseMessageSchema = z.object({
 // workspace is archived.
 export const WorkspaceProjectDescriptorPayloadSchema = z.object({
     projectId: z.string(),
+    // COMPAT(projectKey): added in v0.2.4 on 2026-07-28; remove optional after 2027-01-28.
+    projectKey: z.string().optional(),
     projectDisplayName: z.string(),
     projectCustomName: z.string().nullable().optional(),
     projectRootPath: z.string(),
@@ -6171,7 +7186,7 @@ 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
+// 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.
@@ -6185,6 +7200,20 @@ export const ProjectUpdatedNotificationSchema = z.object({
         hasActiveWorkspaces: z.boolean(),
     }),
 });
+export const ProjectUpdateMessageSchema = z.object({
+    type: z.literal("project.update"),
+    payload: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("upsert"), project: WorkspaceProjectDescriptorPayloadSchema }),
+        z.object({ kind: z.literal("remove"), projectId: z.string() }),
+    ]),
+});
+export const ProjectListResponseMessageSchema = z.object({
+    type: z.literal("project.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        projects: z.array(WorkspaceProjectDescriptorPayloadSchema),
+    }),
+});
 export const ScriptStatusUpdateMessageSchema = z.object({
     type: z.literal("script_status_update"),
     payload: z.object({
@@ -6238,7 +7267,7 @@ 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
+        // 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
@@ -6316,6 +7345,70 @@ export const HostingListOwnersResponseSchema = z.object({
         error: z.string().nullable(),
     }),
 });
+export const ProjectCreateDirectoryErrorCodeSchema = z.enum([
+    "invalid_name",
+    "parent_directory_not_found",
+    "directory_exists",
+    "permission_denied",
+    "registration_failed",
+    "filesystem_error",
+]);
+export const ProjectCreateDirectoryResponseSchema = z.object({
+    type: z.literal("project.create_directory.response"),
+    payload: z.object({
+        requestId: z.string(),
+        directoryPath: z.string().nullable(),
+        project: WorkspaceProjectDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
+        // Error codes are open-ended on the wire so older clients can still parse
+        // responses after a newer daemon learns another failure reason.
+        errorCode: z.string().nullable(),
+    }),
+});
+export const WorkspaceGithubSearchRepositoriesResponseSchema = z.object({
+    type: z.literal("workspace.github.search_repositories.response"),
+    payload: z.discriminatedUnion("status", [
+        z.object({
+            status: z.literal("success"),
+            requestId: z.string(),
+            repositories: z.array(GithubRepositorySchema),
+            available: z.literal(true),
+            error: z.null(),
+        }),
+        z.object({
+            status: z.literal("unavailable"),
+            requestId: z.string(),
+            repositories: z.array(GithubRepositorySchema),
+            reason: z.literal("gh_missing"),
+            available: z.literal(false),
+            error: z.string(),
+        }),
+        z.object({
+            status: z.literal("unauthenticated"),
+            requestId: z.string(),
+            repositories: z.array(GithubRepositorySchema),
+            available: z.literal(false),
+            error: z.string(),
+        }),
+        z.object({
+            status: z.literal("error"),
+            requestId: z.string(),
+            repositories: z.array(GithubRepositorySchema),
+            available: z.literal(true),
+            error: z.string(),
+        }),
+    ]),
+});
+export const ProjectGithubCloneResponseSchema = z.object({
+    type: z.literal("project.github.clone.response"),
+    payload: z.object({
+        requestId: z.string(),
+        repo: z.string().trim().min(MIN_REPOSITORY_PATH_LENGTH),
+        checkoutPath: z.string().nullable(),
+        project: WorkspaceProjectDescriptorPayloadSchema.nullable(),
+        error: z.string().nullable(),
+    }),
+});
 export const StartWorkspaceScriptResponseMessageSchema = z.object({
     type: z.literal("start_workspace_script_response"),
     payload: z.object({
@@ -6326,6 +7419,26 @@ export const StartWorkspaceScriptResponseMessageSchema = z.object({
         error: z.string().nullable(),
     }),
 });
+const WorkspaceScriptOperationPayloadSchema = z.object({
+    requestId: z.string(),
+    workspaceId: z.string(),
+    scriptName: z.string().optional(),
+    script: WorkspaceScriptPayloadSchema.nullable().optional(),
+    scripts: z.array(WorkspaceScriptPayloadSchema).optional(),
+    error: z.string().nullable(),
+});
+export const WorkspaceScriptListResponseMessageSchema = z.object({
+    type: z.literal("workspace.script.list.response"),
+    payload: WorkspaceScriptOperationPayloadSchema,
+});
+export const WorkspaceScriptStartResponseMessageSchema = z.object({
+    type: z.literal("workspace.script.start.response"),
+    payload: WorkspaceScriptOperationPayloadSchema,
+});
+export const WorkspaceScriptStopResponseMessageSchema = z.object({
+    type: z.literal("workspace.script.stop.response"),
+    payload: WorkspaceScriptOperationPayloadSchema,
+});
 // COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer parse daemon editor RPC responses.
 export const LegacyListAvailableEditorsResponseMessageSchema = z.object({
     type: z.literal("list_available_editors_response"),
@@ -6363,7 +7476,7 @@ export const ArchiveWorkspaceResponseMessageSchema = z.object({
 // 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
+    // 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.
@@ -6373,7 +7486,7 @@ export const WorktreeArchiveBranchDetectionSchema = z.object({
     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
+    // 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
@@ -6490,6 +7603,106 @@ export const FetchAgentTimelineResponseMessageSchema = z.object({
         error: z.string().nullable(),
     }),
 });
+export const ProviderSubagentDescriptorPayloadSchema = z.object({
+    id: z.string(),
+    parentAgentId: z.string(),
+    provider: AgentProviderSchema,
+    title: z.string().nullable(),
+    description: z.string().nullable(),
+    status: z.enum(["running", "completed", "failed", "canceled"]),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    toolCallId: z.string().nullable(),
+    cwd: z.string().nullable().optional(),
+});
+export const ProviderSubagentListResponseMessageSchema = z.object({
+    type: z.literal("agent.provider_subagents.list.response"),
+    payload: z.object({
+        requestId: z.string(),
+        parentAgentId: z.string(),
+        subagents: z.array(ProviderSubagentDescriptorPayloadSchema),
+        error: z.string().nullable(),
+    }),
+});
+export const ProviderSubagentTimelineResponseMessageSchema = z.object({
+    type: z.literal("agent.provider_subagents.timeline.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        parentAgentId: z.string(),
+        subagentId: z.string(),
+        provider: AgentProviderSchema.nullable(),
+        direction: z.enum(["tail", "before", "after"]),
+        epoch: z.string(),
+        reset: z.boolean(),
+        staleCursor: z.boolean(),
+        gap: z.boolean(),
+        window: z.object({
+            minSeq: z.number().int().nonnegative(),
+            maxSeq: z.number().int().nonnegative(),
+            nextSeq: z.number().int().nonnegative(),
+        }),
+        hasOlder: z.boolean(),
+        hasNewer: z.boolean(),
+        rows: z.array(z.object({
+            item: AgentTimelineItemPayloadSchema,
+            timestamp: z.string(),
+            seq: z.number().int().nonnegative(),
+        })),
+        error: z.string().nullable(),
+    }),
+});
+export const ProviderSubagentUpdateMessageSchema = z.object({
+    type: z.literal("agent.provider_subagents.update"),
+    payload: z.discriminatedUnion("kind", [
+        z.object({
+            kind: z.literal("upsert"),
+            subagent: ProviderSubagentDescriptorPayloadSchema,
+        }),
+        z.object({
+            kind: z.literal("timeline"),
+            parentAgentId: z.string(),
+            subagentId: z.string(),
+            provider: AgentProviderSchema,
+            item: AgentTimelineItemPayloadSchema,
+            timestamp: z.string(),
+            seq: z.number().int().nonnegative(),
+            epoch: z.string(),
+        }),
+        z.object({
+            kind: z.literal("remove"),
+            parentAgentId: z.string(),
+            subagentId: z.string(),
+        }),
+    ]),
+});
+export const SetAgentTimelineSubscriptionResponseMessageSchema = z.object({
+    type: z.literal("agent.timeline.set_subscription.response"),
+    payload: z.object({
+        agentIds: z.array(z.string()),
+        requestId: z.string(),
+    }),
+});
+export const AgentAttentionRequiredMessageSchema = z.object({
+    type: z.literal("agent_attention_required"),
+    payload: z.object({
+        agentId: z.string(),
+        reason: z.enum(["finished", "error", "permission"]),
+        timestamp: z.string(),
+        shouldNotify: z.boolean(),
+        notification: z
+            .object({
+            title: z.string(),
+            body: z.string(),
+            data: z.object({
+                serverId: z.string(),
+                workspaceId: z.string().optional(),
+                agentId: z.string(),
+                reason: z.enum(["finished", "error", "permission"]),
+            }),
+        })
+            .optional(),
+    }),
+});
 export const AgentForkContextResponseMessageSchema = z.object({
     type: z.literal("agent.fork_context.response"),
     payload: z.object({
@@ -6498,6 +7711,7 @@ export const AgentForkContextResponseMessageSchema = z.object({
         attachment: TextAttachmentSchema.nullable(),
         itemCount: z.number().int().nonnegative(),
         boundaryMessageId: z.string().nullable(),
+        boundaryCursor: AgentTimelineCursorSchema.nullable().optional(),
         error: z.string().nullable(),
     }),
 });
@@ -6509,7 +7723,7 @@ export const AgentQueueRemoveResponseMessageSchema = z.object({
         /**
          * 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.
+         * 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.
@@ -6558,6 +7772,7 @@ export const CancelAgentResponseMessageSchema = z.object({
         // can say "nothing to stop" instead of silently no-oping. Purely additive;
         // absent ⇒ unknown (old daemon). See docs/agent-lifecycle.md (Item 2).
         cancelled: z.boolean().optional(),
+        error: z.string().nullable().optional(),
     }),
 });
 export const ClearAgentAttentionResponseMessageSchema = z.object({
@@ -6603,7 +7818,7 @@ export const SendAgentMessageResponseMessageSchema = z.object({
         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
+        // 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(),
@@ -6766,6 +7981,37 @@ export const DaemonGetStatusResponseSchema = z.object({
     })
         .passthrough(),
 });
+export const HubRelationshipStatusSchema = z.object({
+    state: z.enum([
+        "not_connected",
+        "connecting",
+        "connected",
+        "reconnecting",
+        "disconnecting",
+        "revoked",
+    ]),
+    daemonId: z.string().nullable(),
+    hubOrigin: z.string().nullable(),
+    scopes: z.array(z.string()),
+    connectedAt: z.string().nullable(),
+    lastError: z.string().nullable(),
+});
+export const HubManagementDaemonConnectResponseSchema = z.object({
+    type: z.literal("hub.management.daemon.connect.response"),
+    payload: z.object({ requestId: z.string(), status: HubRelationshipStatusSchema }),
+});
+export const HubManagementDaemonGetStatusResponseSchema = z.object({
+    type: z.literal("hub.management.daemon.get_status.response"),
+    payload: z.object({ requestId: z.string(), status: HubRelationshipStatusSchema }),
+});
+export const HubManagementDaemonDisconnectResponseSchema = z.object({
+    type: z.literal("hub.management.daemon.disconnect.response"),
+    payload: z.object({
+        requestId: z.string(),
+        status: HubRelationshipStatusSchema,
+        warning: z.string().optional(),
+    }),
+});
 export const DaemonGetPairingOfferResponseSchema = z.object({
     type: z.literal("daemon.get_pairing_offer.response"),
     payload: z
@@ -6979,8 +8225,7 @@ const CheckoutPrGithubRepositoryPolicySchema = z
     rebaseMergeAllowed: false,
     viewerDefaultMergeMethod: null,
 });
-const CheckoutPrGithubStatusSchema = z
-    .object({
+const CheckoutPrGithubStatusObjectSchema = z.object({
     mergeStateStatus: z.string().nullable().optional().default(null),
     autoMergeRequest: CheckoutPrGithubAutoMergeRequestSchema,
     viewerCanEnableAutoMerge: z.boolean().optional().default(false),
@@ -6990,9 +8235,23 @@ const CheckoutPrGithubStatusSchema = z
     repository: CheckoutPrGithubRepositoryPolicySchema,
     isMergeQueueEnabled: z.boolean().optional().default(false),
     isInMergeQueue: z.boolean().optional().default(false),
-})
-    .optional();
+});
+const CheckoutPrGithubStatusSchema = CheckoutPrGithubStatusObjectSchema.optional();
+// The open facts envelope for forge-specific PR facts. Permanent - non-GitHub
+// forges deliver their native facts through it. The transitional piece is the
+// `github` mirror above, which stays populated for clients predating this
+// envelope; see COMPAT(forgeSpecific) in status-projection.ts for the shim.
+//
+// NOTE: `forgeSpecific.forge` is a FACTS-FAMILY tag, not the workspace brand id.
+// The whole Gitea family (gitea, forgejo, codeberg) emits `forge: "gitea"` here
+// because they share one facts shape, while the top-level `forge` above carries
+// the specific brand. Validation of family-specific payloads happens at runtime
+// in the consumer that knows that forge family.
+const CheckoutPrForgeSpecificSchema = z.unknown().optional();
 export const CheckoutPrStatusSchema = z.object({
+    // COMPAT(forge): added in v0.1.106, remove the default after 2026-12-27 once daemon floor >= v0.1.106.
+    forge: z.string().optional().default("github"),
+    projectPath: z.string().optional(),
     number: z.number().optional(),
     url: z.string(),
     title: z.string(),
@@ -7025,6 +8284,14 @@ export const CheckoutPrStatusSchema = z.object({
     github: CheckoutPrGithubStatusSchema,
     // Provider-neutral per-PR hosting facts. Absent from old daemons; for
     // GitHub projects both this and the legacy `github` field are populated.
+    //
+    // NOT a shim, and deliberately untagged: this does not collapse into `forge`.
+    // Otto registers every hosting provider into the forge registry under the
+    // forge id `github`, which is the provider-routing facade rather than the gh
+    // CLI (bootstrap.ts, `createGitHostingResolver`). So `forge` reads "github"
+    // for a Bitbucket workspace and only `hosting.provider` carries the truth.
+    // The two disagree by design; a reader wanting the real provider must use
+    // this field.
     hosting: z
         .object({
         provider: GitHostingProviderIdWireSchema,
@@ -7038,7 +8305,9 @@ export const CheckoutPrStatusSchema = z.object({
             .optional(),
     })
         .optional(),
+    forgeSpecific: CheckoutPrForgeSpecificSchema,
 });
+export const ForgeAuthStateSchema = z.unknown().optional();
 const CheckoutPrStatusPayloadSchema = z.object({
     cwd: z.string(),
     status: CheckoutPrStatusSchema.nullable(),
@@ -7048,6 +8317,9 @@ const CheckoutPrStatusPayloadSchema = z.object({
     githubFeaturesEnabled: z.boolean(),
     // Provider-neutral enablement. Present even when status is null so clients
     // can drive search/create-PR affordances for the workspace's provider.
+    // Permanent for the same reason as the `hosting` block on the PR status
+    // schema above: `forge` is a routing-facade id and cannot answer "which
+    // provider is this really".
     hosting: z
         .object({
         provider: GitHostingProviderIdWireSchema,
@@ -7055,6 +8327,13 @@ const CheckoutPrStatusPayloadSchema = z.object({
         capabilities: GitHostingCapabilitiesSchema.optional(),
     })
         .optional(),
+    // COMPAT(forgeAuthState): added in v0.1.106, remove after 2026-12-27. Optional richer
+    // signal that supersedes githubFeaturesEnabled. The legacy boolean stays for old clients
+    // and may remain true for non-auth error payloads so old clients still show the error.
+    // Drop the boolean once the daemon floor >= v0.1.106.
+    authState: ForgeAuthStateSchema,
+    // COMPAT(forge): added in v0.1.106, remove the default after 2026-12-27 once daemon floor >= v0.1.106.
+    forge: z.string().optional().default("github"),
     error: CheckoutErrorSchema.nullable(),
     requestId: z.string(),
 });
@@ -7082,6 +8361,8 @@ const CheckoutDiffSubscriptionPayloadSchema = z.object({
     cwd: z.string(),
     files: z.array(ParsedDiffFileSchema),
     error: CheckoutErrorSchema.nullable(),
+    // COMPAT(diffTooLarge): added in v0.2.4, keep optional until the daemon floor is v0.2.4.
+    diffTooLarge: z.boolean().optional(),
 });
 export const SubscribeCheckoutDiffResponseSchema = z.object({
     type: z.literal("subscribe_checkout_diff_response"),
@@ -7232,7 +8513,7 @@ export const GitFileHistoryEntrySchema = z.object({
     authoredAt: z.number(),
     committerName: z.string(),
     committedAt: z.number(),
-    // The file's name at this commit — differs from the requested path across a
+    // The file's name at this commit - differs from the requested path across a
     // rename. Diff requests must echo this one back, not the current name.
     path: z.string(),
     previousPath: z.string().optional(),
@@ -7263,7 +8544,7 @@ export const CheckoutGitFileCommitDiffResponseSchema = z.object({
         diff: z.string(),
         // Highlighted/parsed form of the same diff, when it parsed cleanly.
         structured: z.array(ParsedDiffFileSchema).optional(),
-        // The file's previous revision — the diff's left-hand side, and the honest
+        // The file's previous revision - the diff's left-hand side, and the honest
         // label for it. Absent when this revision created the file.
         previousSha: z.string().optional(),
         previousPath: z.string().optional(),
@@ -7378,6 +8659,18 @@ export const CheckoutPrMergeResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+export const CheckoutForgeSetAutoMergeResponseSchema = z.object({
+    type: z.literal("checkout.forge.set_auto_merge.response"),
+    payload: z.object({
+        cwd: z.string(),
+        enabled: z.boolean(),
+        success: z.boolean(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+// COMPAT(githubAutoMergeRpc): added in v0.1.106, remove after 2026-12-28 once
+// all supported clients use checkout.forge.set_auto_merge.*.
 export const CheckoutGithubSetAutoMergeResponseSchema = z.object({
     type: z.literal("checkout.github.set_auto_merge.response"),
     payload: z.object({
@@ -7454,6 +8747,29 @@ export const PreviewStopResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+export const CheckoutCommitsListResponseSchema = z.object({
+    type: z.literal("checkout.commits.list.response"),
+    payload: z.object({
+        cwd: z.string(),
+        baseRef: z.string().nullable(),
+        commits: z.array(CheckoutCommitSchema),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutCommitFileDiffResponseSchema = z.object({
+    type: z.literal("checkout.commits.file_diff.response"),
+    payload: z.object({
+        cwd: z.string(),
+        sha: z.string(),
+        path: z.string(),
+        // null when the file is absent from the commit or carries no textual diff
+        // (e.g. binary-only changes).
+        file: ParsedDiffFileSchema.nullable(),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
 const CheckoutGithubCheckAnnotationSchema = z.object({
     path: z.string().optional(),
     startLine: z.number().optional(),
@@ -7472,6 +8788,31 @@ const CheckoutGithubCheckJobSchema = z.object({
     logTail: z.string().optional(),
     logTruncated: z.boolean().optional(),
 });
+// Statuses stay open strings so future forge values cannot break parsing.
+const CheckoutPipelineJobSchema = z.object({
+    id: z.number(),
+    name: z.string(),
+    stage: z.string(),
+    status: z.string(),
+    rawStatus: z.string(),
+    url: z.string().nullable().optional().default(null),
+    allowFailure: z.boolean().optional().default(false),
+    durationSeconds: z.number().nullable().optional().default(null),
+});
+const CheckoutPipelineStageSchema = z.object({
+    name: z.string(),
+    status: z.string(),
+    jobs: z.array(CheckoutPipelineJobSchema).optional().default([]),
+});
+const CheckoutPipelineSchema = z.object({
+    id: z.number(),
+    status: z.string(),
+    rawStatus: z.string(),
+    url: z.string().nullable().optional().default(null),
+    ref: z.string().nullable().optional().default(null),
+    sha: z.string().nullable().optional().default(null),
+    stages: z.array(CheckoutPipelineStageSchema).optional().default([]),
+});
 export const CheckoutGithubCheckDetailsSchema = z.object({
     checkRunId: z.number(),
     workflowRunId: z.number().nullable().optional(),
@@ -7491,13 +8832,28 @@ export const CheckoutGithubCheckDetailsSchema = z.object({
     annotations: z.array(CheckoutGithubCheckAnnotationSchema).optional().default([]),
     failedJobs: z.array(CheckoutGithubCheckJobSchema).optional().default([]),
     truncated: z.boolean().optional().default(false),
+    // No default: server CheckDetails keeps this optional and GitHub leaves it absent.
+    pipeline: CheckoutPipelineSchema.nullable().optional(),
 });
+export const CheckoutCheckDetailsSchema = CheckoutGithubCheckDetailsSchema;
+export const CheckoutForgeGetCheckDetailsResponseSchema = z.object({
+    type: z.literal("checkout.forge.get_check_details.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        details: CheckoutCheckDetailsSchema.nullable().optional().default(null),
+        error: CheckoutErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+// COMPAT(githubCheckDetailsRpc): added in v0.1.106, remove after 2026-12-28 once
+// all supported clients use checkout.forge.get_check_details.*.
 export const CheckoutGithubGetCheckDetailsResponseSchema = z.object({
     type: z.literal("checkout.github.get_check_details.response"),
     payload: z.object({
         cwd: z.string(),
         success: z.boolean(),
-        details: CheckoutGithubCheckDetailsSchema.nullable().optional().default(null),
+        details: CheckoutCheckDetailsSchema.nullable().optional().default(null),
         error: CheckoutErrorSchema.nullable(),
         requestId: z.string(),
     }),
@@ -7557,6 +8913,16 @@ const PullRequestTimelineCommentItemSchema = z.object({
     // threads under their parent review. Absent on issue comments and on
     // timelines from daemons that predate the field.
     reviewId: z.string().optional(),
+    // Forge-neutral discussion/thread id this comment belongs to, independent of a
+    // file position. GitLab maps its discussion id here so general (non-file)
+    // reply chains group into one thread; file-position threads also carry it.
+    // Absent on standalone comments and on timelines from daemons that predate it.
+    threadId: z.string().optional(),
+    // Forge-neutral resolution state for a thread that has no file position, e.g. a
+    // GitLab general (non-file) discussion that is resolvable. File-position threads
+    // carry their resolution under `location.isResolved` instead. Absent on ordinary
+    // comments, on forges that expose no thread resolution, and on older timelines.
+    threadIsResolved: z.boolean().optional(),
     location: z
         .object({
         path: z.string(),
@@ -7592,6 +8958,10 @@ export const PullRequestTimelineResponseSchema = z.object({
         error: PullRequestTimelineErrorSchema.nullable().optional().default(null),
         requestId: z.string().optional().default(""),
         githubFeaturesEnabled: z.boolean().optional().default(true),
+        // COMPAT(forgeAuthState): added in v0.1.106, remove after 2026-12-27. Optional richer
+        // signal that supersedes githubFeaturesEnabled, mirroring CheckoutPrStatusPayloadSchema.
+        // Drop the boolean once the daemon floor >= v0.1.106.
+        authState: ForgeAuthStateSchema,
     })
         .optional()
         .prefault({}),
@@ -7681,14 +9051,29 @@ export const BranchSuggestionsResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+const ForgeSearchResponsePayloadSchema = z.object({
+    items: z.array(z.unknown()),
+    authState: z.unknown().optional(),
+    error: z.string().nullable(),
+    requestId: z.string(),
+});
+const GitHubSearchResponsePayloadSchema = z.object({
+    items: z.array(z.unknown()),
+    featuresEnabled: z.boolean().optional(),
+    authState: z.unknown().optional(),
+    githubFeaturesEnabled: z.boolean().optional(),
+    error: z.string().nullable(),
+    requestId: z.string(),
+});
+export const ForgeSearchResponseSchema = z.object({
+    type: z.literal("forge.search.response"),
+    payload: ForgeSearchResponsePayloadSchema,
+});
+// COMPAT(githubSearchRpc): added in v0.1.106, remove after 2026-12-28 once
+// clients use forge.search.*.
 export const GitHubSearchResponseSchema = z.object({
     type: z.literal("github_search_response"),
-    payload: z.object({
-        items: z.array(GitHubSearchItemSchema),
-        githubFeaturesEnabled: z.boolean(),
-        error: z.string().nullable(),
-        requestId: z.string(),
-    }),
+    payload: GitHubSearchResponsePayloadSchema,
 });
 export const HostingSearchResponseSchema = z.object({
     type: z.literal("hosting.search.response"),
@@ -7769,6 +9154,64 @@ export const FileExplorerResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+export const FileSubscribeResponseSchema = z.object({
+    type: z.literal("fs.file.subscribe.response"),
+    payload: z.object({
+        subscriptionId: z.string(),
+        initial: FileVersionSchema,
+        requestId: z.string(),
+    }),
+});
+export const FileUnsubscribeResponseSchema = z.object({
+    type: z.literal("fs.file.unsubscribe.response"),
+    payload: z.object({
+        subscriptionId: z.string(),
+        requestId: z.string(),
+    }),
+});
+export const FsFileWriteResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("written"),
+        modifiedAt: z.string(),
+        size: z.number(),
+        revision: z.string().optional(),
+    }),
+    z.object({ status: z.literal("conflict"), version: FileVersionSchema }),
+    z.object({ status: z.literal("error"), error: z.string() }),
+]);
+export const FsFileWriteResponseSchema = z.object({
+    type: z.literal("fs.file.write.response"),
+    payload: z.object({
+        result: FsFileWriteResultSchema,
+        requestId: z.string(),
+    }),
+});
+export const FsFileWriteBinaryResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("written"),
+        modifiedAt: z.string(),
+        size: z.number(),
+    }),
+    // The target is already there and the request did not ask to replace it.
+    z.object({ status: z.literal("exists") }),
+    z.object({ status: z.literal("error"), error: z.string() }),
+]);
+export const FsFileWriteBinaryResponseSchema = z.object({
+    type: z.literal("fs.file.write_binary.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        result: FsFileWriteBinaryResultSchema,
+        requestId: z.string(),
+    }),
+});
+export const FileUpdateSchema = z.object({
+    type: z.literal("fs.file.update"),
+    payload: z.object({
+        subscriptionId: z.string(),
+        version: FileVersionSchema,
+    }),
+});
 const ProjectIconSchema = z.object({
     data: z.string(),
     mimeType: z.string(),
@@ -7865,7 +9308,7 @@ export const FileCreateResponseSchema = z.object({
 });
 /**
  * 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
+ * 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", [
@@ -7998,7 +9441,7 @@ export const CodeDefinitionLocationSchema = z.object({
     /**
      * 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
+     * resolved them or the name index guessed - which changes how much to trust the
      * list. Absent from old daemons.
      */
     serverId: z.string().optional(),
@@ -8006,7 +9449,7 @@ export const CodeDefinitionLocationSchema = z.object({
 /**
  * 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
+ * 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"]);
@@ -8081,7 +9524,7 @@ export const CodeRenameEditSchema = z.object({
     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
+     * 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(""),
@@ -8117,7 +9560,7 @@ export const CodeRenamePreviewResponseSchema = z.object({
  * workspace. Collapsing them into one failure is how "nothing happened" becomes unexplainable.
  */
 /**
- * Whether the run HAPPENED — deliberately not whether everything applied.
+ * 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
@@ -8234,7 +9677,7 @@ export const LspServerStopResponseSchema = z.object({
 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. */
+    /** 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(),
@@ -8247,7 +9690,7 @@ export const CodeSolutionListResponseSchema = z.object({
         /**
          * 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.
+         * solution all return - the client has one silent case to handle, not four.
          */
         solutions: z.array(SolutionRefSchema),
         error: z.string().nullable(),
@@ -8277,8 +9720,8 @@ export const SolutionTreeProjectSchema = z.object({
      */
     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
+     * 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(),
@@ -8296,7 +9739,7 @@ export const CodeSolutionGetTreeResponseSchema = z.object({
         format: SolutionFormatSchema.default("sln"),
         folders: z.array(SolutionTreeFolderSchema),
         projects: z.array(SolutionTreeProjectSchema),
-        /** Solution configurations and platforms — first-class .NET concepts no CLI surfaces. */
+        /** 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(),
@@ -8333,7 +9776,7 @@ export const SolutionProjectNodeSchema = z.discriminatedUnion("kind", [
         name: z.string(),
         path: z.string(),
         outsideWorkspace: z.boolean(),
-        /** `Compile`, `Content`, `EmbeddedResource`, … — MSBuild's own item type. */
+        /** `Compile`, `Content`, `EmbeddedResource`, … - MSBuild's own item type. */
         itemType: z.string(),
         isImplicit: z.boolean(),
     }),
@@ -8389,7 +9832,7 @@ export const FileSearchResultEventSchema = z.object({
         cwd: z.string(),
         searchId: z.string(),
         path: z.string(),
-        /** File content hash at match time — the replace precondition. */
+        /** File content hash at match time - the replace precondition. */
         hash: z.string(),
         matches: z.array(FileSearchMatchSchema),
     }),
@@ -8759,7 +10202,72 @@ export const DaemonUpdateProgressMessageSchema = z.object({
         phase: z.enum(["starting", "downloading", "installing", "complete"]),
     }),
 });
+export const HubExecutionAgentCreateResponseSchema = z.object({
+    type: z.literal("hub.execution.agent.create.response"),
+    payload: z.object({
+        requestId: z.string(),
+        executionId: z.string(),
+        agentId: z.string().nullable(),
+        agent: AgentSnapshotPayloadSchema.nullable(),
+        success: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const HubExecutionControlResponseSchema = z.object({
+    type: z.literal("hub.execution.control.response"),
+    payload: z.object({
+        requestId: z.string(),
+        executionId: z.string(),
+        action: HubExecutionControlActionSchema,
+        success: z.boolean(),
+        error: z.string().nullable(),
+    }),
+});
+export const HubExecutionAgentUpdateSchema = z.object({
+    type: z.literal("hub.execution.agent.update"),
+    payload: z.object({
+        executionId: z.string(),
+        agentId: z.string(),
+        agent: AgentSnapshotPayloadSchema,
+    }),
+});
+export const HubExecutionAgentStreamSchema = z.object({
+    type: z.literal("hub.execution.agent.stream"),
+    payload: z.object({
+        executionId: z.string(),
+        agentId: z.string(),
+        event: AgentStreamEventPayloadSchema,
+    }),
+});
+export const HubExecutionOutboundMessageSchema = z.discriminatedUnion("type", [
+    HubExecutionAgentCreateResponseSchema,
+    HubExecutionControlResponseSchema,
+    HubExecutionAgentUpdateSchema,
+    HubExecutionAgentStreamSchema,
+]);
+export class HubMessageCorrelationError extends Error {
+    constructor(messageType) {
+        super(`Hub message ${messageType} has mismatched agent correlation`);
+        this.name = "HubMessageCorrelationError";
+    }
+}
+export function parseHubExecutionOutboundMessage(value) {
+    const message = HubExecutionOutboundMessageSchema.parse(value);
+    const payload = message.payload;
+    if ("agent" in payload &&
+        payload.agent !== null &&
+        "agentId" in payload &&
+        payload.agentId !== null &&
+        payload.agent.id !== payload.agentId) {
+        throw new HubMessageCorrelationError(message.type);
+    }
+    return message;
+}
 export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
+    HubExecutionAgentCreateResponseSchema,
+    HubExecutionControlResponseSchema,
+    HubExecutionAgentUpdateSchema,
+    HubExecutionAgentStreamSchema,
     BrowserAutomationExecuteRequestSchema,
     ActivityLogMessageSchema,
     AssistantChunkMessageSchema,
@@ -8778,6 +10286,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ArtifactUpdateMessageSchema,
     AgentUpdateMessageSchema,
     WorkspaceUpdateMessageSchema,
+    ProjectUpdateMessageSchema,
+    ProjectListResponseMessageSchema,
     ScriptStatusUpdateMessageSchema,
     WorkspaceSetupProgressMessageSchema,
     WorkspaceSetupStatusResponseMessageSchema,
@@ -8790,8 +10300,14 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProjectAddResponseSchema,
     ProjectScaffoldResponseSchema,
     ProjectScaffoldProgressSchema,
+    ProjectCreateDirectoryResponseSchema,
     OpenProjectResponseMessageSchema,
+    WorkspaceGithubSearchRepositoriesResponseSchema,
+    ProjectGithubCloneResponseSchema,
     StartWorkspaceScriptResponseMessageSchema,
+    WorkspaceScriptListResponseMessageSchema,
+    WorkspaceScriptStartResponseMessageSchema,
+    WorkspaceScriptStopResponseMessageSchema,
     LegacyListAvailableEditorsResponseMessageSchema,
     LegacyOpenInEditorResponseMessageSchema,
     ArchiveWorkspaceResponseMessageSchema,
@@ -8801,6 +10317,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     WorktreeReattachResponseSchema,
     FetchAgentResponseMessageSchema,
     FetchAgentTimelineResponseMessageSchema,
+    ProviderSubagentListResponseMessageSchema,
+    ProviderSubagentTimelineResponseMessageSchema,
+    ProviderSubagentUpdateMessageSchema,
+    SetAgentTimelineSubscriptionResponseMessageSchema,
+    AgentAttentionRequiredMessageSchema,
     AgentForkContextResponseMessageSchema,
     CancelAgentResponseMessageSchema,
     ClearAgentAttentionResponseMessageSchema,
@@ -8810,10 +10331,16 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetVoiceModeResponseMessageSchema,
     DaemonGetStatusResponseSchema,
     DaemonGetPairingOfferResponseSchema,
+    HubManagementDaemonConnectResponseSchema,
+    HubManagementDaemonGetStatusResponseSchema,
+    HubManagementDaemonDisconnectResponseSchema,
     DiagnosticsResponseSchema,
     GetDaemonConfigResponseMessageSchema,
     SetDaemonConfigResponseMessageSchema,
     ConnectorsListToolsResponseSchema,
+    ConnectorsOauthAuthorizeResponseSchema,
+    ConnectorsOauthDisconnectResponseSchema,
+    ConnectorsOauthStatusMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
     SpeechTtsSpeakResponseSchema,
@@ -8851,6 +10378,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProjectLinksUnsetResponseSchema,
     ProjectLinksChangedSchema,
     WorkspaceTitleSetResponseSchema,
+    WorkspacePinSetResponseSchema,
+    WorkspaceRecoveryInspectResponseSchema,
+    WorkspaceRecoveryRestoreResponseSchema,
     WaitForFinishResponseMessageSchema,
     AgentPermissionRequestMessageSchema,
     AgentPermissionResolvedMessageSchema,
@@ -8880,6 +10410,14 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     BrainHfSearchResponseSchema,
     BrainHfQuantsResponseSchema,
     BrainModelsAddResponseSchema,
+    BrainModelsInventoryResponseSchema,
+    BrainModelProfileGetResponseSchema,
+    BrainModelProfileSetResponseSchema,
+    BrainModelBudgetGetResponseSchema,
+    BrainModelLoadResponseSchema,
+    BrainModelUnloadResponseSchema,
+    BrainModelDeleteResponseSchema,
+    BrainLogsTailResponseSchema,
     AgentArchivedMessageSchema,
     CloseItemsResponseSchema,
     CheckoutStatusResponseSchema,
@@ -8919,7 +10457,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutRefreshResponseSchema,
     CheckoutPrCreateResponseSchema,
     CheckoutPrMergeResponseSchema,
+    CheckoutForgeSetAutoMergeResponseSchema,
     CheckoutGithubSetAutoMergeResponseSchema,
+    CheckoutCommitsListResponseSchema,
+    CheckoutCommitFileDiffResponseSchema,
+    CheckoutForgeGetCheckDetailsResponseSchema,
     CheckoutGithubGetCheckDetailsResponseSchema,
     PreviewListConfigResponseSchema,
     PreviewStartResponseSchema,
@@ -8934,6 +10476,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     StashListResponseSchema,
     ValidateBranchResponseSchema,
     BranchSuggestionsResponseSchema,
+    ForgeSearchResponseSchema,
     GitHubSearchResponseSchema,
     HostingSearchResponseSchema,
     HostingAuthStatusResponseSchema,
@@ -8944,6 +10487,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     OttoWorktreeArchiveResponseSchema,
     CreateOttoWorktreeResponseSchema,
     FileExplorerResponseSchema,
+    FileSubscribeResponseSchema,
+    FileUnsubscribeResponseSchema,
+    FsFileWriteResponseSchema,
+    FsFileWriteBinaryResponseSchema,
+    FileUpdateSchema,
     ProjectIconResponseSchema,
     FileDownloadTokenResponseSchema,
     FileUploadResponseSchema,
@@ -9063,8 +10611,11 @@ export const WSHelloMessageSchema = z.object({
         voice: z.boolean().optional(),
         pushNotifications: z.boolean().optional(),
         [CLIENT_CAPS.reasoningMergeEnum]: z.boolean().optional(),
+        [CLIENT_CAPS.selectiveAgentTimeline]: z.boolean().optional(),
         [CLIENT_CAPS.customModeIcons]: z.boolean().optional(),
         [CLIENT_CAPS.terminalReflowableSnapshot]: z.boolean().optional(),
+        [CLIENT_CAPS.providerSubagents]: z.boolean().optional(),
+        [CLIENT_CAPS.projectUpdates]: z.boolean().optional(),
         [CLIENT_CAPS.browserHost]: BrowserAutomationHostCapabilitySchema.optional(),
     })
         .passthrough()