@otto-code/protocol 0.6.2 → 0.6.4

package/dist/observed-subagent-title.d.ts

@@ -0,0 +1,26 @@
+/** Hard cap so no provider summary can produce a wall-of-text label. */
+export declare const OBSERVED_SUBAGENT_TITLE_MAX = 60;
+export declare function normalizeObservedTitleSource(value: string | undefined | null): string | null;
+export declare function normalizeObservedSubagentType(value: string | undefined | null): string | null;
+/**
+ * Derive the frozen row name for an observed subagent. Prefer the stable
+ * `subAgentType` (e.g. "code-explorer") over the description — a
+ * `task_progress` description is the ever-changing AI summary, which must
+ * never become the label. Generic catch-all types ("general-purpose") are
+ * skipped in favor of the description. Callers freeze the result at the first
+ * named update.
+ */
+export declare function deriveObservedSubagentTitle(update: {
+    subAgentType?: string;
+    description?: string;
+}): string;
+/**
+ * True when this update carries a real name source we can freeze the title on.
+ * A generic catch-all type alone doesn't count — freezing "general-purpose"
+ * would lock out the description a later update may carry.
+ */
+export declare function observedUpdateHasTitleSource(update: {
+    subAgentType?: string;
+    description?: string;
+}): boolean;
+//# sourceMappingURL=observed-subagent-title.d.ts.map

package/dist/observed-subagent-title.js

@@ -0,0 +1,63 @@
+// Shared naming rule for provider-managed (observed) subagents. This is the
+// single source of truth for how an observed subagent is titled — the daemon
+// uses it to freeze the track-row label (agent-projections.ts), and the app's
+// visualizer uses it so page-side child labels (subagent_dispatch/return
+// particles ride an edge keyed by child NAME) resolve to exactly the same
+// string as the child node the daemon-titled agent row spawned. If the two
+// ever diverge, the dispatch/return visuals silently stop rendering.
+// See docs/agent-lifecycle.md (Item 4) and docs/visualizer.md.
+/** Hard cap so no provider summary can produce a wall-of-text label. */
+export const OBSERVED_SUBAGENT_TITLE_MAX = 60;
+/**
+ * Catch-all subagent types that make lousy row labels — Claude's default Task
+ * runs as "general-purpose". These never become the title; the task
+ * description names the row instead (user-locked).
+ */
+const GENERIC_OBSERVED_SUBAGENT_TYPES = new Set([
+    "general-purpose",
+    "general",
+    "task",
+    "agent",
+    "subagent",
+]);
+export function normalizeObservedTitleSource(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const collapsed = value.replace(/\s+/g, " ").trim();
+    return collapsed.length > 0 ? collapsed : null;
+}
+export function normalizeObservedSubagentType(value) {
+    const normalized = normalizeObservedTitleSource(value);
+    if (normalized === null || GENERIC_OBSERVED_SUBAGENT_TYPES.has(normalized.toLowerCase())) {
+        return null;
+    }
+    return normalized;
+}
+/**
+ * Derive the frozen row name for an observed subagent. Prefer the stable
+ * `subAgentType` (e.g. "code-explorer") over the description — a
+ * `task_progress` description is the ever-changing AI summary, which must
+ * never become the label. Generic catch-all types ("general-purpose") are
+ * skipped in favor of the description. Callers freeze the result at the first
+ * named update.
+ */
+export function deriveObservedSubagentTitle(update) {
+    const base = normalizeObservedSubagentType(update.subAgentType) ??
+        normalizeObservedTitleSource(update.description) ??
+        "Subagent";
+    if (base.length <= OBSERVED_SUBAGENT_TITLE_MAX) {
+        return base;
+    }
+    return `${base.slice(0, OBSERVED_SUBAGENT_TITLE_MAX - 1).trimEnd()}…`;
+}
+/**
+ * True when this update carries a real name source we can freeze the title on.
+ * A generic catch-all type alone doesn't count — freezing "general-purpose"
+ * would lock out the description a later update may carry.
+ */
+export function observedUpdateHasTitleSource(update) {
+    return (normalizeObservedSubagentType(update.subAgentType) !== null ||
+        normalizeObservedTitleSource(update.description) !== null);
+}
+//# sourceMappingURL=observed-subagent-title.js.map

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 = [
     {

package/dist/tool-call-display.d.ts

@@ -7,5 +7,14 @@ export interface ToolCallDisplayModel {
     summary?: string;
     errorText?: string;
 }
+/**
+ * Friendly display name for a bare tool identifier, used at every surface that
+ * shows a tool/action name without a full timeline item to run through
+ * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
+ * activity rows). Strips the MCP/Otto namespace, consults the known-tool
+ * registry, then title-cases as a fallback — so "mcp__otto__spawn_task",
+ * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ */
+export declare function getToolDisplayName(name: string): string;
 export declare function buildToolCallDisplayModel(input: ToolCallDisplayInput): ToolCallDisplayModel;
 //# sourceMappingURL=tool-call-display.d.ts.map

package/dist/tool-call-display.js

@@ -1,4 +1,4 @@
-import { getOttoToolLeafName, isOttoToolName } from "./tool-name-normalization.js";
+import { getMcpToolLeafName, getOttoToolLeafName } from "./tool-name-normalization.js";
 import { stripCwdPrefix } from "./path-utils.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6,26 +6,71 @@ function isRecord(value) {
 function readString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+// Curated display names — the registry of tools we explicitly "know about".
+// Keyed by the lowercased leaf name (transport namespace already stripped).
+//
+// Only tools whose bare id does NOT title-case cleanly on its own need an entry
+// here: lowercase compound names ("websearch") a splitter can't segment, or
+// ones we want to word deliberately. Well-formed snake_case ("spawn_task") and
+// camelCase ("WebSearch") names are handled by the algorithmic humanizer below
+// and do NOT need listing.
+//
+// Anything not here falls through to the humanizer and still renders readably —
+// so an unmapped tool shows up looking slightly generic (e.g. a stray provider
+// tool), which is the cue to add it here. Extend this map to teach Otto a tool.
+const KNOWN_TOOL_DISPLAY_NAMES = {
+    websearch: "Web Search",
+    web_search: "Web Search",
+    webfetch: "Web Fetch",
+    web_fetch: "Web Fetch",
+    todowrite: "Update Todos",
+    todoread: "Read Todos",
+    multiedit: "Multi Edit",
+    notebookedit: "Edit Notebook",
+    notebookread: "Read Notebook",
+    bashoutput: "Bash Output",
+    killshell: "Kill Shell",
+    exitplanmode: "Exit Plan Mode",
+    applypatch: "Apply Patch",
+    ls: "List Files",
+};
+// Split camelCase / PascalCase and separator-delimited identifiers into words,
+// then Title-Case them: "WebSearch" -> "Web Search", "spawn_task" -> "Spawn
+// Task", "HTTPServer" -> "HTTP Server".
+function titleCaseToolId(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+        .join(" ");
+}
 function humanizeToolName(name) {
     const trimmed = name.trim();
     if (!trimmed) {
         return name;
     }
-    if (isOttoToolName(trimmed)) {
-        const leaf = getOttoToolLeafName(trimmed);
-        if (leaf) {
-            return humanizeToolName(leaf);
-        }
-    }
-    if (/[:./]/.test(trimmed) || trimmed.includes("__")) {
-        return trimmed;
+    // Strip the transport namespace first ("mcp__otto__spawn_task" ->
+    // "spawn_task", "otto.list_agents" -> "list_agents") so both the known-tool
+    // lookup and the fallback operate on the bare tool id.
+    const leaf = getMcpToolLeafName(trimmed) ?? getOttoToolLeafName(trimmed);
+    if (leaf) {
+        return humanizeToolName(leaf);
     }
-    return trimmed
-        .replace(/[._-]+/g, " ")
-        .split(" ")
-        .filter((segment) => segment.length > 0)
-        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
-        .join(" ");
+    return KNOWN_TOOL_DISPLAY_NAMES[trimmed.toLowerCase()] ?? titleCaseToolId(trimmed);
+}
+/**
+ * Friendly display name for a bare tool identifier, used at every surface that
+ * shows a tool/action name without a full timeline item to run through
+ * {@link buildToolCallDisplayModel} (the visualizer's action labels, sub-agent
+ * activity rows). Strips the MCP/Otto namespace, consults the known-tool
+ * registry, then title-cases as a fallback — so "mcp__otto__spawn_task",
+ * "otto.spawn_task", and a bare "spawn_task" all render as "Spawn Task".
+ */
+export function getToolDisplayName(name) {
+    return humanizeToolName(name);
 }
 function formatErrorText(error) {
     if (error === null || error === undefined) {

package/dist/tool-name-normalization.d.ts

@@ -5,5 +5,21 @@ export declare function isSpeakToolName(name: string): boolean;
 export declare function isLikelyNamespacedToolName(name: string): boolean;
 export declare function isOttoToolName(name: string): boolean;
 export declare function getOttoToolLeafName(name: string): string | null;
+/**
+ * Strip a leading MCP namespace for DISPLAY, returning the bare tool id.
+ *
+ * Tools hosted over MCP arrive namespaced as `mcp__<server>__<tool>` (Claude
+ * Code format). The `mcp__<server>__` part is transport plumbing that means
+ * nothing to a reader — "Create Issue", not "mcp__linear__create_issue". This
+ * generalizes {@link getOttoToolLeafName} to ANY server so every MCP tool reads
+ * cleanly, not just Otto's own.
+ *
+ * Returns `null` when the name carries no `mcp__…__` namespace, so callers keep
+ * plain tool names (`Read`, `bash`) and dotted/other forms untouched. Case is
+ * preserved — MCP tool ids are already snake_case and callers humanize after.
+ * `speak` is never treated as namespaced (it renders as a chat bubble, not an
+ * action row).
+ */
+export declare function getMcpToolLeafName(name: string): string | null;
 export declare function isLikelyExternalToolName(name: string): boolean;
 //# sourceMappingURL=tool-name-normalization.d.ts.map

package/dist/tool-name-normalization.js

@@ -69,6 +69,32 @@ export function getOttoToolLeafName(name) {
     }
     return null;
 }
+/**
+ * Strip a leading MCP namespace for DISPLAY, returning the bare tool id.
+ *
+ * Tools hosted over MCP arrive namespaced as `mcp__<server>__<tool>` (Claude
+ * Code format). The `mcp__<server>__` part is transport plumbing that means
+ * nothing to a reader — "Create Issue", not "mcp__linear__create_issue". This
+ * generalizes {@link getOttoToolLeafName} to ANY server so every MCP tool reads
+ * cleanly, not just Otto's own.
+ *
+ * Returns `null` when the name carries no `mcp__…__` namespace, so callers keep
+ * plain tool names (`Read`, `bash`) and dotted/other forms untouched. Case is
+ * preserved — MCP tool ids are already snake_case and callers humanize after.
+ * `speak` is never treated as namespaced (it renders as a chat bubble, not an
+ * action row).
+ */
+export function getMcpToolLeafName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || isSpeakToolName(trimmed) || !trimmed.includes("__")) {
+        return null;
+    }
+    const segments = trimmed.split("__").filter((segment) => segment.length > 0);
+    if (segments.length >= 3 && segments[0].toLowerCase() === "mcp") {
+        return segments.slice(2).join("__");
+    }
+    return null;
+}
 export function isLikelyExternalToolName(name) {
     const normalized = normalizeToolName(name);
     if (!normalized) {