@otto-code/protocol 0.7.4 → 0.7.6

package/dist/messages.js

@@ -7,7 +7,7 @@ import { CLIENT_CAPS } from "./client-capabilities.js";
 import { AGENT_LIFECYCLE_STATUSES } from "./agent-lifecycle.js";
 import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "./agent-title-limits.js";
 import { AgentProviderSchema } from "./provider-manifest.js";
-import { McpServerConfigSchema, OTTO_TOOL_GROUPS } from "./provider-config.js";
+import { ConnectorConfigSchema, McpServerConfigSchema, OTTO_TOOL_GROUPS, } from "./provider-config.js";
 import { TOOL_CALL_ICON_NAMES } from "./agent-types.js";
 import { ChatCreateRequestSchema, ChatListRequestSchema, ChatInspectRequestSchema, ChatDeleteRequestSchema, ChatPostRequestSchema, ChatReadRequestSchema, ChatWaitRequestSchema, ChatCreateResponseSchema, ChatListResponseSchema, ChatInspectResponseSchema, ChatDeleteResponseSchema, ChatPostResponseSchema, ChatReadResponseSchema, ChatWaitResponseSchema, } from "./chat/rpc-schemas.js";
 import { ScheduleCreateRequestSchema, ScheduleListRequestSchema, ScheduleInspectRequestSchema, ScheduleLogsRequestSchema, SchedulePauseRequestSchema, ScheduleResumeRequestSchema, ScheduleDeleteRequestSchema, ScheduleRunOnceRequestSchema, ScheduleUpdateRequestSchema, ScheduleCreateResponseSchema, ScheduleListResponseSchema, ScheduleInspectResponseSchema, ScheduleLogsResponseSchema, SchedulePauseResponseSchema, ScheduleResumeResponseSchema, ScheduleDeleteResponseSchema, ScheduleRunOnceResponseSchema, ScheduleUpdateResponseSchema, } from "./schedule/rpc-schemas.js";
@@ -68,6 +68,17 @@ const MutableAgentBehaviorsConfigSchema = z
     // Default value of an agent's notifyOnFinish when the spawn path leaves it
     // unspecified (the current implicit default).
     notifyOnFinishDefault: z.boolean().default(true),
+    // Provider-agnostic task-list reminders. Otto renders every provider's
+    // native todo list into one timeline UI; when an agent leaves that list with
+    // unfinished items, these keep it from going stale (the user shouldn't have
+    // to dismiss a half-checked list themselves).
+    // Passive: while a stale list is open, attach a reminder to the agent's next
+    // turn (mirrors the harness's own "your todo list looks stale" nudge).
+    todoNudge: z.boolean().default(true),
+    // Active: when the agent goes idle with a stale list, inject a one-shot
+    // reconcile pass so it marks done what's done (or states what's genuinely
+    // left) before the turn truly ends.
+    todoReconcileOnIdle: z.boolean().default(true),
 })
     .passthrough();
 export const TerminalProfileSchema = z
@@ -397,6 +408,161 @@ export const SavedProviderEndpointSchema = z
     savedAt: z.number().optional(),
 })
     .passthrough();
+// The editable projection of @otto-code/brain's own config (the brain's
+// config.json stays the source of truth on disk; the daemon writes changes
+// through). Every field is defaulted so a new client parsing an old daemon's
+// config sees a well-formed, OFF section.
+export const MutableBrainTlsConfigSchema = z
+    .object({
+    mode: z.enum(["off", "files", "self-signed", "tailscale"]).default("off"),
+    certFile: z.string().nullable().default(null),
+    keyFile: z.string().nullable().default(null),
+    hostname: z.string().nullable().default(null),
+    certDir: z.string().nullable().default(null),
+    renewBeforeDays: z.number().int().min(1).default(21),
+})
+    .passthrough();
+// Where a remote brain lives, when brain.mode is "remote". Every field is
+// defaulted so an old daemon's config parses as a well-formed, empty target.
+export const MutableBrainRemoteConfigSchema = z
+    .object({
+    host: z.string().default(""),
+    port: z.number().int().default(1234),
+    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
+    .object({
+    enabled: z.boolean().default(false),
+    autoStart: z.boolean().default(false),
+    // "local": the daemon spawns and supervises the brain on this host.
+    // "remote": the daemon connects to a brain running on another Otto host
+    // (read-only: status/evals/config, no lifecycle). Gated by features.brainRemote.
+    mode: z.enum(["local", "remote"]).default("local"),
+    remote: MutableBrainRemoteConfigSchema.default({
+        host: "",
+        port: 1234,
+        secure: false,
+        authToken: null,
+        certFingerprint: null,
+    }),
+    listen: z
+        .object({
+        host: z.string().default("127.0.0.1"),
+        port: z.number().int().default(1234),
+    })
+        .passthrough()
+        .default({ host: "127.0.0.1", port: 1234 }),
+    defaultModel: z.string().nullable().default(null),
+    // Pin the host to one model: serve only the default/resident model and
+    // refuse completion requests that ask for a different one.
+    lockModel: z.boolean().default(false),
+    // Sharing gates (off by default). allowRemoteConfig: key holders may CHANGE
+    // config over the network (POST /__host/config), not just use it.
+    // allowInsecureBind: permit a non-loopback bind with no token (open share).
+    allowRemoteConfig: z.boolean().default(false),
+    allowInsecureBind: z.boolean().default(false),
+    authMode: z.enum(["none", "token"]).default("none"),
+    // Secret: masked with DAEMON_CONFIG_SECRET_SENTINEL on the way out; an
+    // unchanged sentinel is stripped from inbound patches.
+    authToken: z.string().nullable().default(null),
+    tls: MutableBrainTlsConfigSchema.default({
+        mode: "off",
+        certFile: null,
+        keyFile: null,
+        hostname: null,
+        certDir: null,
+        renewBeforeDays: 21,
+    }),
+})
+    .passthrough();
+// 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 —
+// 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
+// nested patch (e.g. just `listen.host`) preserves its siblings too. Keep the
+// field set in sync with MutableBrainConfigSchema; `.passthrough()` carries any
+// field a newer daemon adds through untouched in the meantime.
+const MutableBrainTlsPatchSchema = z
+    .object({
+    mode: z.enum(["off", "files", "self-signed", "tailscale"]),
+    certFile: z.string().nullable(),
+    keyFile: z.string().nullable(),
+    hostname: z.string().nullable(),
+    certDir: z.string().nullable(),
+    renewBeforeDays: z.number().int().min(1),
+})
+    .partial()
+    .passthrough();
+const MutableBrainRemotePatchSchema = z
+    .object({
+    host: z.string(),
+    port: z.number().int(),
+    secure: z.boolean(),
+    authToken: z.string().nullable(),
+    certFingerprint: z.string().nullable(),
+})
+    .partial()
+    .passthrough();
+const MutableBrainListenPatchSchema = z
+    .object({
+    host: z.string(),
+    port: z.number().int(),
+})
+    .partial()
+    .passthrough();
+export const MutableBrainConfigPatchSchema = z
+    .object({
+    enabled: z.boolean(),
+    autoStart: z.boolean(),
+    mode: z.enum(["local", "remote"]),
+    remote: MutableBrainRemotePatchSchema,
+    listen: MutableBrainListenPatchSchema,
+    defaultModel: z.string().nullable(),
+    lockModel: z.boolean(),
+    allowRemoteConfig: z.boolean(),
+    allowInsecureBind: z.boolean(),
+    authMode: z.enum(["none", "token"]),
+    authToken: z.string().nullable(),
+    tls: MutableBrainTlsPatchSchema,
+})
+    .partial()
+    .passthrough();
+export const DEFAULT_MUTABLE_BRAIN_CONFIG = {
+    enabled: false,
+    autoStart: false,
+    mode: "local",
+    remote: { host: "", port: 1234, secure: false, authToken: null, certFingerprint: null },
+    listen: { host: "127.0.0.1", port: 1234 },
+    defaultModel: null,
+    lockModel: false,
+    allowRemoteConfig: false,
+    allowInsecureBind: false,
+    authMode: "none",
+    authToken: null,
+    tls: {
+        mode: "off",
+        certFile: null,
+        keyFile: null,
+        hostname: null,
+        certDir: null,
+        renewBeforeDays: 21,
+    },
+};
 export const MutableDaemonConfigSchema = z
     .object({
     mcp: z
@@ -418,6 +584,8 @@ export const MutableDaemonConfigSchema = z
         promptSuggestions: true,
         agentProgressSummaries: true,
         notifyOnFinishDefault: true,
+        todoNudge: true,
+        todoReconcileOnIdle: true,
     }),
     providers: z.record(z.string(), MutableDaemonProviderConfigSchema).default({}),
     metadataGeneration: MutableMetadataGenerationConfigSchema.default({
@@ -481,6 +649,15 @@ export const MutableDaemonConfigSchema = z
         maxRunningProbes: 2,
         idleMinutes: 10,
     }),
+    // Local AI host (otto-brain) management. Gated by server_info features.brainControl;
+    // defaults OFF and well-formed so a new client parsing an old daemon's config renders
+    // the row without ever implying the brain is running.
+    brain: MutableBrainConfigSchema.default(DEFAULT_MUTABLE_BRAIN_CONFIG),
+    // Host-wide connector registry (MCP servers surfaced as named, toggle-able
+    // integrations). Gated by server_info features.connectors; defaults to an
+    // empty roster so a new client parsing an old daemon's config still sees a
+    // well-formed section.
+    connectors: z.array(ConnectorConfigSchema).default([]),
 })
     .passthrough();
 export const MutableDaemonConfigPatchSchema = z
@@ -495,6 +672,7 @@ export const MutableDaemonConfigPatchSchema = z
     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.
@@ -529,6 +707,15 @@ export const MutableDaemonConfigPatchSchema = z
     lsp: MutableLspConfigSchema.partial().optional(),
     // Gated by server_info features.solutionView; patches deep-merge.
     dotnetSolutionManagement: MutableDotnetSolutionConfigSchema.partial().optional(),
+    // Gated by server_info features.brainControl; patches deep-merge. Uses the
+    // dedicated no-default patch schema (see MutableBrainConfigPatchSchema): a
+    // plain `.partial()` here keeps every field's default and resets the whole
+    // block on a single-field patch.
+    brain: MutableBrainConfigPatchSchema.optional(),
+    // Gated by server_info features.connectors. Replaces the full array
+    // (read-modify-write), matching modelTierOverrides/savedProviderEndpoints, so
+    // enabling/disabling a connector or a tool is a whole-array rewrite.
+    connectors: z.array(ConnectorConfigSchema).optional(),
 })
     .partial()
     .passthrough();
@@ -618,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(),
@@ -891,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"),
@@ -918,6 +1107,8 @@ export const AgentTimelineItemPayloadSchema = z.union([
         // 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.
+        // 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(),
@@ -979,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"]),
             }),
@@ -1030,6 +1222,13 @@ export const QueuedAgentMessagePayloadSchema = z.object({
     preview: z.string(),
     enqueuedAt: z.string(),
     attachmentCount: z.number().int().nonnegative().optional(),
+    /**
+     * 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
+     * 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
@@ -1106,7 +1305,9 @@ export const AgentSnapshotPayloadSchema = z.object({
     // 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(),
@@ -1129,6 +1330,14 @@ export const AgentSnapshotPayloadSchema = z.object({
     // 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.
     attend: z.enum(["attended", "observed"]).optional(),
+    // True when an observed sub-agent run outlives an interrupt of the parent's
+    // turn: a backgrounded Task/Agent (its tool_result was only a launch ack) or
+    // a Workflow orchestration run. The client uses it to stop claiming that
+    // interrupting the parent stops work it will not actually stop.
+    // COMPAT(backgroundedObservedSubagents): added in v0.7.5; absent ⇒ treated as
+    // foreground, which is the pre-existing behavior. Drop the gate when daemon
+    // floor >= v0.7.5. See docs/chat-lifecycle.md.
+    backgrounded: z.boolean().optional(),
     // Spinner colors from the Agent Personality this agent was spawned from, so
     // its live thinking indicator renders in the personality's identity. Absent ⇒
     // the client falls back to the theme's default spinner colors. Purely additive
@@ -1313,6 +1522,459 @@ export const AttachmentsImagesClearResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+// --- Local AI host (otto-brain) management -------------------------------
+// Lifecycle + evals are correlated request/response RPCs. Gated by
+// 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.
+// 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.
+export const BrainHostStatusSchema = z
+    .object({
+    running: z.boolean(),
+    pid: z.number().nullable().optional(),
+    version: z.string().nullable().optional(),
+    host: z.string().nullable().optional(),
+    port: z.number().nullable().optional(),
+    displayHost: z.string().nullable().optional(),
+    secure: z.boolean().optional(),
+    state: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    modelId: z.string().nullable().optional(),
+    vramBytes: z.number().nullable().optional(),
+    loadSeconds: z.number().nullable().optional(),
+    startedAt: z.string().nullable().optional(),
+    lastError: z.string().nullable().optional(),
+    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(),
+})
+    .passthrough();
+const BrainHostStatusResultSchema = z.object({
+    status: BrainHostStatusSchema,
+    error: z.string().nullable(),
+    requestId: z.string(),
+});
+export const BrainHostStatusRequestSchema = z.object({
+    type: z.literal("brain.host.status.request"),
+    requestId: z.string(),
+});
+export const BrainHostStatusResponseSchema = z.object({
+    type: z.literal("brain.host.status.response"),
+    payload: BrainHostStatusResultSchema,
+});
+export const BrainHostStartRequestSchema = z.object({
+    type: z.literal("brain.host.start.request"),
+    // Optional model fragment/id to load on start; null = the brain's default.
+    model: z.string().nullable().default(null),
+    requestId: z.string(),
+});
+export const BrainHostStartResponseSchema = z.object({
+    type: z.literal("brain.host.start.response"),
+    payload: BrainHostStatusResultSchema,
+});
+export const BrainHostStopRequestSchema = z.object({
+    type: z.literal("brain.host.stop.request"),
+    requestId: z.string(),
+});
+export const BrainHostStopResponseSchema = z.object({
+    type: z.literal("brain.host.stop.response"),
+    payload: BrainHostStatusResultSchema,
+});
+export const BrainHostRestartRequestSchema = z.object({
+    type: z.literal("brain.host.restart.request"),
+    model: z.string().nullable().default(null),
+    requestId: z.string(),
+});
+export const BrainHostRestartResponseSchema = z.object({
+    type: z.literal("brain.host.restart.response"),
+    payload: BrainHostStatusResultSchema,
+});
+// Benchmark rankings/variance/latest, proxied from the brain's `/__host/evals`.
+export const BrainEvalsSchema = z
+    .object({
+    rankings: z.array(z.record(z.string(), z.unknown())).default([]),
+    latest: z.array(z.record(z.string(), z.unknown())).default([]),
+    variance: z.array(z.record(z.string(), z.unknown())).default([]),
+    runCount: z.number().default(0),
+})
+    .passthrough();
+export const BrainEvalsGetRequestSchema = z.object({
+    type: z.literal("brain.evals.get.request"),
+    requestId: z.string(),
+});
+export const BrainEvalsGetResponseSchema = z.object({
+    type: z.literal("brain.evals.get.response"),
+    payload: z.object({
+        evals: BrainEvalsSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Brain network auto-discovery: the daemon enumerates this host's bind
+// addresses and probes the local `tailscale` CLI so the client can offer the
+// operator a pick-list of likely listen hosts (and pre-fill the tailscale TLS
+// mode) instead of asking them to hunt for IPs by hand.
+// Gated by server_info.features.brainNetworkDiscovery.
+export const BrainTailscaleInfoSchema = z
+    .object({
+    // Whether the tailscale CLI is present and its daemon answers.
+    available: z.boolean(),
+    // This machine's MagicDNS name, e.g. greyskull.tail279562.ts.net.
+    hostname: z.string().nullable().optional(),
+    // The tailnet IPv4 address, for a tailnet-only bind.
+    ipv4: z.string().nullable().optional(),
+    // The default directory the brain writes issued certificates to.
+    certDir: z.string().nullable().optional(),
+})
+    .passthrough();
+// One candidate value for `listen.host`, with a human label for the pick-list.
+export const BrainBindAddressSchema = z
+    .object({
+    // The literal value written to listen.host (an IP, 0.0.0.0, or "tailscale").
+    value: z.string(),
+    // Display label, e.g. "Local only", "All interfaces", "192.168.1.42 (en0)".
+    label: z.string(),
+    kind: z.enum(["loopback", "all", "lan", "tailscale"]),
+})
+    .passthrough();
+export const BrainNetworkInfoSchema = z
+    .object({
+    addresses: z.array(BrainBindAddressSchema).default([]),
+    tailscale: BrainTailscaleInfoSchema.nullable().optional(),
+})
+    .passthrough();
+// Detected model names for the settings pickers. Read from the brain's
+// /v1/models when it is reachable (local child up, or remote); empty otherwise,
+// which the client renders as a disabled picker. Gated by features.brainStatus.
+export const BrainModelsListRequestSchema = z.object({
+    type: z.literal("brain.models.list.request"),
+    requestId: z.string(),
+});
+export const BrainModelsListResponseSchema = z.object({
+    type: z.literal("brain.models.list.response"),
+    payload: z.object({
+        models: z.array(z.string()).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Read/write a *remote* brain's own config (its /__host/config). Only valid in
+// brain.mode "remote"; the config is the remote brain's effective config with
+// secrets redacted. Editable fields are model-related (defaultModel, lockModel);
+// network/TLS/auth stay host-owned. Gated by features.brainRemote.
+export const BrainRemoteConfigSchema = z.record(z.string(), z.unknown());
+export const BrainRemoteConfigGetRequestSchema = z.object({
+    type: z.literal("brain.remote.config.get.request"),
+    requestId: z.string(),
+});
+export const BrainRemoteConfigGetResponseSchema = z.object({
+    type: z.literal("brain.remote.config.get.response"),
+    payload: z.object({
+        config: BrainRemoteConfigSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const BrainRemoteConfigPatchRequestSchema = z.object({
+    type: z.literal("brain.remote.config.patch.request"),
+    patch: BrainRemoteConfigSchema,
+    requestId: z.string(),
+});
+export const BrainRemoteConfigPatchResponseSchema = z.object({
+    type: z.literal("brain.remote.config.patch.response"),
+    payload: z.object({
+        config: BrainRemoteConfigSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+export const BrainNetworkDiscoverRequestSchema = z.object({
+    type: z.literal("brain.network.discover.request"),
+    requestId: z.string(),
+});
+export const BrainNetworkDiscoverResponseSchema = z.object({
+    type: z.literal("brain.network.discover.response"),
+    payload: z.object({
+        info: BrainNetworkInfoSchema.nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// --- Brain model management (runtimes, catalog, downloads, ops) ----------
+// The daemon drives these by shelling out to `otto-brain <verb> --json` (it
+// never imports the brain's runtime modules in-process). Reads (scan, catalog,
+// runtime list) are correlated request/response; long operations (pull, runtime
+// install, calibrate, sweep, bench) run as tracked JOBS the client polls via
+// brain.jobs.list. All gated by server_info.features.brainManage.
+// An installed local model, from `otto-brain scan`. Passthrough so the brain's
+// scan row can grow fields without a protocol bump.
+export const BrainInstalledModelSchema = z
+    .object({
+    model: z.string().default(""),
+    arch: z.string().default(""),
+    quant: z.string().default(""),
+    size: z.string().default(""),
+    ctx: z.string().default(""),
+    vision: z.string().default(""),
+    calibrated: z.string().default(""),
+    features: z.string().default(""),
+    source: z.string().default(""),
+})
+    .passthrough();
+// A downloadable catalog model, annotated with whether it is already installed
+// (the daemon reuses the brain's authoritative catalog↔model join). Passthrough
+// over the catalog entry's optional metadata.
+export const BrainCatalogModelSchema = z
+    .object({
+    id: z.string(),
+    name: z.string().default(""),
+    installed: z.boolean().default(false),
+    publisher: z.string().default(""),
+    repo: z.string().default(""),
+    quant: z.string().default(""),
+    params: z.string().default(""),
+    sizeBytes: z.number().nullable().optional(),
+    size: z.string().default(""),
+    vision: z.boolean().default(false),
+    thinking: z.boolean().default(false),
+    contextMax: z.number().nullable().optional(),
+    tier: z.string().default(""),
+    useCases: z.array(z.string()).default([]),
+    why: z.string().default(""),
+})
+    .passthrough();
+// An installed llama.cpp runtime, from `otto-brain runtime list`.
+export const BrainRuntimeSchema = z
+    .object({
+    label: z.string().default(""),
+    version: z.string().default(""),
+    source: z.string().default(""),
+    dir: z.string().default(""),
+})
+    .passthrough();
+// A tracked long-running brain operation. The client polls brain.jobs.list and
+// renders progress. `percent` is null when the job reports no measurable
+// progress (indeterminate). Terminal jobs linger briefly so the UI can show
+// the outcome before they are pruned.
+export const BrainJobKindSchema = z.enum([
+    "pull",
+    "runtime-install",
+    "calibrate",
+    "sweep",
+    "bench",
+]);
+export const BrainJobStatusSchema = z.enum(["running", "succeeded", "failed", "canceled"]);
+export const BrainJobSchema = z
+    .object({
+    id: z.string(),
+    kind: BrainJobKindSchema,
+    // A short human label, e.g. "Download Phi-4 (14B)".
+    label: z.string().default(""),
+    // The subject id (catalog id, model name, or build tag) this job acts on.
+    target: z.string().nullable().default(null),
+    status: BrainJobStatusSchema.default("running"),
+    percent: z.number().nullable().default(null),
+    // The latest progress line (e.g. "extracting…", "budget 512: done").
+    message: z.string().nullable().default(null),
+    error: z.string().nullable().default(null),
+    startedAt: z.string().default(""),
+    finishedAt: z.string().nullable().default(null),
+})
+    .passthrough();
+// Every job-starting RPC returns the created (or refused) job under this shape.
+const BrainJobResultSchema = z.object({
+    job: BrainJobSchema.nullable(),
+    error: z.string().nullable(),
+    requestId: z.string(),
+});
+// Every job-listing RPC returns the active + recently-finished jobs.
+const BrainJobsResultSchema = z.object({
+    jobs: z.array(BrainJobSchema).default([]),
+    error: z.string().nullable(),
+    requestId: z.string(),
+});
+// Installed models — `otto-brain scan`.
+export const BrainModelsScanRequestSchema = z.object({
+    type: z.literal("brain.models.scan.request"),
+    requestId: z.string(),
+});
+export const BrainModelsScanResponseSchema = z.object({
+    type: z.literal("brain.models.scan.response"),
+    payload: z.object({
+        models: z.array(BrainInstalledModelSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Downloadable catalog — `otto-brain catalog`.
+export const BrainCatalogListRequestSchema = z.object({
+    type: z.literal("brain.catalog.list.request"),
+    requestId: z.string(),
+});
+export const BrainCatalogListResponseSchema = z.object({
+    type: z.literal("brain.catalog.list.response"),
+    payload: z.object({
+        models: z.array(BrainCatalogModelSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// Installed runtimes — `otto-brain runtime list`.
+export const BrainRuntimeListRequestSchema = z.object({
+    type: z.literal("brain.runtime.list.request"),
+    requestId: z.string(),
+});
+export const BrainRuntimeListResponseSchema = z.object({
+    type: z.literal("brain.runtime.list.response"),
+    payload: z.object({
+        runtimes: z.array(BrainRuntimeSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// 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.
+    model: z.string(),
+    requestId: z.string(),
+});
+export const BrainModelsPullResponseSchema = z.object({
+    type: z.literal("brain.models.pull.response"),
+    payload: BrainJobResultSchema,
+});
+// 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.
+    build: z.string().nullable().default(null),
+    requestId: z.string(),
+});
+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
+// runtime + GPU; refused with a helpful error otherwise.
+export const BrainCalibrateRequestSchema = z.object({
+    type: z.literal("brain.calibrate.request"),
+    model: z.string(),
+    requestId: z.string(),
+});
+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.
+export const BrainSweepRequestSchema = z.object({
+    type: z.literal("brain.sweep.request"),
+    model: z.string(),
+    requestId: z.string(),
+});
+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
+// optional comma list of name fragments; null lets the brain pick.
+export const BrainBenchRequestSchema = z.object({
+    type: z.literal("brain.bench.request"),
+    model: z.string().nullable().default(null),
+    requestId: z.string(),
+});
+export const BrainBenchResponseSchema = z.object({
+    type: z.literal("brain.bench.response"),
+    payload: BrainJobResultSchema,
+});
+// Poll the active + recently-finished jobs.
+export const BrainJobsListRequestSchema = z.object({
+    type: z.literal("brain.jobs.list.request"),
+    requestId: z.string(),
+});
+export const BrainJobsListResponseSchema = z.object({
+    type: z.literal("brain.jobs.list.response"),
+    payload: BrainJobsResultSchema,
+});
+// Cancel a running job; returns the refreshed job list.
+export const BrainJobsCancelRequestSchema = z.object({
+    type: z.literal("brain.jobs.cancel.request"),
+    jobId: z.string(),
+    requestId: z.string(),
+});
+export const BrainJobsCancelResponseSchema = z.object({
+    type: z.literal("brain.jobs.cancel.response"),
+    payload: BrainJobsResultSchema,
+});
+// --- Hugging Face discovery (search + add arbitrary repos) ---------------
+// The daemon shells out to `otto-brain search`/`add --json`. Reads are
+// correlated request/response; the download runs as a `pull` job. Gated by
+// server_info.features.brainHfSearch. The brain resolves its own HF token (env
+// HF_TOKEN or its config), so no secret crosses this boundary.
+// One GGUF repo from a Hugging Face search. Passthrough so the brain's search
+// row can grow fields without a protocol bump.
+export const BrainHfSearchResultSchema = z
+    .object({
+    repo: z.string().default(""),
+    downloads: z.number().default(0),
+    likes: z.number().default(0),
+    gated: z.boolean().default(false),
+    // True when any quant of this repo is already on disk.
+    installed: z.boolean().default(false),
+})
+    .passthrough();
+// One downloadable quantization of a repo — `otto-brain add <repo> --list-quants`.
+export const BrainRepoQuantSchema = z
+    .object({
+    quant: z.string().default(""),
+    size: z.string().default(""),
+    sizeBytes: z.number().default(0),
+    files: z.number().default(0),
+    // True when this specific quant is already on disk.
+    installed: z.boolean().default(false),
+})
+    .passthrough();
+// 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(),
+    limit: z.number().nullable().default(null),
+    requestId: z.string(),
+});
+export const BrainHfSearchResponseSchema = z.object({
+    type: z.literal("brain.hf.search.response"),
+    payload: z.object({
+        results: z.array(BrainHfSearchResultSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// 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(),
+    requestId: z.string(),
+});
+export const BrainHfQuantsResponseSchema = z.object({
+    type: z.literal("brain.hf.quants.response"),
+    payload: z.object({
+        quants: z.array(BrainRepoQuantSchema).default([]),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+// 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(),
+    quant: z.string(),
+    requestId: z.string(),
+});
+export const BrainModelsAddResponseSchema = z.object({
+    type: z.literal("brain.models.add.response"),
+    payload: BrainJobResultSchema,
+});
 export const ProjectRenameRequestSchema = z.object({
     type: z.literal("project.rename.request"),
     projectId: z.string(),
@@ -1356,6 +2018,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(),
@@ -1372,6 +2050,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"),
@@ -1380,10 +2070,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"),
@@ -1404,6 +2097,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"),
@@ -1450,6 +2153,8 @@ export const UploadedFileAttachmentSchema = z.object({
     path: z.string(),
 });
 export const AgentAttachmentSchema = z.discriminatedUnion("type", [
+    ForgeChangeRequestAttachmentSchema,
+    ForgeIssueAttachmentSchema,
     GitHubPrAttachmentSchema,
     GitHubIssueAttachmentSchema,
     HostingPrAttachmentSchema,
@@ -1472,6 +2177,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"
@@ -1546,6 +2257,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(),
@@ -1643,6 +2358,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(),
@@ -1656,6 +2386,33 @@ export const SetDaemonConfigRequestMessageSchema = z.object({
     requestId: z.string(),
     config: MutableDaemonConfigPatchSchema,
 });
+// 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
+// features.connectors.
+export const ConnectorsListToolsRequestSchema = z.object({
+    type: z.literal("connectors.list_tools.request"),
+    requestId: z.string(),
+    connectorId: z.string(),
+});
+export const ConnectorsListToolsResponseSchema = z.object({
+    type: z.literal("connectors.list_tools.response"),
+    payload: z.object({
+        connectorId: z.string(),
+        tools: z
+            .array(z.object({
+            name: z.string(),
+            description: z.string().nullable().default(null),
+            disabled: z.boolean().default(false),
+        }))
+            .default([]),
+        // Non-null when the connector could not be reached / enumerated.
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
 export const SpeechSettingsGetOptionsRequestSchema = z.object({
     type: z.literal("speech.settings.get_options.request"),
     requestId: z.string(),
@@ -1737,6 +2494,29 @@ export const AgentPersonalitiesGetStatsRequestSchema = z.object({
     type: z.literal("agentPersonalities.get_stats.request"),
     requestId: z.string(),
 });
+// COMPAT(personalityProfile): added in v0.7.5; gate lives in
+// features.personalityProfile. Author a personality PROFILE (the prose
+// `personalityPrompt` that shapes how an agent behaves) from the only things
+// the editor knows before one exists: the handle, the roles it will be spawned
+// for, and its two spinner colors. Like the voice-cue RPC this is described
+// inline (not a stored id) so the editor can generate for an unsaved draft, and
+// is an editor-time action: the result lands in the prompt field for the user to
+// edit, and is stored on the personality by the ordinary save.
+export const AgentPersonalitiesGenerateProfileRequestSchema = z.object({
+    type: z.literal("agentPersonalities.generate_profile.request"),
+    requestId: z.string(),
+    name: z.string(),
+    // Permissive strings to match the stored personality shape (forward-compatible
+    // with roles this daemon predates); the daemon filters to its known set.
+    roles: z.array(z.string().min(1)).optional(),
+    // The spinner glow pair, read as a palette (temperature, energy) and never
+    // quoted literally in the profile.
+    glowA: z.string().optional(),
+    glowB: z.string().optional(),
+    // Scopes provider resolution to a workspace; omitted falls back to any
+    // resolvable one.
+    cwd: z.string().optional(),
+});
 export const ReadProjectConfigRequestMessageSchema = z.object({
     type: z.literal("read_project_config_request"),
     requestId: z.string(),
@@ -1781,6 +2561,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", [
@@ -1809,6 +2592,9 @@ export const CreateAgentRequestMessageSchema = z.object({
     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(),
@@ -2080,9 +2866,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(),
 });
@@ -2802,6 +3608,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({
@@ -3262,6 +4110,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(),
@@ -3269,16 +4126,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(),
@@ -3367,17 +4271,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(),
@@ -3458,6 +4386,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(),
 });
@@ -3485,6 +4416,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(),
@@ -3580,6 +4513,35 @@ 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(),
@@ -3654,6 +4616,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(),
         }),
@@ -3743,6 +4710,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(),
@@ -3756,6 +4724,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(),
@@ -4205,6 +5270,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({
@@ -4219,6 +5294,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(),
@@ -4269,7 +5369,31 @@ export const CaptureTerminalRequestSchema = z.object({
     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,
@@ -4278,6 +5402,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     FetchAgentHistoryRequestMessageSchema,
     FetchRecentProviderSessionsRequestMessageSchema,
     FetchWorkspacesRequestMessageSchema,
+    ProjectListRequestMessageSchema,
     FetchAgentRequestMessageSchema,
     DeleteAgentRequestMessageSchema,
     ArchiveAgentRequestMessageSchema,
@@ -4285,6 +5410,28 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     HistoryAgentsClearArchivedRequestSchema,
     AttachmentsImagesStatsRequestSchema,
     AttachmentsImagesClearRequestSchema,
+    BrainHostStatusRequestSchema,
+    BrainHostStartRequestSchema,
+    BrainHostStopRequestSchema,
+    BrainHostRestartRequestSchema,
+    BrainEvalsGetRequestSchema,
+    BrainNetworkDiscoverRequestSchema,
+    BrainModelsListRequestSchema,
+    BrainRemoteConfigGetRequestSchema,
+    BrainRemoteConfigPatchRequestSchema,
+    BrainModelsScanRequestSchema,
+    BrainCatalogListRequestSchema,
+    BrainRuntimeListRequestSchema,
+    BrainModelsPullRequestSchema,
+    BrainRuntimeInstallRequestSchema,
+    BrainCalibrateRequestSchema,
+    BrainSweepRequestSchema,
+    BrainBenchRequestSchema,
+    BrainJobsListRequestSchema,
+    BrainJobsCancelRequestSchema,
+    BrainHfSearchRequestSchema,
+    BrainHfQuantsRequestSchema,
+    BrainModelsAddRequestSchema,
     UpdateAgentRequestMessageSchema,
     ProjectRenameRequestSchema,
     ProjectRemoveRequestSchema,
@@ -4292,20 +5439,28 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProjectLinksSetRequestSchema,
     ProjectLinksUnsetRequestSchema,
     WorkspaceTitleSetRequestSchema,
+    WorkspacePinSetRequestSchema,
+    WorkspaceRecoveryInspectRequestSchema,
+    WorkspaceRecoveryRestoreRequestSchema,
     SetVoiceModeMessageSchema,
     SendAgentMessageRequestSchema,
     WaitForFinishRequestSchema,
     DaemonGetStatusRequestSchema,
     DaemonGetPairingOfferRequestSchema,
+    HubManagementDaemonConnectRequestSchema,
+    HubManagementDaemonGetStatusRequestSchema,
+    HubManagementDaemonDisconnectRequestSchema,
     DiagnosticsRequestSchema,
     GetDaemonConfigRequestMessageSchema,
     SetDaemonConfigRequestMessageSchema,
+    ConnectorsListToolsRequestSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
     SpeechTtsSpeakRequestSchema,
     SpeechTtsSpeakCancelRequestSchema,
     VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
+    AgentPersonalitiesGenerateProfileRequestSchema,
     ReadProjectConfigRequestMessageSchema,
     WriteProjectConfigRequestMessageSchema,
     DictationStreamStartMessageSchema,
@@ -4341,6 +5496,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     RestartServerRequestMessageSchema,
     DaemonUpdateRequestMessageSchema,
     FetchAgentTimelineRequestMessageSchema,
+    ProviderSubagentListRequestMessageSchema,
+    ProviderSubagentTimelineRequestMessageSchema,
+    SetAgentTimelineSubscriptionRequestMessageSchema,
     AgentForkContextRequestMessageSchema,
     SetAgentModeRequestMessageSchema,
     SetAgentModelRequestMessageSchema,
@@ -4390,7 +5548,11 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutRefreshRequestSchema,
     CheckoutPrCreateRequestSchema,
     CheckoutPrMergeRequestSchema,
+    CheckoutForgeSetAutoMergeRequestSchema,
     CheckoutGithubSetAutoMergeRequestSchema,
+    CheckoutCommitsListRequestSchema,
+    CheckoutCommitFileDiffRequestSchema,
+    CheckoutForgeGetCheckDetailsRequestSchema,
     CheckoutGithubGetCheckDetailsRequestSchema,
     PreviewListConfigRequestSchema,
     PreviewStartRequestSchema,
@@ -4405,6 +5567,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     StashListRequestSchema,
     ValidateBranchRequestSchema,
     BranchSuggestionsRequestSchema,
+    ForgeSearchRequestSchema,
     GitHubSearchRequestSchema,
     HostingSearchRequestSchema,
     HostingAuthStatusRequestSchema,
@@ -4420,6 +5583,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProjectScaffoldRequestSchema,
     HostingListRepositoriesRequestSchema,
     HostingListOwnersRequestSchema,
+    ProjectCreateDirectoryRequestSchema,
+    WorkspaceGithubSearchRepositoriesRequestSchema,
+    ProjectGithubCloneRequestSchema,
     ArchiveWorkspaceRequestSchema,
     WorkspaceArchivePreflightRequestSchema,
     WorktreeBaseRefSetRequestSchema,
@@ -4428,6 +5594,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     WorkspaceCreateRequestSchema,
     WorkspaceClearAttentionRequestSchema,
     FileExplorerRequestSchema,
+    FileSubscribeRequestSchema,
+    FileUnsubscribeRequestSchema,
+    FsFileWriteRequestSchema,
+    FsFileWriteBinaryRequestSchema,
     ProjectIconRequestSchema,
     FileDownloadTokenRequestSchema,
     FileUploadRequestSchema,
@@ -4467,6 +5637,9 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CreateTerminalRequestSchema,
     RenameTerminalRequestSchema,
     StartWorkspaceScriptRequestSchema,
+    WorkspaceScriptListRequestSchema,
+    WorkspaceScriptStartRequestSchema,
+    WorkspaceScriptStopRequestSchema,
     SubscribeTerminalRequestSchema,
     UnsubscribeTerminalRequestSchema,
     TerminalInputSchema,
@@ -4641,14 +5814,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.
@@ -4671,14 +5853,55 @@ 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.
         daemonSelfUpdate: z.boolean().optional(),
+        // Daemon manages the local AI host (otto-brain) as a child: reports
+        // brain.host.status, serves brain.host.start/stop/restart, exposes the
+        // editable `brain` config block, and honors kill-on-shutdown. Without it
+        // the Local brain host UI is hidden ("update the host").
+        // COMPAT(brainControl): added in v0.7.5, remove gate after 2026-01-30 once daemon floor >= v0.7.5.
+        brainControl: z.boolean().optional(),
+        // Daemon streams the brain's live status/telemetry via
+        // subscribe_brain_status + brain_status_changed, and serves brain.evals.get.
+        // Separate from brainControl because status/eval watching can ship after
+        // lifecycle control. Without it the Brain dashboard falls back to a
+        // periodic brain.host.status poll (no live feed, no eval charts).
+        // COMPAT(brainStatus): added in v0.7.5, remove gate after 2026-01-30 once daemon floor >= v0.7.5.
+        brainStatus: z.boolean().optional(),
+        // Daemon serves brain.network.discover: enumerates this host's bind
+        // addresses and probes the local `tailscale` CLI, so the client can
+        // offer a listen-host pick-list and auto-fill the tailscale TLS mode.
+        // COMPAT(brainNetworkDiscovery): added in v0.7.5, remove gate after 2026-07-30 once daemon floor >= v0.7.5.
+        brainNetworkDiscovery: z.boolean().optional(),
+        // Daemon can point the brain at a remote host (brain.mode "remote"):
+        // status/evals/config proxied from another Otto's brain, no local spawn.
+        // COMPAT(brainRemote): added in v0.7.5, remove gate after 2026-07-30 once daemon floor >= v0.7.5.
+        brainRemote: z.boolean().optional(),
+        // Daemon manages the brain's models and runtimes by shelling out to the
+        // otto-brain CLI: serves brain.models.scan / brain.catalog.list /
+        // brain.runtime.list (reads) and starts brain.models.pull /
+        // brain.runtime.install / brain.calibrate / brain.sweep / brain.bench as
+        // tracked jobs polled via brain.jobs.list. Without it the Brain "Models"
+        // and "Operations" sections are hidden ("update the host").
+        // COMPAT(brainManage): added in v0.7.5, remove gate after 2026-07-30 once daemon floor >= v0.7.5.
+        brainManage: z.boolean().optional(),
+        // Daemon serves brain.hf.search / brain.hf.quants (reads) and starts
+        // brain.models.add (download an arbitrary HF repo's quant) as a pull job.
+        // 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(),
         // 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.
@@ -4739,6 +5962,16 @@ export const ServerInfoStatusPayloadSchema = z
         // 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.
@@ -4779,6 +6012,10 @@ export const ServerInfoStatusPayloadSchema = z
         ttsSpeak: z.boolean().optional(),
         // COMPAT(visualizerVoiceCues): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
         visualizerVoiceCues: z.boolean().optional(),
+        // COMPAT(personalityProfile): added in v0.7.5, drop the gate when daemon floor >= v0.7.5.
+        // Host can author a personality profile (the prompt prose) from a name,
+        // roles, and spinner colors.
+        personalityProfile: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
         setAgentPersonality: z.boolean().optional(),
         // COMPAT(checkoutGitCommit): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
@@ -4872,11 +6109,23 @@ export const ServerInfoStatusPayloadSchema = z
         // 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
+        // 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(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}` —
+        // 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.
+        todoReminders: z.boolean().optional(),
         // COMPAT(metadataGenerationEnabled): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
         // Set when the daemon persists `metadataGeneration.{enabled,preferWriterPersonalities}`.
         // The generation path (WP-B) reads them; the client gates the toggle cards on this.
@@ -4914,6 +6163,13 @@ export const ServerInfoStatusPayloadSchema = z
         // 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
@@ -4928,6 +6184,40 @@ export const ServerInfoStatusPayloadSchema = z
         // 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(),
 })
@@ -5147,8 +6437,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(),
@@ -5232,7 +6564,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.
@@ -5241,6 +6575,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
@@ -5262,6 +6598,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) => ({
@@ -5353,6 +6693,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(),
@@ -5414,6 +6756,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({
@@ -5545,6 +6901,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({
@@ -5555,6 +6975,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"),
@@ -5719,6 +7159,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({
@@ -5727,6 +7267,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(),
     }),
 });
@@ -5787,6 +7328,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({
@@ -5953,6 +7495,19 @@ export const AgentPersonalitiesGetStatsResponseSchema = z.object({
     })
         .passthrough(),
 });
+export const AgentPersonalitiesGenerateProfileResponseSchema = z.object({
+    type: z.literal("agentPersonalities.generate_profile.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // The authored personality prompt, ready to drop into the editor's prompt
+        // field. Absent when generation failed (see error) or no writer/provider
+        // resolves on this host.
+        profile: z.string().optional(),
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
 export const DaemonGetStatusResponseSchema = z.object({
     type: z.literal("daemon.get_status.response"),
     payload: z
@@ -5982,6 +7537,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
@@ -6195,8 +7781,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),
@@ -6206,9 +7791,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(),
@@ -6241,6 +7840,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,
@@ -6254,7 +7861,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(),
@@ -6264,6 +7873,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,
@@ -6271,6 +7883,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(),
 });
@@ -6298,6 +7917,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"),
@@ -6594,6 +8215,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({
@@ -6670,6 +8303,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(),
@@ -6688,6 +8344,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(),
@@ -6707,13 +8388,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(),
     }),
@@ -6773,6 +8469,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(),
@@ -6808,6 +8514,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({}),
@@ -6897,14 +8607,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"),
@@ -6985,6 +8710,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(),
@@ -7975,7 +9758,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,
@@ -7994,6 +9842,8 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ArtifactUpdateMessageSchema,
     AgentUpdateMessageSchema,
     WorkspaceUpdateMessageSchema,
+    ProjectUpdateMessageSchema,
+    ProjectListResponseMessageSchema,
     ScriptStatusUpdateMessageSchema,
     WorkspaceSetupProgressMessageSchema,
     WorkspaceSetupStatusResponseMessageSchema,
@@ -8006,8 +9856,14 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProjectAddResponseSchema,
     ProjectScaffoldResponseSchema,
     ProjectScaffoldProgressSchema,
+    ProjectCreateDirectoryResponseSchema,
     OpenProjectResponseMessageSchema,
+    WorkspaceGithubSearchRepositoriesResponseSchema,
+    ProjectGithubCloneResponseSchema,
     StartWorkspaceScriptResponseMessageSchema,
+    WorkspaceScriptListResponseMessageSchema,
+    WorkspaceScriptStartResponseMessageSchema,
+    WorkspaceScriptStopResponseMessageSchema,
     LegacyListAvailableEditorsResponseMessageSchema,
     LegacyOpenInEditorResponseMessageSchema,
     ArchiveWorkspaceResponseMessageSchema,
@@ -8017,6 +9873,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     WorktreeReattachResponseSchema,
     FetchAgentResponseMessageSchema,
     FetchAgentTimelineResponseMessageSchema,
+    ProviderSubagentListResponseMessageSchema,
+    ProviderSubagentTimelineResponseMessageSchema,
+    ProviderSubagentUpdateMessageSchema,
+    SetAgentTimelineSubscriptionResponseMessageSchema,
+    AgentAttentionRequiredMessageSchema,
     AgentForkContextResponseMessageSchema,
     CancelAgentResponseMessageSchema,
     ClearAgentAttentionResponseMessageSchema,
@@ -8026,15 +9887,20 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetVoiceModeResponseMessageSchema,
     DaemonGetStatusResponseSchema,
     DaemonGetPairingOfferResponseSchema,
+    HubManagementDaemonConnectResponseSchema,
+    HubManagementDaemonGetStatusResponseSchema,
+    HubManagementDaemonDisconnectResponseSchema,
     DiagnosticsResponseSchema,
     GetDaemonConfigResponseMessageSchema,
     SetDaemonConfigResponseMessageSchema,
+    ConnectorsListToolsResponseSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
     SpeechTtsSpeakResponseSchema,
     SpeechTtsSpeakCancelResponseSchema,
     VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
+    AgentPersonalitiesGenerateProfileResponseSchema,
     ReadProjectConfigResponseMessageSchema,
     WriteProjectConfigResponseMessageSchema,
     SetAgentModeResponseMessageSchema,
@@ -8065,6 +9931,9 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProjectLinksUnsetResponseSchema,
     ProjectLinksChangedSchema,
     WorkspaceTitleSetResponseSchema,
+    WorkspacePinSetResponseSchema,
+    WorkspaceRecoveryInspectResponseSchema,
+    WorkspaceRecoveryRestoreResponseSchema,
     WaitForFinishResponseMessageSchema,
     AgentPermissionRequestMessageSchema,
     AgentPermissionResolvedMessageSchema,
@@ -8072,6 +9941,28 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     HistoryAgentsClearArchivedResponseSchema,
     AttachmentsImagesStatsResponseSchema,
     AttachmentsImagesClearResponseSchema,
+    BrainHostStatusResponseSchema,
+    BrainHostStartResponseSchema,
+    BrainHostStopResponseSchema,
+    BrainHostRestartResponseSchema,
+    BrainEvalsGetResponseSchema,
+    BrainNetworkDiscoverResponseSchema,
+    BrainModelsListResponseSchema,
+    BrainRemoteConfigGetResponseSchema,
+    BrainRemoteConfigPatchResponseSchema,
+    BrainModelsScanResponseSchema,
+    BrainCatalogListResponseSchema,
+    BrainRuntimeListResponseSchema,
+    BrainModelsPullResponseSchema,
+    BrainRuntimeInstallResponseSchema,
+    BrainCalibrateResponseSchema,
+    BrainSweepResponseSchema,
+    BrainBenchResponseSchema,
+    BrainJobsListResponseSchema,
+    BrainJobsCancelResponseSchema,
+    BrainHfSearchResponseSchema,
+    BrainHfQuantsResponseSchema,
+    BrainModelsAddResponseSchema,
     AgentArchivedMessageSchema,
     CloseItemsResponseSchema,
     CheckoutStatusResponseSchema,
@@ -8111,7 +10002,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutRefreshResponseSchema,
     CheckoutPrCreateResponseSchema,
     CheckoutPrMergeResponseSchema,
+    CheckoutForgeSetAutoMergeResponseSchema,
     CheckoutGithubSetAutoMergeResponseSchema,
+    CheckoutCommitsListResponseSchema,
+    CheckoutCommitFileDiffResponseSchema,
+    CheckoutForgeGetCheckDetailsResponseSchema,
     CheckoutGithubGetCheckDetailsResponseSchema,
     PreviewListConfigResponseSchema,
     PreviewStartResponseSchema,
@@ -8126,6 +10021,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     StashListResponseSchema,
     ValidateBranchResponseSchema,
     BranchSuggestionsResponseSchema,
+    ForgeSearchResponseSchema,
     GitHubSearchResponseSchema,
     HostingSearchResponseSchema,
     HostingAuthStatusResponseSchema,
@@ -8136,6 +10032,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     OttoWorktreeArchiveResponseSchema,
     CreateOttoWorktreeResponseSchema,
     FileExplorerResponseSchema,
+    FileSubscribeResponseSchema,
+    FileUnsubscribeResponseSchema,
+    FsFileWriteResponseSchema,
+    FsFileWriteBinaryResponseSchema,
+    FileUpdateSchema,
     ProjectIconResponseSchema,
     FileDownloadTokenResponseSchema,
     FileUploadResponseSchema,
@@ -8255,8 +10156,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()