@otto-code/protocol 0.7.3 → 0.7.5

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,153 @@ 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),
+})
+    .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,
+    }),
+    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(),
+})
+    .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 },
+    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 +576,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 +641,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
@@ -529,6 +698,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();
@@ -1030,6 +1208,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
@@ -1129,6 +1314,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 +1506,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(),
@@ -1656,6 +2302,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 +2410,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(),
@@ -2143,6 +2839,27 @@ export const AgentDetachResponseMessageSchema = z.object({
     type: z.literal("agent.detach.response"),
     payload: AgentActionResponsePayloadSchema,
 });
+// Move a chat into another workspace, in the same project or a different one.
+//
+// Ownership is one field (see the agent snapshot's `workspaceId`), independent of
+// cwd, so re-stamping it is all a move takes: nothing on disk is keyed by
+// workspace, and clients derive which workspace shows a chat from that field
+// alone.
+//
+// The chat's `cwd` does not change, and does not have to match the target
+// workspace's directory. The daemon has never required those to agree (an
+// agent's cwd can already be a subdirectory of its workspace, and nothing
+// validates one against the other), and a session already rooted on disk cannot
+// honestly be re-rooted. So a moved chat keeps running where it was started.
+//
+// Gated by server_info.features.agentWorkspaceTransfer.
+export const AgentWorkspaceTransferRequestMessageSchema = z.object({
+    type: z.literal("agent.workspace.transfer.request"),
+    agentId: z.string(),
+    // The workspace that should own the chat from now on.
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
 // Stop a running observed subagent (Claude Task / ultracode fan-out). The
 // agentId is the observed subagent's id; the daemon resolves it to the owning
 // provider session's task and calls stopTask. Only observed subagents accept
@@ -2767,6 +3484,20 @@ export const WorkspaceTitleSetResponseSchema = z.object({
     type: z.literal("workspace.title.set.response"),
     payload: WorkspaceTitleSetResponsePayloadSchema,
 });
+export const AgentWorkspaceTransferResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    agentId: z.string(),
+    // Which workspace owns the chat now: the requested one when accepted, the one
+    // it never left when refused. Lets a client correct its optimistic state from
+    // the response alone.
+    workspaceId: z.string().nullable(),
+    accepted: z.boolean(),
+    error: z.string().nullable(),
+});
+export const AgentWorkspaceTransferResponseMessageSchema = z.object({
+    type: z.literal("agent.workspace.transfer.response"),
+    payload: AgentWorkspaceTransferResponsePayloadSchema,
+});
 export const SetVoiceModeResponseMessageSchema = z.object({
     type: z.literal("set_voice_mode_response"),
     payload: z.object({
@@ -3567,6 +4298,11 @@ export const WorkspaceArchivePreflightRequestSchema = z.object({
     requestId: z.string(),
     workspaceId: z.string(),
 });
+// Where the Changes view's base branch came from. Surfaced so the chip can say *why* it is
+// comparing against this branch: an inferred parent is a heuristic over a graph that does not
+// record the answer, and it has to look like one or a wrong guess reads as a bug in the diff.
+// COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+export const CheckoutBaseSourceSchema = z.enum(["user", "inferred", "worktree", "default"]);
 // Repoint a worktree-backed workspace's base branch — what the Changes view diffs
 // against, and what merge-into-base and PR creation target. On a stacked branch the
 // useful base is the parent branch, not the repo default, the same way a forge PR
@@ -3576,8 +4312,14 @@ export const WorktreeBaseRefSetRequestSchema = z.object({
     type: z.literal("worktree.baseRef.set.request"),
     requestId: z.string(),
     workspaceId: z.string(),
-    // Branch name, with or without an `origin/` prefix; null resets to the default branch.
+    // Branch name; null resets to the default branch. An `origin/` prefix is meaningful and is
+    // kept — `main` and `origin/main` are different comparisons whenever the two have drifted.
     baseRef: z.string().nullable(),
+    // Forget the remembered base and detect the branch's parent again, ignoring `baseRef`.
+    // The escape hatch for a wrong guess: parent detection is a heuristic over a graph that does
+    // not record the answer, and the result is sticky, so it has to be re-runnable on demand.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    redetect: z.boolean().optional(),
 });
 // Create a new workspace record. Unlike open_project, this never deduplicates by
 // directory: it always produces a fresh workspace. The source discriminates
@@ -4239,6 +4981,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,
@@ -4254,12 +5018,14 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     DiagnosticsRequestSchema,
     GetDaemonConfigRequestMessageSchema,
     SetDaemonConfigRequestMessageSchema,
+    ConnectorsListToolsRequestSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
     SpeechTtsSpeakRequestSchema,
     SpeechTtsSpeakCancelRequestSchema,
     VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
+    AgentPersonalitiesGenerateProfileRequestSchema,
     ReadProjectConfigRequestMessageSchema,
     WriteProjectConfigRequestMessageSchema,
     DictationStreamStartMessageSchema,
@@ -4301,6 +5067,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentThinkingRequestMessageSchema,
     SetAgentFeatureRequestMessageSchema,
     AgentDetachRequestMessageSchema,
+    AgentWorkspaceTransferRequestMessageSchema,
     AgentSubagentStopRequestMessageSchema,
     AgentBackgroundTaskStopRequestMessageSchema,
     AgentBackgroundTaskClearRequestMessageSchema,
@@ -4632,6 +5399,41 @@ export const ServerInfoStatusPayloadSchema = z
         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.
@@ -4732,6 +5534,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.
@@ -4763,6 +5569,13 @@ export const ServerInfoStatusPayloadSchema = z
         // the daemon can write the worktree's metadata.
         // COMPAT(worktreeDiffBase): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
         worktreeDiffBase: z.boolean().optional(),
+        // Set when the daemon stores the diff base *per branch*, which is what lets any git
+        // checkout repoint it rather than only an Otto worktree — a plain checkout's gitdir is
+        // shared by every branch in it, so a single stored base would bleed across branch
+        // switches. Also gates parent-branch detection, the `origin/`-qualified pin, and the
+        // re-detect action. Without it the client keeps the worktree-only picker.
+        // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4, drop the gate when daemon floor >= v0.7.4.
+        checkoutDiffBaseAnyRepo: z.boolean().optional(),
         // Set when the daemon persists the host-level hideMergeIntoBaseAction
         // workspace policy (read/written via the daemon config RPCs). Without
         // it the client hides the Workspaces toggle, since patching the field
@@ -4818,11 +5631,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.
@@ -4868,6 +5693,12 @@ export const ServerInfoStatusPayloadSchema = z
         // the daemon half of the Storage section; the app-side preview cache row
         // is local and always shown.
         attachmentStorage: z.boolean().optional(),
+        // COMPAT(agentWorkspaceTransfer): added in v0.7.4, drop the gate when
+        // daemon floor >= v0.7.4. Set when the daemon serves
+        // `agent.workspace.transfer` — moving a chat to another workspace over
+        // 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(),
     })
         .optional(),
 })
@@ -5572,6 +6403,9 @@ export const WorktreeBaseRefSetResponseSchema = z.object({
         baseRef: z.string().nullable(),
         // The stored base is the repository default branch (no stacked-branch override).
         isDefault: z.boolean(),
+        // Where the resulting base came from, so the client can label it without a refetch.
+        // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+        baseSource: CheckoutBaseSourceSchema.optional(),
         error: z.string().nullable(),
     }),
 });
@@ -5890,6 +6724,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
@@ -6048,6 +6895,15 @@ const CheckoutStatusCommonSchema = z.object({
     // COMPAT(checkoutStatusGitStateAt): added in v0.6.8; absent from older daemons.
     // Drop the optional marker when floor >= v0.6.8 (target 2027-01-24).
     gitStateAt: z.number().optional(),
+    // Where `baseRef` came from, so the base chip can label an inferred parent as a guess rather
+    // than presenting it with the same authority as an explicit pick.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    baseSource: CheckoutBaseSourceSchema.optional(),
+    // Whether this checkout can have its base repointed. True for any git checkout on a daemon
+    // that stores the base per branch; older daemons only supported Otto worktrees, which the
+    // client inferred from isOttoOwnedWorktree.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    isBaseEditable: z.boolean().optional(),
 });
 const CheckoutStatusNotGitSchema = CheckoutStatusCommonSchema.extend({
     isGit: z.literal(false),
@@ -7957,12 +8813,14 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     DiagnosticsResponseSchema,
     GetDaemonConfigResponseMessageSchema,
     SetDaemonConfigResponseMessageSchema,
+    ConnectorsListToolsResponseSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
     SpeechTtsSpeakResponseSchema,
     SpeechTtsSpeakCancelResponseSchema,
     VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
+    AgentPersonalitiesGenerateProfileResponseSchema,
     ReadProjectConfigResponseMessageSchema,
     WriteProjectConfigResponseMessageSchema,
     SetAgentModeResponseMessageSchema,
@@ -7970,6 +8828,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentThinkingResponseMessageSchema,
     SetAgentFeatureResponseMessageSchema,
     AgentDetachResponseMessageSchema,
+    AgentWorkspaceTransferResponseMessageSchema,
     AgentQueueRemoveResponseMessageSchema,
     AgentQueueReorderResponseMessageSchema,
     AgentQueueClearResponseMessageSchema,
@@ -7999,6 +8858,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,