@otto-code/protocol 0.6.3 → 0.6.5

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
@@ -293,16 +315,57 @@ export const ModelTierOverrideSchema = z
     tier: ModelTierSchema,
 })
     .passthrough();
+// A remembered provider endpoint: a base URL together with the credential it
+// was saved with, so pointing a provider back at a previous endpoint is one
+// pick instead of re-typing the key. Entries are scoped by the connection
+// env-var pair they belong to (OPENAI_BASE_URL/OPENAI_API_KEY vs
+// ANTHROPIC_BASE_URL/ANTHROPIC_AUTH_TOKEN), which is exactly what the provider
+// settings sheet keys its dropdown off — so every openai-compatible provider
+// entry on the host shares one pool, and Claude-compatible entries share
+// another. Deliberately `z.string()` rather than an enum: a future env-var
+// family must not make old entries unparseable.
+export const SavedProviderEndpointSchema = z
+    .object({
+    /** Stable identity, `${baseUrlKey}::${baseUrl}` — dedupes on re-save. */
+    id: z.string().min(1),
+    baseUrlKey: z.string().min(1),
+    apiKeyKey: z.string().min(1),
+    baseUrl: z.string().min(1),
+    apiKey: z.string().default(""),
+    /** User-facing name; the UI falls back to the URL when absent. */
+    label: z.string().optional(),
+    /** Epoch ms of the last save, used to order the dropdown newest-first. */
+    savedAt: z.number().optional(),
+})
+    .passthrough();
 export const MutableDaemonConfigSchema = z
     .object({
     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(),
+    // Defaults off, matching the daemon's own resolution — browser tools are an
+    // explicit opt-in, so an omitted section must never read as on.
     browserTools: MutableBrowserToolsConfigSchema.default({ enabled: false }),
+    // Daemon-wide agent behavior toggles (Claude-tier capabilities). Defaults to
+    // 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(""),
@@ -323,12 +386,19 @@ export const MutableDaemonConfigSchema = z
     // Gated by the modelTierOverrides feature; defaults empty so a new client
     // parsing an old daemon's config still sees a well-formed array.
     modelTierOverrides: z.array(ModelTierOverrideSchema).default([]),
+    // Per-host remembered provider endpoints (base URL + credential), pooled by
+    // env-var family. Gated by the savedProviderEndpoints feature; defaults
+    // empty so a new client parsing an old daemon's config still sees a
+    // well-formed array.
+    savedProviderEndpoints: z.array(SavedProviderEndpointSchema).default([]),
 })
     .passthrough();
 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.
@@ -356,6 +426,9 @@ export const MutableDaemonConfigPatchSchema = z
     // Gated by server_info features.modelTierOverrides. Replaces the full array
     // (read-modify-write), so removing an entry clears that model's tag.
     modelTierOverrides: z.array(ModelTierOverrideSchema).optional(),
+    // Gated by server_info features.savedProviderEndpoints. Replaces the full
+    // array (read-modify-write), so forgetting an endpoint drops it from disk.
+    savedProviderEndpoints: z.array(SavedProviderEndpointSchema).optional(),
 })
     .partial()
     .passthrough();
@@ -480,6 +553,8 @@ const ContextCompositionSchema = z.object({
 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(),
@@ -1455,6 +1530,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"),
@@ -1482,6 +1577,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(),
@@ -1694,6 +1883,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).
@@ -2723,6 +3070,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     ProviderDiagnosticRequestMessageSchema,
     ProviderUsageListRequestMessageSchema,
     StatsActivityGetRequestMessageSchema,
+    ContextReportGetRequestMessageSchema,
+    ContextEdgeConvertRequestMessageSchema,
+    StatsActivityResetRequestMessageSchema,
+    UsageLogGetRequestMessageSchema,
     AgentContextGetUsageRequestMessageSchema,
     ResumeAgentRequestMessageSchema,
     ImportAgentRequestMessageSchema,
@@ -3036,8 +3387,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.
@@ -3070,6 +3432,8 @@ export const ServerInfoStatusPayloadSchema = z
         agentTeams: z.boolean().optional(),
         // COMPAT(modelTierOverrides): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
         modelTierOverrides: z.boolean().optional(),
+        // COMPAT(savedProviderEndpoints): added in v0.6.5, drop the gate when daemon floor >= v0.6.5.
+        savedProviderEndpoints: z.boolean().optional(),
         // COMPAT(agentOrchestration): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
         agentOrchestration: z.boolean().optional(),
         // COMPAT(activityStats): added in v0.5.3, drop the gate when daemon floor >= v0.5.3.
@@ -3093,6 +3457,44 @@ export const ServerInfoStatusPayloadSchema = z
         // 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(),
 })
@@ -5278,6 +5680,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     TasksSuggestedStartResponseMessageSchema,
     TasksSuggestedDismissResponseMessageSchema,
     SuggestedTasksChangedSchema,
+    ContextReportChangedSchema,
     AgentPersonalitySetResponseMessageSchema,
     AgentRewindResponseMessageSchema,
     UpdateAgentResponseMessageSchema,
@@ -5363,6 +5766,10 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     ProviderDiagnosticResponseMessageSchema,
     ProviderUsageListResponseMessageSchema,
     StatsActivityGetResponseMessageSchema,
+    ContextReportGetResponseMessageSchema,
+    ContextEdgeConvertResponseMessageSchema,
+    StatsActivityResetResponseMessageSchema,
+    UsageLogGetResponseMessageSchema,
     ActivityStatsChangedSchema,
     AgentContextGetUsageResponseMessageSchema,
     ListCommandsResponseSchema,

package/dist/provider-config.d.ts

@@ -86,6 +86,16 @@ export declare const MCP_TOOL_PERMISSION_MODES: readonly ["always-ask", "trust-r
  * conversation is compacted automatically.
  */
 export declare const COMPACTION_THRESHOLD_PERCENTS: readonly [50, 60, 70, 80, 90];
+/**
+ * Max model→tool→model rounds per turn for providers whose tool loop the
+ * daemon owns (openai-compat). The turn stops with an error after this many
+ * rounds without a final answer — a runaway-loop safety valve, most often hit
+ * by smaller local models that keep calling tools instead of converging.
+ * Bounds keep the setting a sane guard rail rather than an off switch.
+ */
+export declare const MAX_TOOL_ROUNDS_DEFAULT = 50;
+export declare const MAX_TOOL_ROUNDS_MIN = 1;
+export declare const MAX_TOOL_ROUNDS_MAX = 1000;
 /**
  * Compaction tuning for providers whose conversation the daemon owns
  * (openai-compat). These set the provider-level defaults; the per-agent
@@ -167,6 +177,7 @@ export declare const ProviderOverrideSchema: z.ZodObject<{
         keepRecentTokens: z.ZodOptional<z.ZodNumber>;
         hideSelector: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    maxToolRounds: z.ZodOptional<z.ZodNumber>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     order: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -239,6 +250,7 @@ export declare const ProviderOverridesSchema: z.ZodRecord<z.ZodString, z.ZodObje
         keepRecentTokens: z.ZodOptional<z.ZodNumber>;
         hideSelector: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
+    maxToolRounds: z.ZodOptional<z.ZodNumber>;
     enabled: z.ZodOptional<z.ZodBoolean>;
     order: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;

package/dist/provider-config.js

@@ -117,6 +117,16 @@ export const MCP_TOOL_PERMISSION_MODES = ["always-ask", "trust-read-only"];
  * conversation is compacted automatically.
  */
 export const COMPACTION_THRESHOLD_PERCENTS = [50, 60, 70, 80, 90];
+/**
+ * Max model→tool→model rounds per turn for providers whose tool loop the
+ * daemon owns (openai-compat). The turn stops with an error after this many
+ * rounds without a final answer — a runaway-loop safety valve, most often hit
+ * by smaller local models that keep calling tools instead of converging.
+ * Bounds keep the setting a sane guard rail rather than an off switch.
+ */
+export const MAX_TOOL_ROUNDS_DEFAULT = 50;
+export const MAX_TOOL_ROUNDS_MIN = 1;
+export const MAX_TOOL_ROUNDS_MAX = 1000;
 /**
  * Compaction tuning for providers whose conversation the daemon owns
  * (openai-compat). These set the provider-level defaults; the per-agent
@@ -165,6 +175,11 @@ export const ProviderOverrideSchema = z.object({
      * (openai-compat). Per-agent feature values win over these.
      */
     compaction: ProviderCompactionConfigSchema.optional(),
+    /**
+     * Max model→tool→model rounds per turn for daemon-hosted providers
+     * (openai-compat). Omitted = the built-in default (MAX_TOOL_ROUNDS_DEFAULT).
+     */
+    maxToolRounds: z.number().int().min(MAX_TOOL_ROUNDS_MIN).max(MAX_TOOL_ROUNDS_MAX).optional(),
     enabled: z.boolean().optional(),
     order: z.number().optional(),
 });

package/dist/provider-manifest.js

@@ -124,6 +124,19 @@ const MOCK_LOAD_TEST_MODES = [
         icon: "ShieldOff",
         colorTier: "dangerous",
     },
+    {
+        id: "dontAsk",
+        label: "Don't Ask",
+        description: "Runs without prompting — actions not pre-approved are denied",
+        icon: "ShieldCheck",
+        colorTier: "moderate",
+        // Dev-only mirror of Claude's guarded unattended mode so deterministic E2E
+        // specs can exercise the system-assigned surfaces: the unattended coercion
+        // target for mock schedule runs, and the locked mode badge on a live agent
+        // stuck in a non-user-selectable mode.
+        isUnattended: true,
+        userSelectable: false,
+    },
 ];
 const MOCK_SLOW_MODES = [
     {