@otto-code/protocol 0.6.2 → 0.6.4

package/dist/messages.js

@@ -46,6 +46,28 @@ const MutableStructuredGenerationProviderSchema = z
 const MutableMetadataGenerationConfigSchema = z
     .object({
     providers: z.array(MutableStructuredGenerationProviderSchema).default([]),
+    // Master switch for daemon-side metadata generation (chat auto-titles,
+    // agent progress summaries, and other structured side-generations). Default
+    // true preserves today's behavior. Read by the generation path (WP-B).
+    enabled: z.boolean().default(true),
+    // When true, metadata generation prefers a role-matched Writer personality
+    // over the cheap default tier. Default false — cheap-tier routing is the
+    // default. Read by the generation routing (WP-B).
+    preferWriterPersonalities: z.boolean().default(false),
+})
+    .passthrough();
+// Daemon-wide agent behavior toggles. Each maps to a Claude-tier capability;
+// providers that can't honor a setting silently ignore it (WP-E wires the
+// reads). All default true so a fresh host behaves exactly like today.
+const MutableAgentBehaviorsConfigSchema = z
+    .object({
+    // Native next-prompt predictions (Claude prompt_suggestion stream events).
+    promptSuggestions: z.boolean().default(true),
+    // Agent-authored progress summaries emitted during a turn.
+    agentProgressSummaries: z.boolean().default(true),
+    // Default value of an agent's notifyOnFinish when the spawn path leaves it
+    // unspecified (the current implicit default).
+    notifyOnFinishDefault: z.boolean().default(true),
 })
     .passthrough();
 export const TerminalProfileSchema = z
@@ -177,6 +199,23 @@ const AgentPersonalityVoiceSchema = z
     name: z.string().min(1),
 })
     .passthrough();
+// The three Visualizer lifecycle moments a personality voice-cue line can
+// belong to. Protocol owns this vocabulary — the daemon's cue generator, the
+// personality editor, and the Visualizer playback hook all import it from here.
+export const CUE_MOMENTS = ["join", "thinking", "done"];
+// Pre-generated (and user-editable) spoken "voice cue" lines for the personality
+// — a few short variations for each of three Visualizer moments (its node joins
+// the graph, first starts thinking, completes). Stored on the personality so
+// they're deterministic and hand-tunable in the editor; the Visualizer reads
+// them directly (no runtime generation). All groups optional/loose — a
+// personality may have none, or only some. See docs/visualizer.md "Voice cues".
+const AgentPersonalityVoiceCuesSchema = z
+    .object({
+    join: z.array(z.string()).optional(),
+    thinking: z.array(z.string()).optional(),
+    done: z.array(z.string()).optional(),
+})
+    .passthrough();
 // A named, reusable agent template stored per-host. `id` is the stable identity
 // everything binds to; `name` is a freely-renamable label. Effort and roles are
 // plain strings on the wire (like speech engine/model ids) so the daemon can
@@ -199,6 +238,7 @@ export const AgentPersonalitySchema = z
     roles: z.array(z.string().min(1)).optional(),
     spinner: AgentPersonalitySpinnerSchema.optional(),
     voice: AgentPersonalityVoiceSchema.optional(),
+    voiceCues: AgentPersonalityVoiceCuesSchema.optional(),
 })
     .passthrough();
 const MutableAgentPersonalitiesConfigSchema = z
@@ -280,11 +320,27 @@ export const MutableDaemonConfigSchema = z
     mcp: z
         .object({
         injectIntoAgents: z.boolean(),
+        // Daemon-wide Otto tool-group allowlist for the MCP (Claude) path.
+        // undefined = all groups enabled (mirrors openai-compat's per-provider
+        // ottoToolGroups semantics). An empty array = no Otto tools. Read by the
+        // MCP catalog gating (WP-A).
+        toolGroups: z.array(z.enum(OTTO_TOOL_GROUPS)).optional(),
     })
         .passthrough(),
     browserTools: MutableBrowserToolsConfigSchema.default({ enabled: false }),
+    // Daemon-wide agent behavior toggles (Claude-tier capabilities). Defaults to
+    // all-on so a new client parsing an old daemon's config sees today's behavior.
+    agentBehaviors: MutableAgentBehaviorsConfigSchema.default({
+        promptSuggestions: true,
+        agentProgressSummaries: true,
+        notifyOnFinishDefault: true,
+    }),
     providers: z.record(z.string(), MutableDaemonProviderConfigSchema).default({}),
-    metadataGeneration: MutableMetadataGenerationConfigSchema.default({ providers: [] }),
+    metadataGeneration: MutableMetadataGenerationConfigSchema.default({
+        providers: [],
+        enabled: true,
+        preferWriterPersonalities: false,
+    }),
     autoArchiveAfterMerge: z.boolean().default(false),
     enableTerminalAgentHooks: z.boolean().default(false),
     appendSystemPrompt: z.string().default(""),
@@ -311,6 +367,8 @@ export const MutableDaemonConfigPatchSchema = z
     .object({
     mcp: MutableDaemonConfigSchema.shape.mcp.partial().optional(),
     browserTools: MutableBrowserToolsConfigSchema.partial().optional(),
+    // Gated by server_info features.agentBehaviorToggles; patches deep-merge.
+    agentBehaviors: MutableAgentBehaviorsConfigSchema.partial().optional(),
     // A null entry removes the provider's config entirely (custom provider
     // uninstall). Gated by server_info features.providerRemove — old daemons
     // reject null values.
@@ -367,6 +425,22 @@ const AgentProviderNoticeSchema = z.discriminatedUnion("type", [
     z.object({ type: z.literal("warning"), message: z.string() }),
     z.object({ type: z.literal("error"), message: z.string() }),
 ]);
+// Provider-reported plan rate-limit status (e.g. Claude claude.ai plan
+// windows), pushed on the agent stream when it changes. Presentation-only:
+// the app decides whether to show it (rateLimitWarningsEnabled setting).
+export const AgentRateLimitInfoSchema = z.object({
+    status: z.enum(["allowed", "warning", "rejected"]),
+    // Percentage of the limit window used, 0-100. Absent when the provider
+    // does not report it (Claude only includes it near the limit).
+    utilizationPercent: z.number().optional(),
+    // Provider-reported window identifier, e.g. "five_hour" | "seven_day".
+    // Open set — display code falls back to a generic label for unknown values.
+    limitType: z.string().optional(),
+    // ISO 8601 timestamp when the window resets.
+    resetsAt: z.string().optional(),
+    // True when usage is currently drawing from overage/extra usage credits.
+    isUsingOverage: z.boolean().optional(),
+});
 export const AgentFeatureToggleSchema = z.object({
     type: z.literal("toggle"),
     id: z.string(),
@@ -436,13 +510,25 @@ const AgentCapabilityFlagsSchema = z
     supportsRewindBoth: z.boolean().optional().default(false),
 })
     .catchall(z.boolean());
+const ContextCompositionSchema = z.object({
+    systemPrompt: z.number().optional(),
+    userMessages: z.number().optional(),
+    toolResults: z.number().optional(),
+    reasoning: z.number().optional(),
+    subagentResults: z.number().optional(),
+});
 const AgentUsageSchema = z.object({
     inputTokens: z.number().optional(),
     cachedInputTokens: z.number().optional(),
+    // Cache-write (prompt-cache creation) tokens; Claude-specific, optional/additive.
+    cacheCreationInputTokens: z.number().optional(),
     outputTokens: z.number().optional(),
     totalCostUsd: z.number().optional(),
     contextWindowMaxTokens: z.number().optional(),
     contextWindowUsedTokens: z.number().optional(),
+    // Provider-graded context breakdown for the visualizer ring/bar; absent ⇒
+    // occupancy only (pre-composition behavior). See ContextComposition.
+    contextComposition: ContextCompositionSchema.optional(),
 });
 const AgentSessionConfigSchema = z.object({
     provider: AgentProviderSchema,
@@ -754,6 +840,22 @@ export const AgentStreamEventPayloadSchema = z.discriminatedUnion("type", [
         })
             .optional(),
     }),
+    // Predicted next-user-prompt suggestion emitted after a turn. Transient: the
+    // app shows the latest as composer ghost text (Tab to accept) and clears it on
+    // the next turn_started. COMPAT(promptSuggestions): added in v0.6.3.
+    z.object({
+        type: z.literal("prompt_suggestion"),
+        provider: AgentProviderSchema,
+        suggestion: z.string(),
+    }),
+    // Provider-reported plan rate-limit status (Claude claude.ai plan windows).
+    // Transient: the app shows a suppressible warning strip near the composer.
+    // Deduped provider-side. COMPAT(rateLimitEvents): added in v0.6.3.
+    z.object({
+        type: z.literal("rate_limit_updated"),
+        provider: AgentProviderSchema,
+        info: AgentRateLimitInfoSchema,
+    }),
 ]);
 const AgentPersistenceHandleSchema = z
     .object({
@@ -1229,6 +1331,32 @@ export const SpeechTtsPreviewRequestSchema = z.object({
         .passthrough()
         .optional(),
 });
+// COMPAT(visualizerVoiceCues): added in v0.6.3; gate lives in
+// features.visualizerVoiceCues. Author short spoken "cue" lines for a
+// personality — a handful of variations each for three Visualizer moments
+// (join / thinking / done) — via the Writer mini-task chain, flavored by the
+// persona's `name` + `prompt`. The persona is passed inline (not a stored id)
+// so the personality editor can generate for an unsaved draft too; the result
+// is stored on the personality (`voiceCues`) and edited there, so this is an
+// editor-time action, not a runtime one. `cwd` scopes provider resolution to a
+// workspace; omitted falls back to any resolvable one.
+export const VisualizerVoiceCuesGenerateRequestSchema = z.object({
+    type: z.literal("visualizer.voiceCues.generate.request"),
+    requestId: z.string(),
+    name: z.string(),
+    prompt: z.string().optional(),
+    cwd: z.string().optional(),
+    // The persona's roles (e.g. "researcher", "coder") so the writer can flavor
+    // the lines to what the agent does. Permissive strings to match the stored
+    // personality shape (forward-compatible with roles this daemon predates).
+    roles: z.array(z.string().min(1)).optional(),
+    // When present, author only this one moment's lines (a focused single-moment
+    // prompt) and return only that group. The editor issues one request per
+    // moment so it can show generation progress and keep the moments distinct.
+    // Omitted → author all three at once (the original all-in-one path, still
+    // used by older clients).
+    moment: z.enum(CUE_MOMENTS).optional(),
+});
 export const AgentPersonalitiesGetStatsRequestSchema = z.object({
     type: z.literal("agentPersonalities.get_stats.request"),
     requestId: z.string(),
@@ -1369,6 +1497,26 @@ export const ActivityCountersSchema = z.object({
     toolsCalled: z.number().default(0),
     artifactsCreated: z.number().default(0),
     schedulesExecuted: z.number().default(0),
+    // Usage & cost accounting (WP-G). Additive/defaulted like every counter above,
+    // so old daemons emit 0 and old clients drop the unknown leaves. "In"/"Out"
+    // are token totals; *CostMicroUsd are integer micro-USD (usd*1e6) to stay
+    // summable — populated only for turns reporting a real provider cost (Claude).
+    // The client detects whether the daemon actually populates these via
+    // features.usageCostCategories (see below).
+    costMicroUsd: z.number().default(0),
+    mainChatTokensIn: z.number().default(0),
+    mainChatTokensOut: z.number().default(0),
+    mainChatCostMicroUsd: z.number().default(0),
+    generationsTokensIn: z.number().default(0),
+    generationsTokensOut: z.number().default(0),
+    generationsCostMicroUsd: z.number().default(0),
+    subagentTokensIn: z.number().default(0),
+    subagentTokensOut: z.number().default(0),
+    subagentCostMicroUsd: z.number().default(0),
+    compactionTokensIn: z.number().default(0),
+    compactionTokensOut: z.number().default(0),
+    claudeTokensIn: z.number().default(0),
+    claudeTokensOut: z.number().default(0),
 });
 export const StatsActivityGetRequestMessageSchema = z.object({
     type: z.literal("stats.activity.get.request"),
@@ -1396,6 +1544,100 @@ export const StatsActivityGetResponseMessageSchema = z.object({
 export const ActivityStatsChangedSchema = z.object({
     type: z.literal("activity_stats_changed"),
 });
+// One itemized row of the usage ledger — a single token/cost-bearing activity
+// (a chat turn, a sub-agent turn, or a background generation). The aggregate
+// ActivityCounters above are the rollup of this same event stream; the ledger is
+// the scrollable detail behind the tiles (usage-ledger project). `kind` and
+// `provider` are plain strings (not enums) so an OLD client still parses a NEW
+// daemon that emits a kind it hasn't heard of — it renders it generically rather
+// than failing the whole message. All token/cost leaves default to 0.
+export const UsageEventSchema = z.object({
+    /** Stable unique id for the row (daemon-generated). */
+    id: z.string(),
+    /** Epoch milliseconds when the activity was recorded. */
+    at: z.number(),
+    /** "chat" | "subagent" | "generation" today; open for future kinds. */
+    kind: z.string(),
+    /** Finer label within the kind (e.g. a generation's purpose, a sub-agent name). */
+    subtype: z.string().optional(),
+    /** Agent provider id (e.g. "claude", an openai-compat endpoint id). */
+    provider: z.string(),
+    /** Model id/name if known at the increment site. */
+    model: z.string().optional(),
+    /** input + cached + cache-creation tokens (same "in" split the counters use). */
+    tokensIn: z.number().default(0),
+    /**
+     * The portion of `tokensIn` served from the provider prompt cache (cache-read),
+     * billed at a fraction of fresh input. The fresh (full-rate) portion is
+     * `tokensIn - cachedTokensIn`. Absent when the provider reports no cache reads
+     * (e.g. openai-compat endpoints with no caching), which reads as all-fresh.
+     */
+    cachedTokensIn: z.number().optional(),
+    /** output tokens. */
+    tokensOut: z.number().default(0),
+    /** Real provider spend in integer micro-USD (usd*1e6); 0 for token-only providers. */
+    costMicroUsd: z.number().default(0),
+    /** Mid-turn compaction slice folded into this turn's usage, if any (token-only). */
+    compactionTokensIn: z.number().optional(),
+    compactionTokensOut: z.number().optional(),
+    /** The agent this activity belonged to, for tracing back to the chat. */
+    agentId: z.string().optional(),
+    /**
+     * How many model round-trips this row aggregates. A chat row is one query, but
+     * a sub-agent row covers a whole delegated task that internally ran many
+     * rounds — and each round re-reads the growing context, so `cachedTokensIn` is
+     * cumulative cache-READS, not a cache size. Surfacing the count is what makes a
+     * large cached figure legible instead of looking like a bug. Absent when the
+     * provider doesn't report it.
+     */
+    rounds: z.number().optional(),
+    /**
+     * Sub-agent rows only — the spawn-tree identity that lets the Log group rows
+     * the way a human reads the run (chat turn → its sub-agents → their
+     * sub-agents) instead of by settle time, which async sub-agents crossing turn
+     * boundaries makes wrong. `startedAt` is when the sub-agent was first
+     * observed (epoch ms; a row belongs to the turn that spawned it, not the turn
+     * it happened to settle in), `subagentKey` is its stable observed key, and
+     * `parentSubagentKey` is the spawning sub-agent's key — absent for depth-1
+     * sub-agents spawned by the chat itself.
+     */
+    startedAt: z.number().optional(),
+    subagentKey: z.string().optional(),
+    parentSubagentKey: z.string().optional(),
+});
+export const UsageLogGetRequestMessageSchema = z.object({
+    type: z.literal("usage.log.get.request"),
+    requestId: z.string(),
+    /** Max rows to return (daemon clamps). Newest-first. */
+    limit: z.number().optional(),
+    /** Cursor: return only rows strictly older than this epoch-ms (for "load more"). */
+    before: z.number().optional(),
+});
+export const UsageLogGetResponseMessageSchema = z.object({
+    type: z.literal("usage.log.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        /** Newest-first page of ledger rows. */
+        events: z.array(UsageEventSchema).default([]),
+        /** True when older rows exist beyond this page (paginate with `before`). */
+        hasMore: z.boolean().default(false),
+    }),
+});
+// Wipe every daemon-wide usage counter AND the itemized usage ledger back to
+// zero — the "Reset" action on the Metrics screen. One RPC clears both sinks
+// (the day-bucketed ActivityStatsStore and the UsageLogStore) so the tiles and
+// the Log tab start fresh together. Gated behind features.statsReset so an old
+// daemon (no handler) never receives a request the client thinks it can send.
+export const StatsActivityResetRequestMessageSchema = z.object({
+    type: z.literal("stats.activity.reset.request"),
+    requestId: z.string(),
+});
+export const StatsActivityResetResponseMessageSchema = z.object({
+    type: z.literal("stats.activity.reset.response"),
+    payload: z.object({
+        requestId: z.string(),
+    }),
+});
 export const AgentContextGetUsageRequestMessageSchema = z.object({
     type: z.literal("agent.context.get_usage.request"),
     agentId: z.string(),
@@ -1608,6 +1850,164 @@ export const SuggestedTasksChangedSchema = z.object({
         tasks: z.array(SuggestedTaskInfoSchema),
     }),
 });
+// Context Management — the daemon's accounting of everything a provider sends
+// before the user types (see projects/context-management/context-management.md).
+//
+// Two distinctions carry the whole feature and must not be collapsed on the
+// wire: an `import` edge is inlined into the request while a `reference` edge
+// costs only its link text, and `costClass` separates weight that rides every
+// request from weight that loads only when the agent touches an area.
+//
+// All numbers are estimates (chars/4) and `confidence` says how much to trust
+// the file set: `exact` when Otto composed the payload itself, `convention`
+// when resolved from a provider's documented layout, `unverified` for
+// subprocess-owned agents we cannot see into.
+// COMPAT(contextManagement): added in v0.6.5, drop the gate when daemon floor >= v0.6.5.
+export const ContextScopeSchema = z.enum([
+    "enterprise",
+    "global",
+    "project",
+    "local",
+    "subdirectory",
+    "runtime",
+]);
+export const ContextCategorySchema = z.enum([
+    "context_files",
+    "memory_index",
+    "skills_roster",
+    "mcp_tools",
+    "otto_injected",
+    "system_prompt",
+]);
+export const ContextCostClassSchema = z.enum(["fixed", "conditional", "referenced"]);
+export const ContextSeveritySchema = z.enum(["ok", "notice", "warn", "critical"]);
+export const ContextConfidenceSchema = z.enum(["exact", "convention", "unverified"]);
+export const ContextFindingKindSchema = z.enum([
+    "dead_import",
+    "dead_reference",
+    "duplicate_across_scope",
+    "duplicate_within_file",
+    "oversized_memory_entry",
+    "import_cycle",
+    "depth_capped",
+]);
+export const ContextRangeSchema = z.object({
+    start: z.number(),
+    end: z.number(),
+});
+export const ContextFindingSchema = z.object({
+    kind: ContextFindingKindSchema,
+    message: z.string(),
+    range: ContextRangeSchema.optional(),
+    relatedNodeIds: z.array(z.string()).optional(),
+    // The node this finding is about. Redundant while the finding sits on its
+    // node, load-bearing once the report flattens them all into one list — that
+    // list is the "Worth fixing" tab, and without this a row cannot say where it
+    // came from or take you there.
+    nodeId: z.string().optional(),
+    // 1-based line of `range.start` in that node's file, so the fix list can jump
+    // the editor without the client re-reading bytes to count newlines.
+    line: z.number().optional(),
+    // Last line of the range, so the client can select the whole offending span
+    // rather than dropping a cursor at the top of it.
+    lineEnd: z.number().optional(),
+});
+export const ContextNodeSchema = z.object({
+    id: z.string(),
+    path: z.string(),
+    relPath: z.string(),
+    scope: ContextScopeSchema,
+    category: ContextCategorySchema,
+    costClass: ContextCostClassSchema,
+    bytes: z.number(),
+    estTokens: z.number(),
+    // Extra parents that also reach this node. The node is listed and counted
+    // exactly once; these render as a dimmed "also imported by" chip.
+    alsoImportedByNodeIds: z.array(z.string()),
+    findings: z.array(ContextFindingSchema),
+});
+export const ContextEdgeSchema = z.object({
+    fromNodeId: z.string(),
+    // Null when the target could not be resolved — pairs with a dead_* finding.
+    toNodeId: z.string().nullable(),
+    kind: z.enum(["import", "reference"]),
+    rawTarget: z.string(),
+    // Byte range of the whole reference token in the parent file, which is what
+    // makes "Always load" <-> "Link only" a single-span edit.
+    range: ContextRangeSchema,
+});
+export const ContextCategoryTotalSchema = z.object({
+    category: ContextCategorySchema,
+    estTokens: z.number(),
+    sharePercent: z.number(),
+    severity: ContextSeveritySchema,
+});
+export const ContextReportSchema = z.object({
+    workspaceId: z.string(),
+    provider: z.string(),
+    // The window the report was evaluated against — from the active model, or
+    // the client's what-if picker. Severity is meaningless without it.
+    windowTokens: z.number(),
+    scannedAt: z.string(),
+    confidence: ContextConfidenceSchema,
+    supported: z.boolean(),
+    supportsImports: z.boolean(),
+    nodes: z.array(ContextNodeSchema),
+    edges: z.array(ContextEdgeSchema),
+    categoryTotals: z.array(ContextCategoryTotalSchema),
+    fixedTotal: z.number(),
+    conditionalTotal: z.number(),
+    referencedTotal: z.number(),
+    workingRoom: z.number(),
+    aggregateSeverity: ContextSeveritySchema,
+    findings: z.array(ContextFindingSchema),
+});
+// Pushed with the full current report whenever a watched context file changes.
+// Full-report reconciliation, same idiom as suggested_tasks_changed.
+export const ContextReportChangedSchema = z.object({
+    type: z.literal("context_report_changed"),
+    payload: z.object({
+        workspaceId: z.string(),
+        report: ContextReportSchema.nullable(),
+    }),
+});
+// `provider` and `windowTokens` are the what-if pickers: omitted means "the
+// active agent's provider and its model's real window".
+export const ContextReportGetRequestMessageSchema = z.object({
+    type: z.literal("context.report.get.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    provider: z.string().optional(),
+    windowTokens: z.number().optional(),
+});
+export const ContextReportGetResponseMessageSchema = z.object({
+    type: z.literal("context.report.get.response"),
+    payload: z.object({
+        requestId: z.string(),
+        report: ContextReportSchema.nullable(),
+    }),
+});
+// Converts one edge between "always loaded" and "link only". Server-side
+// because the parent file may live outside the workspace root.
+export const ContextEdgeConvertRequestMessageSchema = z.object({
+    type: z.literal("context.edge.convert.request"),
+    requestId: z.string(),
+    workspaceId: z.string(),
+    // The parent file holding the reference — its `ContextNode.path`, not its
+    // id: ids are case-folded on Windows and are not safe to write through.
+    filePath: z.string(),
+    rawTarget: z.string(),
+    range: ContextRangeSchema,
+    target: z.enum(["import", "reference"]),
+});
+export const ContextEdgeConvertResponseMessageSchema = z.object({
+    type: z.literal("context.edge.convert.response"),
+    payload: z.object({
+        requestId: z.string(),
+        ok: z.boolean(),
+        error: z.string().optional(),
+    }),
+});
 // Aggregate outcome for a start/dismiss over one or more tasks. `succeeded`/
 // `failed` count the tasks acted on so the client can report "Started 3 tasks";
 // `error` collects any per-task failure messages (the failed tasks' chips stay).
@@ -1620,11 +2020,22 @@ const SuggestedTaskActionResponsePayloadSchema = z.object({
     error: z.string().nullable(),
 });
 // Start one or more suggested tasks, applying the SAME mode to each — no
-// combining. `worktree` spins a new worktree-backed workspace per task, `local`
-// a new session in the same repo/cwd per task, `in_session` steers the parent
-// agent with the task prompt. The daemon resolves the parent agent's brain
-// (provider/model/personality) so a started task continues the suggesting agent.
-export const TasksSuggestedStartModeSchema = z.enum(["worktree", "local", "in_session"]);
+// combining. Four modes, only `subagent` links the new agent to the parent:
+//  - `new_chat`:   a fresh independent agent in its own tab, same repo/cwd, NO
+//                  parent link — survives the parent's cancel/archive.
+//  - `subagent`:   a bound child agent that shows in the parent's Subagents
+//                  track and archive-cascades with it.
+//  - `worktree`:   an independent agent on a new git worktree (auto branch-off),
+//                  isolated workspace — also unlinked from the parent.
+//  - `in_session`: steers the parent agent with the task prompt (no new agent).
+// The daemon resolves the parent agent's brain (provider/model/personality) so a
+// started task continues the suggesting agent.
+export const TasksSuggestedStartModeSchema = z.enum([
+    "new_chat",
+    "subagent",
+    "worktree",
+    "in_session",
+]);
 export const TasksSuggestedStartRequestMessageSchema = z.object({
     type: z.literal("tasks.suggested.start.request"),
     parentAgentId: z.string(),
@@ -2608,6 +3019,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigRequestMessageSchema,
     SpeechSettingsGetOptionsRequestSchema,
     SpeechTtsPreviewRequestSchema,
+    VisualizerVoiceCuesGenerateRequestSchema,
     AgentPersonalitiesGetStatsRequestSchema,
     ReadProjectConfigRequestMessageSchema,
     WriteProjectConfigRequestMessageSchema,
@@ -2625,6 +3037,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProviderDiagnosticRequestMessageSchema,
     ProviderUsageListRequestMessageSchema,
     StatsActivityGetRequestMessageSchema,
+    ContextReportGetRequestMessageSchema,
+    ContextEdgeConvertRequestMessageSchema,
+    StatsActivityResetRequestMessageSchema,
+    UsageLogGetRequestMessageSchema,
     AgentContextGetUsageRequestMessageSchema,
     ResumeAgentRequestMessageSchema,
     ImportAgentRequestMessageSchema,
@@ -2938,8 +3354,19 @@ export const ServerInfoStatusPayloadSchema = z
         observedSubagents: z.boolean().optional(),
         // COMPAT(backgroundShellTasks): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
         backgroundShellTasks: z.boolean().optional(),
+        // COMPAT(retainedTranscripts): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Daemon retains schedule/artifact generation-agent chats for read-only
+        // viewing after the run. See docs/safe-unattended.md.
+        retainedTranscripts: z.boolean().optional(),
         // COMPAT(suggestedTasks): added in v0.5.6, drop the gate when daemon floor >= v0.5.6.
         suggestedTasks: z.boolean().optional(),
+        // Daemon can resolve and evaluate the provider's context graph, serve
+        // context.report.* and push context_report_changed. Without it the
+        // client hides both the Context Management tab and the composer
+        // warning entirely — there is no degraded client-side fallback, since
+        // only the daemon can see the files a provider loads.
+        // COMPAT(contextManagement): added in v0.6.5, drop the gate when daemon floor >= v0.6.5.
+        contextManagement: z.boolean().optional(),
         // COMPAT(textEditor): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
         textEditor: z.boolean().optional(),
         // COMPAT(projectSearch): added in v0.4.4, drop the gate when daemon floor >= v0.4.4.
@@ -2956,6 +3383,8 @@ export const ServerInfoStatusPayloadSchema = z
         agentPersonalities: z.boolean().optional(),
         // COMPAT(ttsPreview): added in v0.4.7, drop the gate when daemon floor >= v0.4.7.
         ttsPreview: z.boolean().optional(),
+        // COMPAT(visualizerVoiceCues): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        visualizerVoiceCues: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
         setAgentPersonality: z.boolean().optional(),
         // COMPAT(checkoutGitCommit): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
@@ -2984,6 +3413,53 @@ export const ServerInfoStatusPayloadSchema = z
         // permissions). The client gates this behind an "edit anyway" warning;
         // an old daemon leaves the flag unset and out-of-project files are not offered.
         fileOutsideWorkspace: z.boolean().optional(),
+        // COMPAT(promptSuggestions): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        // Set when the daemon emits agent_stream `prompt_suggestion` events (native
+        // Claude next-prompt predictions). The client gates the Settings toggle on
+        // this; suggestions already degrade silently on an old daemon (no event).
+        promptSuggestions: z.boolean().optional(),
+        // COMPAT(rateLimitEvents): added in v0.6.3, drop the gate when daemon floor >= v0.6.3.
+        // Set when the daemon emits agent_stream `rate_limit_updated` events (Claude
+        // plan rate-limit status). Warnings degrade silently on an old daemon (no event).
+        rateLimitEvents: z.boolean().optional(),
+        // COMPAT(openaiCompatMaxToolRounds): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Set when the daemon honors the provider-level `maxToolRounds` override for
+        // openai-compat agents. The client gates the Agents-tab control on this so an
+        // old daemon (which silently ignores the field and keeps the fixed 50-round
+        // cap) shows "Update the host" instead of a knob that does nothing.
+        openaiCompatMaxToolRounds: z.boolean().optional(),
+        // COMPAT(mcpToolGroups): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Set when the daemon honors `mcp.toolGroups` — per-group gating of the
+        // Otto tool catalog on the MCP (Claude) path. Old daemons register every
+        // group regardless, so the client hides the categorized section instead
+        // of showing category switches that do nothing.
+        mcpToolGroups: z.boolean().optional(),
+        // COMPAT(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(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.
+        metadataGenerationEnabled: z.boolean().optional(),
+        // COMPAT(usageCostCategories): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Set when the daemon populates the per-category token/cost counters in
+        // ActivityCounters (mainChat/generations/subagents/compaction + Claude
+        // provider split + micro-USD cost). An old daemon leaves them all at 0,
+        // so the client hides the Usage & Cost column's category grid rather than
+        // presenting a column of zeros as if it were truthful accounting.
+        usageCostCategories: z.boolean().optional(),
+        // COMPAT(usageLog): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Set when the daemon serves the itemized usage ledger (usage.log.get).
+        // The client gates the Metrics screen's "Log" tab on this; an old daemon
+        // simply doesn't offer the tab.
+        usageLog: z.boolean().optional(),
+        // COMPAT(statsReset): added in v0.6.4, drop the gate when daemon floor >= v0.6.4.
+        // Set when the daemon handles stats.activity.reset (wipe all usage
+        // counters + the itemized ledger). The client gates the Metrics screen's
+        // "Reset" button on this; an old daemon simply doesn't offer it.
+        statsReset: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3666,6 +4142,18 @@ export const SpeechTtsPreviewResponseSchema = z.object({
     })
         .passthrough(),
 });
+export const VisualizerVoiceCuesGenerateResponseSchema = z.object({
+    type: z.literal("visualizer.voiceCues.generate.response"),
+    payload: z
+        .object({
+        requestId: z.string(),
+        // Absent when generation failed (see error) or no writer/provider
+        // resolves on this host. Reuses the stored-cues shape.
+        cues: AgentPersonalityVoiceCuesSchema.optional(),
+        error: z.string().optional(),
+    })
+        .passthrough(),
+});
 export const AgentPersonalitiesGetStatsResponseSchema = z.object({
     type: z.literal("agentPersonalities.get_stats.response"),
     payload: z
@@ -5141,6 +5629,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetDaemonConfigResponseMessageSchema,
     SpeechSettingsGetOptionsResponseSchema,
     SpeechTtsPreviewResponseSchema,
+    VisualizerVoiceCuesGenerateResponseSchema,
     AgentPersonalitiesGetStatsResponseSchema,
     ReadProjectConfigResponseMessageSchema,
     WriteProjectConfigResponseMessageSchema,
@@ -5156,6 +5645,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     TasksSuggestedStartResponseMessageSchema,
     TasksSuggestedDismissResponseMessageSchema,
     SuggestedTasksChangedSchema,
+    ContextReportChangedSchema,
     AgentPersonalitySetResponseMessageSchema,
     AgentRewindResponseMessageSchema,
     UpdateAgentResponseMessageSchema,
@@ -5241,6 +5731,10 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProviderDiagnosticResponseMessageSchema,
     ProviderUsageListResponseMessageSchema,
     StatsActivityGetResponseMessageSchema,
+    ContextReportGetResponseMessageSchema,
+    ContextEdgeConvertResponseMessageSchema,
+    StatsActivityResetResponseMessageSchema,
+    UsageLogGetResponseMessageSchema,
     ActivityStatsChangedSchema,
     AgentContextGetUsageResponseMessageSchema,
     ListCommandsResponseSchema,