@otto-code/server 0.7.2 → 0.7.3

package/dist/server/server/agent/providers/claude/agent.js

@@ -1517,12 +1517,19 @@ function readLegacyResultUsageTokens(usage) {
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
-// Claude's Bash tool used with run_in_background: true reports its lifecycle
+// Claude's shell tool used with run_in_background: true reports its lifecycle
 // through the same task_started/task_progress/task_notification stream as
 // subagents. See projects/observed-subagents/observed-subagents.md's note
 // that Otto today ignores shell/monitor/workflow task events.
+//
+// The tool is named "Bash" on POSIX hosts and "PowerShell" on Windows ones, so
+// both names have to be recognized. Matching only "Bash" left every Windows
+// background shell task failing this test everywhere it is used: routing
+// survived on task_type ("local_bash") and the remembered task id, but the
+// interrupt teardown in flushPendingToolCalls has no such fallback, so an
+// in-flight background PowerShell row was never closed and stuck "running".
 function isClaudeBackgroundShellToolName(name) {
-    return name === "Bash";
+    return name === "Bash" || name === "PowerShell";
 }
 // Claude's Workflow tool (deterministic multi-agent orchestration —
 // agent()/parallel()/pipeline(), progress phases, task-completion notifications)
@@ -3602,7 +3609,7 @@ class ClaudeAgentSession {
         }
     }
     translateMessageToEvents(message, options) {
-        const parentToolUseId = readClaudeParentToolUseId(message);
+        const parentToolUseId = this.readObservedSubagentSidechainParent(message);
         if (parentToolUseId) {
             const sidechainEvents = this.sidechainTracker.handleMessage(message, parentToolUseId);
             this.appendObservedSubagentSidechainEvents(message, parentToolUseId, sidechainEvents);
@@ -3676,6 +3683,44 @@ class ClaudeAgentSession {
         }
         return events;
     }
+    /**
+     * True when a message's `parent_tool_use_id` names an observable AI run
+     * (a Task/Agent sub-agent or a Workflow) rather than an ordinary tool.
+     *
+     * A non-null parent_tool_use_id is NOT by itself a sub-agent signal. Roughly
+     * 30s into ANY slow tool the CLI emits a heartbeat `tool_progress` whose
+     * tool_use_id is a synthetic "<id>-heartbeat-N" and whose parent_tool_use_id
+     * is the real tool's id:
+     *
+     *   {"type":"tool_progress","tool_use_id":"toolu_01EB…-heartbeat-0",
+     *    "parent_tool_use_id":"toolu_01EB…"}
+     *
+     * Treating that as a sidechain announced an observed sub-agent keyed by the
+     * shell tool, titled with its `description`. The row then had no timeline (a
+     * tool_progress is neither an assistant nor a user message) and no way to
+     * settle (every settle path is gated on a Task/Agent/Workflow tool name), so
+     * every Bash/PowerShell call that ran longer than the heartbeat left a
+     * permanently "running" row with an empty pane.
+     *
+     * An unknown parent stays accepted: a backgrounded Agent whose tool_result
+     * ack already evicted its cache entry still has to reach its observed row.
+     */
+    readObservedSubagentSidechainParent(message) {
+        const parentToolUseId = readClaudeParentToolUseId(message);
+        if (!parentToolUseId) {
+            return null;
+        }
+        if (this.announcedObservedSubagents.has(parentToolUseId) ||
+            this.workflowObservedKeys.has(parentToolUseId)) {
+            return parentToolUseId;
+        }
+        const cachedTool = this.toolUseCache.get(parentToolUseId);
+        if (!cachedTool) {
+            return parentToolUseId;
+        }
+        const isObservable = isClaudeSubagentToolName(cachedTool.name) || isClaudeWorkflowToolName(cachedTool.name);
+        return isObservable ? parentToolUseId : null;
+    }
     /**
      * Route a sidechain (subagent) message into the observed subagent's own
      * lifecycle + timeline events, alongside the parent Task row's summary log.

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPersonalityUpdate, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, FetchCatalogOptions, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ProviderCatalog } from "../agent-sdk-types.js";
+import type { AgentBareCompletionOptions, AgentBareCompletionResult, AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPersonalityUpdate, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, FetchCatalogOptions, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ProviderCatalog } from "../agent-sdk-types.js";
 export declare const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export declare const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
 export declare class MockLoadTestAgentClient implements AgentClient {
@@ -12,6 +12,15 @@ export declare class MockLoadTestAgentClient implements AgentClient {
     fetchCatalog(_options: FetchCatalogOptions): Promise<ProviderCatalog>;
     listImportableSessions(): Promise<ImportableProviderSession[]>;
     importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
+    /**
+     * Tool-less metadata generation (chat titles, branch names). The mock already
+     * answers these contracts deterministically through a normal turn, but the
+     * structured-generation ladder calls generateBareCompletion first and skips
+     * any provider that lacks it — so pinning metadataGeneration at the mock
+     * provider silently fell through to a real CLI, which is exactly what the
+     * pin exists to avoid. Same parsers as the turn path, answered directly.
+     */
+    generateBareCompletion(options: AgentBareCompletionOptions): Promise<AgentBareCompletionResult>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { importSessionFromPersistence } from "../provider-session-import.js";
+import { generateSyntheticConversation } from "../synthetic-conversation.js";
 import { getAgentProviderDefinition } from "@otto-code/protocol/provider-manifest";
 export const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
@@ -60,6 +61,16 @@ const MODELS = [
             intervalMs: 5,
         },
     },
+    {
+        provider: MOCK_LOAD_TEST_PROVIDER_ID,
+        id: "synthetic-history",
+        label: "Synthetic history (count-bounded)",
+        description: "Emits a deterministic corpus of synthetic conversation items in one turn then finishes. Used to seed performance-test corpora — all content flows through generateSyntheticConversation so blocks are combinatorially unique.",
+        metadata: {
+            itemCount: 300,
+            intervalMs: 0,
+        },
+    },
 ];
 function shouldEmitPlanApprovalPrompt(prompt) {
     return /emit\s+(?:a\s+)?synthetic\s+plan\s+approval/i.test(promptToText(prompt));
@@ -127,6 +138,7 @@ function resolveModelProfile(modelId) {
         modelId: model.id,
         durationMs: typeof metadata.durationMs === "number" ? metadata.durationMs : MOCK_LOAD_TEST_DURATION_MS,
         intervalMs: typeof metadata.intervalMs === "number" ? metadata.intervalMs : MOCK_LOAD_TEST_INTERVAL_MS,
+        itemCount: typeof metadata.itemCount === "number" && metadata.itemCount > 0 ? metadata.itemCount : null,
     };
 }
 function promptToText(prompt) {
@@ -172,6 +184,45 @@ function parseAgentStreamStressPrompt(prompt) {
         coalesced: Boolean(match[2]),
     };
 }
+// Allow the caller to override itemCount per-turn via a prompt directive like
+// "synthetic-history: 30". This lets the seeder drive many small turns rather
+// than one giant one — important because findMountedWindowStart walks back from
+// the tail until it hits a user message, and a single huge turn with no user
+// messages in its timeline mounts the entire history.
+function parseSyntheticHistoryCountPrompt(prompt) {
+    const text = promptToText(prompt);
+    const match = /synthetic-history\s*:\s*(\d+)/i.exec(text);
+    if (!match) {
+        return null;
+    }
+    const count = Number(match[1]);
+    if (!Number.isFinite(count) || count <= 0) {
+        return null;
+    }
+    return Math.min(count, 5000);
+}
+// Pin the generator seed for this turn via a directive like "synthetic-seed: 41".
+//
+// Without this the seed is hashString(turnId), and turnId is a fresh randomUUID
+// per turn — so the generator is deterministic but a *corpus* is not. Two seeding
+// runs would produce statistically similar, byte-different conversations, and any
+// before/after measurement taken across them would be comparing two different
+// corpora while reporting the difference as a code change. A seeder that pins the
+// seed gets the same corpus back every time.
+function parseSyntheticSeedPrompt(prompt) {
+    const text = promptToText(prompt);
+    const match = /synthetic-seed\s*:\s*(\d+)/i.exec(text);
+    if (!match) {
+        return null;
+    }
+    const seed = Number(match[1]);
+    if (!Number.isFinite(seed)) {
+        return null;
+    }
+    // The generator forces the seed unsigned anyway; keep it in range here so the
+    // directive and the PRNG agree on what "seed 4294967297" means.
+    return seed >>> 0;
+}
 function parseStructuredBranchNamePrompt(prompt) {
     const text = promptToText(prompt);
     const hasBranchNamePrompt = text.includes("Generate a title and a git branch name for a coding agent") &&
@@ -420,6 +471,60 @@ function buildCycleQueue(turnId, cycle) {
     queue.push({ kind: "usage" });
     return queue;
 }
+// Build a single-shot queue from the deterministic synthetic conversation
+// generator. Unlike buildCycleQueue this is never refilled — the turn finishes
+// when the queue drains, so it exercises rendering paths with combinatorially
+// unique markdown blocks (avoiding the app's height cache).
+function buildSyntheticHistoryQueue(_turnId, seed, itemCount) {
+    const conversation = generateSyntheticConversation({ seed, itemCount });
+    const queue = [];
+    for (const item of conversation) {
+        switch (item.type) {
+            case "assistant_message":
+                // Tokenize so the app sees incremental streaming.
+                for (const tok of tokenize(item.text)) {
+                    queue.push({ kind: "assistant_token", text: tok });
+                }
+                break;
+            case "reasoning":
+                for (const tok of tokenize(item.text)) {
+                    queue.push({ kind: "reasoning_token", text: tok });
+                }
+                break;
+            case "tool_call":
+                // Emit running then completed to exercise both timeline states.
+                queue.push({
+                    kind: "tool_running",
+                    callId: item.callId,
+                    name: item.name,
+                    detail: item.detail,
+                });
+                queue.push({
+                    kind: "tool_completed",
+                    callId: item.callId,
+                    name: item.name,
+                    detail: item.detail,
+                });
+                break;
+            case "user_message":
+                // Skip — the user prompt is the turn itself, not a timeline event.
+                break;
+            default:
+                // We don't emit todo/error/compaction from synthetic history (the corpus generator doesn't produce them).
+                break;
+        }
+    }
+    queue.push({ kind: "usage" });
+    return queue;
+}
+// Simple string hash for deriving a deterministic seed from a turn UUID.
+function hashString(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+        h = ((h << 5) - h + s.charCodeAt(i)) | 0;
+    }
+    return h >>> 0; // force unsigned
+}
 function createToolCall(input) {
     return {
         type: "tool_call",
@@ -473,6 +578,21 @@ export class MockLoadTestAgentClient {
             resumeSession: this.resumeSession.bind(this),
         });
     }
+    /**
+     * Tool-less metadata generation (chat titles, branch names). The mock already
+     * answers these contracts deterministically through a normal turn, but the
+     * structured-generation ladder calls generateBareCompletion first and skips
+     * any provider that lacks it — so pinning metadataGeneration at the mock
+     * provider silently fell through to a real CLI, which is exactly what the
+     * pin exists to avoid. Same parsers as the turn path, answered directly.
+     */
+    async generateBareCompletion(options) {
+        const structured = parseStructuredBranchNamePrompt(options.prompt) ?? parseStructuredTitlePrompt(options.prompt);
+        if (!structured) {
+            throw new Error("Mock load-test provider only generates the structured title/branch metadata contracts.");
+        }
+        return { text: JSON.stringify(structured) };
+    }
     async isAvailable() {
         return true;
     }
@@ -519,6 +639,21 @@ export class MockLoadTestAgentSession {
         const completed = new Promise((promiseResolve) => {
             resolve = promiseResolve;
         });
+        // For a count-bounded turn, pre-build the whole queue from a seed derived from
+        // turnId, so the same turn always replays the same conversation.
+        //
+        // The prompt directive wins over the model's own metadata, which means it can also
+        // make a normally time-bounded model count-bounded for one turn. That is deliberate
+        // and opt-in: a seeder asking for `synthetic-history: 30` wants exactly that, and no
+        // model behaves differently unless a caller writes the directive.
+        let initialQueue = [];
+        const resolvedItemCount = parseSyntheticHistoryCountPrompt(prompt) ?? profile.itemCount;
+        if (resolvedItemCount != null) {
+            // turnId is the default seed so an unpinned turn still varies; a caller
+            // building a corpus it wants to rebuild identically pins it instead.
+            const seed = parseSyntheticSeedPrompt(prompt) ?? hashString(turnId);
+            initialQueue = buildSyntheticHistoryQueue(turnId, seed, resolvedItemCount);
+        }
         const turn = {
             turnId,
             assistantMessageId,
@@ -527,10 +662,11 @@ export class MockLoadTestAgentSession {
             cycle: 0,
             durationMs: profile.durationMs,
             intervalMs: profile.intervalMs,
+            itemCount: resolvedItemCount,
             timer: null,
             resolve,
             completed,
-            queue: [],
+            queue: initialQueue,
             emittedTokens: 0,
             turnStarted: false,
         };
@@ -1129,12 +1265,22 @@ export class MockLoadTestAgentSession {
                 turnId: turn.turnId,
             });
         }
-        const elapsedMs = Date.now() - turn.startedAt;
-        if (elapsedMs >= turn.durationMs) {
-            this.finishTurn(turn);
-            return;
+        // Time-bounded turns: stop when the duration expires. Count-bounded turns
+        // (synthetic-history) skip this check entirely — they finish on queue drain.
+        if (turn.itemCount == null) {
+            const elapsedMs = Date.now() - turn.startedAt;
+            if (elapsedMs >= turn.durationMs) {
+                this.finishTurn(turn);
+                return;
+            }
         }
+        // Empty queue: refill for time-bounded turns, finish for count-bounded ones.
         if (turn.queue.length === 0) {
+            if (turn.itemCount != null) {
+                // Count-bounded turn has drained its pre-built queue — wrap up.
+                this.finishTurn(turn);
+                return;
+            }
             turn.cycle += 1;
             turn.queue = buildCycleQueue(turn.turnId, turn.cycle);
         }

package/dist/server/server/agent/synthetic-conversation.d.ts

@@ -0,0 +1,18 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+/**
+ * Options for deterministic synthetic conversation generation.
+ */
+export interface SyntheticConversationOptions {
+    /** Seed value controlling all pseudo-random choices. */
+    seed: number;
+    /** Exact number of timeline items to generate. */
+    itemCount: number;
+}
+/**
+ * Generate a deterministic array of fake-but-realistic agent timeline items.
+ *
+ * Same `seed` + `itemCount` always produces byte-identical output. No wall-clock
+ * or non-deterministic APIs are used.
+ */
+export declare function generateSyntheticConversation(options: SyntheticConversationOptions): AgentTimelineItem[];
+//# sourceMappingURL=synthetic-conversation.d.ts.map