@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/claude/partial-json.js

@@ -0,0 +1,306 @@
+function skipWhitespace(input, index) {
+    let currentIndex = index;
+    while (currentIndex < input.length && /\s/u.test(input[currentIndex] ?? "")) {
+        currentIndex += 1;
+    }
+    return currentIndex;
+}
+function parsePartialString(input, index) {
+    if (input[index] !== '"') {
+        return null;
+    }
+    let currentIndex = index + 1;
+    let value = "";
+    while (currentIndex < input.length) {
+        const character = input[currentIndex];
+        if (character === '"') {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (character === "\\") {
+            const escapeCharacter = input[currentIndex + 1];
+            if (escapeCharacter === undefined) {
+                return {
+                    value,
+                    nextIndex: input.length,
+                    complete: false,
+                };
+            }
+            switch (escapeCharacter) {
+                case '"':
+                case "\\":
+                case "/":
+                    value += escapeCharacter;
+                    currentIndex += 2;
+                    continue;
+                case "b":
+                    value += "\b";
+                    currentIndex += 2;
+                    continue;
+                case "f":
+                    value += "\f";
+                    currentIndex += 2;
+                    continue;
+                case "n":
+                    value += "\n";
+                    currentIndex += 2;
+                    continue;
+                case "r":
+                    value += "\r";
+                    currentIndex += 2;
+                    continue;
+                case "t":
+                    value += "\t";
+                    currentIndex += 2;
+                    continue;
+                case "u": {
+                    const hex = input.slice(currentIndex + 2, currentIndex + 6);
+                    if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/u.test(hex)) {
+                        return {
+                            value,
+                            nextIndex: input.length,
+                            complete: false,
+                        };
+                    }
+                    value += String.fromCodePoint(Number.parseInt(hex, 16));
+                    currentIndex += 6;
+                    continue;
+                }
+                default:
+                    return {
+                        value,
+                        nextIndex: input.length,
+                        complete: false,
+                    };
+            }
+        }
+        value += character;
+        currentIndex += 1;
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialLiteral(input, index) {
+    const remaining = input.slice(index);
+    if (remaining.startsWith("true")) {
+        return { value: true, nextIndex: index + 4, complete: true };
+    }
+    if (remaining.startsWith("false")) {
+        return { value: false, nextIndex: index + 5, complete: true };
+    }
+    if (remaining.startsWith("null")) {
+        return { value: null, nextIndex: index + 4, complete: true };
+    }
+    return null;
+}
+function parsePartialNumber(input, index) {
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(input.slice(index));
+    if (!match?.[0]) {
+        return null;
+    }
+    return {
+        value: Number(match[0]),
+        nextIndex: index + match[0].length,
+        complete: true,
+    };
+}
+function parsePartialArray(input, index) {
+    if (input[index] !== "[") {
+        return null;
+    }
+    const values = [];
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedValue) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        values.push(parsedValue.value);
+        currentIndex = skipWhitespace(input, parsedValue.nextIndex);
+        if (!parsedValue.complete) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value: values,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value: values,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialObject(input, index) {
+    if (input[index] !== "{") {
+        return null;
+    }
+    const value = {};
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedKey = parsePartialString(input, currentIndex);
+        if (!parsedKey?.complete) {
+            return {
+                value,
+                nextIndex: parsedKey?.nextIndex ?? currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, parsedKey.nextIndex);
+        if (input[currentIndex] !== ":") {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, currentIndex + 1);
+        const parsedMemberValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedMemberValue) {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        if (!parsedMemberValue.complete) {
+            return {
+                value,
+                nextIndex: skipWhitespace(input, parsedMemberValue.nextIndex),
+                complete: false,
+            };
+        }
+        value[parsedKey.value] = parsedMemberValue.value;
+        currentIndex = skipWhitespace(input, parsedMemberValue.nextIndex);
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialJsonValue(input, index) {
+    const currentIndex = skipWhitespace(input, index);
+    const character = input[currentIndex];
+    if (character === undefined) {
+        return null;
+    }
+    if (character === '"') {
+        return parsePartialString(input, currentIndex);
+    }
+    if (character === "{") {
+        return parsePartialObject(input, currentIndex);
+    }
+    if (character === "[") {
+        return parsePartialArray(input, currentIndex);
+    }
+    if (character === "t" || character === "f" || character === "n") {
+        return parsePartialLiteral(input, currentIndex);
+    }
+    if (character === "-" || /\d/u.test(character)) {
+        return parsePartialNumber(input, currentIndex);
+    }
+    return null;
+}
+export function parsePartialJsonObject(input) {
+    const currentIndex = skipWhitespace(input, 0);
+    const parsed = parsePartialObject(input, currentIndex);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        value: parsed.value,
+        complete: parsed.complete && skipWhitespace(input, parsed.nextIndex) === input.length,
+    };
+}
+//# sourceMappingURL=partial-json.js.map

package/dist/server/server/agent/providers/claude/project-dir.d.ts

@@ -0,0 +1,6 @@
+export interface ClaudeProjectDirOptions {
+    configDir?: string;
+}
+export declare function claudeProjectDir(cwd: string, options?: ClaudeProjectDirOptions): Promise<string>;
+export declare function claudeProjectDirSync(cwd: string, options?: ClaudeProjectDirOptions): string;
+//# sourceMappingURL=project-dir.d.ts.map

package/dist/server/server/agent/providers/claude/project-dir.js

@@ -0,0 +1,57 @@
+import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Verbatim port of the Claude Agent SDK's project-directory encoding so
+// paseo computes the same `~/.claude/projects/<dir>` path the SDK does.
+// The SDK ships only as a precompiled bundle; grep the JS source at
+// node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs for `function Ar`,
+// `function So`, `async function wn`, `function Dy`, `Ni=200`.
+const PROJECT_DIR_LENGTH_CAP = 200;
+export async function claudeProjectDir(cwd, options) {
+    const canonical = await canonicalize(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+export function claudeProjectDirSync(cwd, options) {
+    const canonical = canonicalizeSync(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+async function canonicalize(input) {
+    try {
+        return normalizeProjectPath(await realpath(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function canonicalizeSync(input) {
+    try {
+        return normalizeProjectPath(realpathSync.native(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function normalizeProjectPath(input) {
+    return process.platform === "darwin" ? input.normalize("NFC") : input;
+}
+function encode(input) {
+    const replaced = input.replace(/[^a-zA-Z0-9]/g, "-");
+    if (replaced.length <= PROJECT_DIR_LENGTH_CAP) {
+        return replaced;
+    }
+    return `${replaced.slice(0, PROJECT_DIR_LENGTH_CAP)}-${hashSuffix(input)}`;
+}
+function hashSuffix(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+function resolveConfigDir(options) {
+    return options?.configDir ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+//# sourceMappingURL=project-dir.js.map

package/dist/server/server/agent/providers/claude/pty-session-launcher.d.ts

@@ -0,0 +1,41 @@
+import type { Logger } from "pino";
+import type { Query, SDKUserMessage } from "@anthropic-ai/claude-agent-sdk";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { PtyTransport } from "./transport/pty.js";
+export interface CreatePtySessionOptions {
+    binary: string;
+    cwd: string;
+    /** Stable session id — pinned via --session-id (fresh) or --resume (continue). */
+    sessionId: string;
+    resume: boolean;
+    model?: string;
+    permissionMode: string;
+    appendSystemPrompt?: string;
+    /** The shared input channel fed by startTurn() — PtyQuery types these into the PTY. */
+    input: AsyncIterable<SDKUserMessage>;
+    runtimeSettings?: ProviderRuntimeSettings;
+    launchEnv?: Record<string, string>;
+    /** Normalized MCP servers (incl. the paseo MCP) — passed via --mcp-config for tool parity with the SDK path. */
+    mcpServers?: Record<string, unknown>;
+    logger: Logger;
+    dims?: {
+        cols: number;
+        rows: number;
+    };
+}
+export interface PtySession {
+    transport: PtyTransport;
+    query: Query;
+    transcriptPath: string;
+    systemPromptFilePath: string | null;
+}
+export declare function createPtySession(opts: CreatePtySessionOptions): Promise<PtySession>;
+/**
+ * PTY child env: scrub AMBIENT ANTHROPIC_* (→ keychain OAuth = Max) — but PRESERVE any a
+ * provider explicitly configures. `pool` extends `claude` and routes through the
+ * claude-proxy via its own `ANTHROPIC_API_KEY`; since `transport` cascades to derived
+ * providers, an unconditional scrub would strip pool's key and silently break its routing.
+ * So only scrub keys the provider did NOT set for itself.
+ */
+export declare function buildPtyEnv(opts: Pick<CreatePtySessionOptions, "runtimeSettings" | "launchEnv">): NodeJS.ProcessEnv;
+//# sourceMappingURL=pty-session-launcher.d.ts.map

package/dist/server/server/agent/providers/claude/pty-session-launcher.js

@@ -0,0 +1,131 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createProviderEnv } from "../../provider-launch-config.js";
+import { PtyTransport } from "./transport/pty.js";
+import { PtyQuery } from "./transport/pty-query.js";
+import { deriveTranscriptDir } from "./transport/transcript-tailer.js";
+import { buildSpawnArgs } from "./spawn-config-writer.js";
+/**
+ * Assembles + launches an interactive-PTY claude session and returns a `Query`-shaped
+ * handle the agent pump can consume unchanged. Keeps `ensureQuery()` thin.
+ *
+ * Two things the spike proved are essential and handled here:
+ *  1. SCRUBBED ENV — `ANTHROPIC_API_KEY`/`ANTHROPIC_BASE_URL` are removed so the child
+ *     falls back to keychain OAuth (Max plan) instead of the daemon's proxy API key.
+ *     (`CLAUDE_CODE_CHILD_SESSION`/`SESSION_ID` are scrubbed globally in
+ *     provider-launch-config so the child persists its own transcript.)
+ *  2. PRE-TRUST — the cwd is marked trusted in ~/.claude.json so the folder-trust TUI
+ *     gate never appears and swallows the first prompt.
+ *
+ * MVP scope: interactive spawn + transcript reconstruction. The paseo MCP + hook bridge
+ * (SpawnConfigWriter/HookHandlerServer) are a follow-up.
+ */
+const DEFAULT_DIMS = { cols: 200, rows: 50 };
+const PTY_ENV_SCRUB_KEYS = ["ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL"];
+export async function createPtySession(opts) {
+    const realCwd = safeRealpath(opts.cwd);
+    pretrustCwd(realCwd, opts.logger);
+    const { args, systemPromptFilePath } = buildSpawnArgs({
+        sessionId: opts.sessionId,
+        claudeBinary: opts.binary,
+        appendSystemPrompt: opts.appendSystemPrompt,
+        extraArgs: buildInteractiveFlags(opts),
+    });
+    const env = buildPtyEnv(opts);
+    const transcriptPath = path.join(deriveTranscriptDir(realCwd), `${opts.sessionId}.jsonl`);
+    const transport = new PtyTransport();
+    await transport.spawn({
+        binary: opts.binary,
+        args,
+        cwd: realCwd,
+        env,
+        dims: opts.dims ?? DEFAULT_DIMS,
+        ...(systemPromptFilePath ? { systemPromptFilePath } : {}),
+    });
+    const query = new PtyQuery({
+        transport,
+        input: opts.input,
+        transcriptPath,
+        sessionId: opts.sessionId,
+        logger: opts.logger,
+    });
+    opts.logger.debug({ pid: transport.context().pid, sessionId: opts.sessionId, transcriptPath }, "PTY claude session spawned");
+    return { transport, query, transcriptPath, systemPromptFilePath };
+}
+/** Interactive spawn flags — deliberately NO --output-format/--print (that is SDK/pool mode). */
+function buildInteractiveFlags(opts) {
+    const flags = [];
+    flags.push(opts.resume ? "--resume" : "--session-id", opts.sessionId);
+    if (opts.model)
+        flags.push("--model", opts.model);
+    if (opts.permissionMode)
+        flags.push("--permission-mode", opts.permissionMode);
+    flags.push("--dangerously-skip-permissions");
+    // Inject the same MCP servers the SDK path passes (incl. the paseo MCP) so the PTY agent
+    // keeps its mcp__paseo__* tools (create_agent, terminals, schedules…). claude accepts
+    // --mcp-config as an inline JSON string. Without this, orchestrated agents (the pool /
+    // cortexos fleet) would lose all paseo tools on switching to PTY.
+    if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
+        flags.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }));
+    }
+    // NOTE: --teammate-mode in-process (ccmanager gotcha) is intentionally omitted — it is
+    // not a valid flag on claude 2.1.197 and would abort the spawn. Revisit if agent-teams
+    // start spawning subagents as separate processes.
+    return flags;
+}
+/**
+ * PTY child env: scrub AMBIENT ANTHROPIC_* (→ keychain OAuth = Max) — but PRESERVE any a
+ * provider explicitly configures. `pool` extends `claude` and routes through the
+ * claude-proxy via its own `ANTHROPIC_API_KEY`; since `transport` cascades to derived
+ * providers, an unconditional scrub would strip pool's key and silently break its routing.
+ * So only scrub keys the provider did NOT set for itself.
+ */
+export function buildPtyEnv(opts) {
+    const configuredEnv = { ...opts.runtimeSettings?.env, ...opts.launchEnv };
+    const scrub = PTY_ENV_SCRUB_KEYS.filter((k) => configuredEnv[k] === undefined);
+    return createProviderEnv({
+        baseEnv: process.env,
+        runtimeSettings: opts.runtimeSettings,
+        overlays: [
+            opts.launchEnv,
+            { MCP_TIMEOUT: "600000", MCP_TOOL_TIMEOUT: "600000", TERM: "xterm-256color" },
+        ],
+        extraScrubKeys: scrub,
+    });
+}
+function safeRealpath(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+/**
+ * Mark the cwd trusted in ~/.claude.json so claude skips the interactive folder-trust
+ * gate. Idempotent + minimal: only writes when the trust flag is missing (already-used
+ * project dirs are trusted, so this rarely writes). Atomic rename to limit corruption.
+ */
+function pretrustCwd(cwd, logger) {
+    const configPath = path.join(os.homedir(), ".claude.json");
+    try {
+        if (!fs.existsSync(configPath))
+            return; // fresh install — claude will create it
+        const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        cfg.projects = cfg.projects ?? {};
+        const entry = cfg.projects[cwd] ?? {};
+        if (entry["hasTrustDialogAccepted"] === true)
+            return;
+        entry["hasTrustDialogAccepted"] = true;
+        cfg.projects[cwd] = entry;
+        const tmp = `${configPath}.paseo-pty-${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2));
+        fs.renameSync(tmp, configPath);
+        logger.debug({ cwd }, "pre-trusted cwd for PTY claude");
+    }
+    catch (err) {
+        logger.warn({ err, cwd }, "PTY pre-trust failed; folder-trust prompt may block the first turn");
+    }
+}
+//# sourceMappingURL=pty-session-launcher.js.map

package/dist/server/server/agent/providers/claude/resume-source.d.ts

@@ -0,0 +1,11 @@
+export interface ResumeSourceLocation {
+    jsonlPath: string;
+}
+/**
+ * Returns the absolute path to `<sid>.jsonl` if found under any project dir,
+ * else `null`. Does not open or mutate the file.
+ */
+export declare function findClaudeSessionJsonl(sid: string, options?: {
+    projectsRoot?: string;
+}): Promise<ResumeSourceLocation | null>;
+//# sourceMappingURL=resume-source.d.ts.map

package/dist/server/server/agent/providers/claude/resume-source.js

@@ -0,0 +1,37 @@
+import { promises as fsPromises } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function claudeProjectsRoot() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+    return path.join(configDir, "projects");
+}
+/**
+ * Returns the absolute path to `<sid>.jsonl` if found under any project dir,
+ * else `null`. Does not open or mutate the file.
+ */
+export async function findClaudeSessionJsonl(sid, options) {
+    if (!sid)
+        return null;
+    const root = options?.projectsRoot ?? claudeProjectsRoot();
+    let projectDirs;
+    try {
+        projectDirs = await fsPromises.readdir(root);
+    }
+    catch {
+        return null;
+    }
+    const target = `${sid}.jsonl`;
+    for (const dirName of projectDirs) {
+        const candidate = path.join(root, dirName, target);
+        try {
+            const stats = await fsPromises.stat(candidate);
+            if (stats.isFile())
+                return { jsonlPath: candidate };
+        }
+        catch {
+            // not in this project dir — keep looking
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=resume-source.js.map

package/dist/server/server/agent/providers/claude/rewind.d.ts

@@ -0,0 +1,30 @@
+import { type Query } from "@anthropic-ai/claude-agent-sdk";
+export interface ClaudeRewindSdk {
+    forkSession(sessionId: string, options: {
+        upToMessageId: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+}
+export declare const realClaudeRewindSdk: ClaudeRewindSdk;
+export declare function revertClaudeConversation(input: {
+    sdk: ClaudeRewindSdk;
+    sessionId: string | null;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+    setSessionId: (sessionId: string) => void;
+}): Promise<void>;
+export declare function revertClaudeFiles(input: {
+    query: Query;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+}): Promise<void>;
+export declare function revertClaudeConversationAndFiles(input: {
+    sdk: ClaudeRewindSdk;
+    query: Query;
+    sessionId: string | null;
+    messageId: string;
+    resolveMessageId?: (messageId: string) => string | Promise<string>;
+    setSessionId: (sessionId: string) => void;
+}): Promise<void>;
+//# sourceMappingURL=rewind.d.ts.map

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

@@ -0,0 +1,30 @@
+import { forkSession as claudeForkSession } from "@anthropic-ai/claude-agent-sdk";
+export const realClaudeRewindSdk = {
+    forkSession: claudeForkSession,
+};
+export async function revertClaudeConversation(input) {
+    if (!input.sessionId) {
+        throw new Error("Claude session is not ready for rewind");
+    }
+    const messageId = (await input.resolveMessageId?.(input.messageId)) ?? input.messageId;
+    const fork = await input.sdk.forkSession(input.sessionId, {
+        upToMessageId: messageId,
+    });
+    input.setSessionId(fork.sessionId);
+}
+export async function revertClaudeFiles(input) {
+    const messageId = (await input.resolveMessageId?.(input.messageId)) ?? input.messageId;
+    const result = await input.query.rewindFiles(messageId, { dryRun: false });
+    if (!result.canRewind) {
+        throw new Error(result.error ?? `No file checkpoint found for message ${messageId}`);
+    }
+}
+export async function revertClaudeConversationAndFiles(input) {
+    await revertClaudeFiles({
+        query: input.query,
+        messageId: input.messageId,
+        resolveMessageId: input.resolveMessageId,
+    });
+    await revertClaudeConversation(input);
+}
+//# sourceMappingURL=rewind.js.map

package/dist/server/server/agent/providers/claude/sidechain-tracker.d.ts

@@ -0,0 +1,22 @@
+import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
+import type { AgentMetadata, AgentStreamEvent } from "../../agent-sdk-types.js";
+export declare class ClaudeSidechainTracker {
+    private readonly activeSidechains;
+    private readonly getToolInput;
+    constructor(input: {
+        getToolInput: (toolUseId: string) => AgentMetadata | null | undefined;
+    });
+    handleMessage(message: SDKMessage, parentToolUseId: string): AgentStreamEvent[];
+    delete(toolUseId: string): void;
+    clear(): void;
+    private updateSubAgentContextFromTaskInput;
+    private normalizeSubAgentText;
+    private extractAssistantMessageActions;
+    private extractStreamEventActions;
+    private extractSubAgentActionCandidates;
+    private appendSubAgentAction;
+    private trimSubAgentTail;
+    private rebuildSubAgentActionIndex;
+    private deriveSubAgentActionSummary;
+}
+//# sourceMappingURL=sidechain-tracker.d.ts.map