@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,57 @@
+/**
+ * Turn observations into store events.
+ *
+ * Pure and stateless by construction. Both the task protocol and a persisted transcript are
+ * edge-triggered — a subagent is declared once and its status changes only when it changes — so
+ * there is nothing to debounce here. Accumulation across partial upserts is the store's sticky
+ * merge (omitted field preserves, explicit null clears), which is why a `status` observation can
+ * carry status alone without blanking the title.
+ */
+export function foldSubagentObservations(observations) {
+    const events = [];
+    for (const observation of observations) {
+        if (observation.kind === "timeline") {
+            events.push({
+                type: "timeline",
+                id: observation.id,
+                item: observation.item,
+                ...(observation.timestamp ? { timestamp: observation.timestamp } : {}),
+            });
+            continue;
+        }
+        if (observation.kind === "subtitle") {
+            events.push({
+                type: "upsert",
+                id: observation.id,
+                subtitle: observation.subtitle,
+                ...(observation.timestamp ? { timestamp: observation.timestamp } : {}),
+            });
+            continue;
+        }
+        if (observation.kind === "status") {
+            events.push({
+                type: "upsert",
+                id: observation.id,
+                status: observation.status,
+                ...(observation.timestamp ? { timestamp: observation.timestamp } : {}),
+            });
+            continue;
+        }
+        // A declared subagent is running until something says otherwise. Its terminal status
+        // arrives as its own observation, so this never has to guess at completion.
+        events.push({
+            type: "upsert",
+            id: observation.id,
+            status: "running",
+            ...(observation.title === undefined ? {} : { title: observation.title }),
+            ...(observation.description === undefined ? {} : { description: observation.description }),
+            ...(observation.toolCallId === undefined ? {} : { toolCallId: observation.toolCallId }),
+            ...(observation.parentSubagentId === undefined
+                ? {}
+                : { parentSubagentId: observation.parentSubagentId }),
+            ...(observation.timestamp ? { timestamp: observation.timestamp } : {}),
+        });
+    }
+    return events;
+}
+//# sourceMappingURL=observation.js.map

package/dist/server/server/agent/providers/claude/subagents/presentation.d.ts

@@ -0,0 +1,12 @@
+export interface ClaudeSubagentUsage {
+    totalTokens?: number;
+}
+export interface ClaudeSubagentPresentationFacts {
+    title?: string;
+    model?: string;
+    effort?: string;
+    usage?: ClaudeSubagentUsage;
+}
+/** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
+export declare function buildClaudeSubagentSubtitle(facts: ClaudeSubagentPresentationFacts): string | undefined;
+//# sourceMappingURL=presentation.d.ts.map

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

@@ -0,0 +1,41 @@
+import { findClaudeModel } from "../models.js";
+/** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
+export function buildClaudeSubagentSubtitle(facts) {
+    const parts = [
+        readPart(facts.title),
+        formatModel(facts.model),
+        formatEffort(facts.effort),
+        formatTokens(facts.usage?.totalTokens),
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+function readPart(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function formatModel(modelId) {
+    const normalized = readPart(modelId);
+    if (!normalized)
+        return undefined;
+    return findClaudeModel(normalized)?.label ?? normalized;
+}
+function formatEffort(effort) {
+    const normalized = readPart(effort);
+    if (!normalized)
+        return undefined;
+    if (normalized === "xhigh")
+        return "Extra High";
+    return normalized
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function formatTokens(totalTokens) {
+    if (typeof totalTokens !== "number" || totalTokens <= 0)
+        return undefined;
+    if (totalTokens < 1000)
+        return `${Math.round(totalTokens)} tokens`;
+    return `${Math.round(totalTokens / 100) / 10}k tokens`;
+}
+//# sourceMappingURL=presentation.js.map

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

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
+import type { SubagentObservation } from "./observation.js";
+/**
+ * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
+ * live task-protocol source produces. Identical observations in means identical descriptor
+ * state out, so a fact is derived once for both paths rather than once per path.
+ *
+ * Claude Code writes each subagent as `<session>/subagents/agent-<agentId>.jsonl` beside an
+ * `agent-<agentId>.meta.json`. The meta file carries the Task `tool_use_id`, which is the same
+ * canonical id the live stream uses — it is the bridge that lets the two paths agree.
+ */
+declare const ClaudeSubagentMetaSchema: z.ZodObject<{
+    agentType: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    description: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    toolUseId: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    spawnDepth: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ClaudeSubagentMeta = z.infer<typeof ClaudeSubagentMetaSchema>;
+/**
+ * Parse a sidecar meta file. This is undocumented Claude Code internals, so every field is
+ * optional and a malformed file is indistinguishable from an absent one: callers fall back to
+ * the parent-transcript derivation rather than losing the subagent.
+ */
+export declare function parseClaudeSubagentMeta(contents: string): ClaudeSubagentMeta | null;
+export interface ClaudeReplayEntry {
+    type?: unknown;
+    agentId?: unknown;
+    timestamp?: unknown;
+    /** Claude Code stamps the active effort on each assistant entry. */
+    effort?: unknown;
+    message?: {
+        content?: unknown;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface ClaudeReplaySubagentInput {
+    agentId: string;
+    meta: ClaudeSubagentMeta | null;
+    entries: ClaudeReplayEntry[];
+    /** Task declarations made by this subagent, used to attach its direct children. */
+    parentFacts?: ClaudeReplayParentFacts;
+}
+export interface ClaudeReplayParentFacts {
+    /** Task `tool_use` id -> identity declared in the parent's tool input. */
+    toolCalls: ReadonlyMap<string, {
+        title?: string;
+        description?: string;
+    }>;
+    /** agentId -> tool call, recovered by scraping tool-result text. Legacy fallback only. */
+    linksByAgentId: ReadonlyMap<string, {
+        toolCallId: string;
+        failed: boolean;
+    }>;
+    /** Task `tool_use` id -> outcome. Usable once meta.json supplies the link directly. */
+    outcomesByToolCallId: ReadonlyMap<string, {
+        failed: boolean;
+    }>;
+}
+export declare function observeReplaySubagents(input: {
+    subagents: readonly ClaudeReplaySubagentInput[];
+    parent: ClaudeReplayParentFacts;
+    convertEntry: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
+}): {
+    observations: SubagentObservation[];
+    toolOwners: ReadonlyMap<string, string>;
+};
+export {};
+//# sourceMappingURL=replay-source.d.ts.map

package/dist/server/server/agent/providers/claude/subagents/replay-source.js

@@ -0,0 +1,305 @@
+import { z } from "zod";
+import { normalizeProviderReplayTimestamp } from "../../../provider-history-timestamps.js";
+import { resolveObservedClaudeModelId } from "../models.js";
+import { buildClaudeSubagentSubtitle } from "./presentation.js";
+/**
+ * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
+ * live task-protocol source produces. Identical observations in means identical descriptor
+ * state out, so a fact is derived once for both paths rather than once per path.
+ *
+ * Claude Code writes each subagent as `<session>/subagents/agent-<agentId>.jsonl` beside an
+ * `agent-<agentId>.meta.json`. The meta file carries the Task `tool_use_id`, which is the same
+ * canonical id the live stream uses — it is the bridge that lets the two paths agree.
+ */
+const ClaudeSubagentMetaSchema = z.object({
+    agentType: z.string().optional().catch(undefined),
+    description: z.string().optional().catch(undefined),
+    toolUseId: z.string().optional().catch(undefined),
+    spawnDepth: z.number().optional().catch(undefined),
+});
+/**
+ * Parse a sidecar meta file. This is undocumented Claude Code internals, so every field is
+ * optional and a malformed file is indistinguishable from an absent one: callers fall back to
+ * the parent-transcript derivation rather than losing the subagent.
+ */
+export function parseClaudeSubagentMeta(contents) {
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        return null;
+    }
+    const result = ClaudeSubagentMetaSchema.safeParse(parsed);
+    if (!result.success)
+        return null;
+    const meta = result.data;
+    const hasAnyField = meta.agentType !== undefined ||
+        meta.description !== undefined ||
+        meta.toolUseId !== undefined ||
+        meta.spawnDepth !== undefined;
+    return hasAnyField ? meta : null;
+}
+/**
+ * Last-observed model and effort from a subagent's own assistant entries.
+ *
+ * Effort is replay-only: the SDK's live assistant message does not carry it, and it can be
+ * silently downgraded for the selected model, so any live value would be a guess.
+ */
+function readRuntime(entries) {
+    const runtime = {};
+    for (const entry of entries) {
+        if (entry.type !== "assistant")
+            continue;
+        const effort = typeof entry.effort === "string" ? entry.effort.trim() : "";
+        if (effort)
+            runtime.effort = effort;
+        const rawModel = entry.message?.model;
+        const model = resolveObservedClaudeModelId(typeof rawModel === "string" ? rawModel : undefined);
+        if (model)
+            runtime.model = model;
+    }
+    return runtime;
+}
+/**
+ * Token counters as Claude Code stamps them onto an assistant entry. Undocumented internals, so
+ * every field is optional and a wrong-typed field reads as absent rather than failing the entry.
+ */
+const ClaudeReplayUsageSchema = z.object({
+    input_tokens: z.number().optional().catch(undefined),
+    cache_creation_input_tokens: z.number().optional().catch(undefined),
+    cache_read_input_tokens: z.number().optional().catch(undefined),
+    output_tokens: z.number().optional().catch(undefined),
+});
+/**
+ * The one number the live path calls `total_tokens`.
+ *
+ * This is not a guess. Claude Code 2.1.220 finalizes a subagent by summing the usage block of the
+ * LAST assistant message — `input + (cache_creation ?? 0) + (cache_read ?? 0) + output` — and ships
+ * that as `usage.total_tokens` on `task_notification`; `task_progress` reports the same sum from
+ * the live tracker as it climbs. So it is a context-size reading at the final turn, not a
+ * cumulative spend across turns, which is why a small subagent reports a number in the tens of
+ * thousands: the reused prompt cache dominates it. Summing per-entry usage instead would multiply
+ * the cached prefix by the turn count and report a number several times larger than the live path.
+ */
+function readTotalTokens(raw) {
+    const parsed = ClaudeReplayUsageSchema.safeParse(raw);
+    if (!parsed.success)
+        return undefined;
+    const { input_tokens, cache_creation_input_tokens, cache_read_input_tokens, output_tokens } = parsed.data;
+    const counters = [
+        input_tokens,
+        cache_creation_input_tokens,
+        cache_read_input_tokens,
+        output_tokens,
+    ];
+    // An object with none of the four counters is not a usage block; reporting 0 would claim the
+    // subagent spent nothing.
+    if (counters.every((counter) => counter === undefined))
+        return undefined;
+    return counters.reduce((total, counter) => total + (counter ?? 0), 0);
+}
+/**
+ * Token context of a subagent's run, recovered from its own transcript.
+ *
+ * Descriptors are in-memory and dropped when the agent closes, so without this a reopened agent
+ * permanently loses its children's counters. The live path gets these numbers handed to it by
+ * Claude Code; here they are re-derived to match those definitions:
+ *
+ * The last assistant entry's summed usage matches Claude Code's live `total_tokens` definition.
+ */
+function readUsage(entries) {
+    let totalTokens;
+    for (const entry of entries) {
+        if (entry.type !== "assistant")
+            continue;
+        const observed = readTotalTokens(entry.message?.usage);
+        if (observed !== undefined)
+            totalTokens = observed;
+    }
+    return totalTokens === undefined ? null : { totalTokens };
+}
+/**
+ * Resolve a child only when the parent transcript declares the corresponding Task.
+ *
+ * `meta.toolUseId` is authoritative for identity — it is the same id the live stream keys on. The
+ * legacy path scrapes `agentId:` out of stringified tool-result content, which both misses the link
+ * when the parent's tool_result is absent and matches unrelated text — on a real five-subagent
+ * session it produced eight ids, inventing `z`, `string`, and `update`. It stays only as a fallback
+ * for sessions recorded before the meta file existed.
+ *
+ * ```
+ * meta.toolUseId matches a parent Task?
+ * ├─ yes → use it and the parent's outcome, when present
+ * └─ no  → a legacy scraped agentId link matches a parent Task?
+ *           ├─ yes → use it and its recorded outcome
+ *           └─ no  → drop it; live never declared this child either
+ * ```
+ *
+ * Claude writes grandchildren and skill-owned sidechains beside direct children. Admitting those
+ * without a parent Task creates replay-only rows with no identity or lifecycle source. Filtering
+ * here keeps live and replay on the same declaration boundary.
+ */
+function resolveParentLink(subagent, parent) {
+    const metaToolUseId = subagent.meta?.toolUseId?.trim();
+    if (metaToolUseId && parent.toolCalls.has(metaToolUseId)) {
+        const outcome = parent.outcomesByToolCallId.get(metaToolUseId);
+        let status = null;
+        if (outcome)
+            status = outcome.failed ? "failed" : "completed";
+        return {
+            id: metaToolUseId,
+            toolCallId: metaToolUseId,
+            status,
+        };
+    }
+    const scraped = parent.linksByAgentId.get(subagent.agentId);
+    if (scraped && parent.toolCalls.has(scraped.toolCallId)) {
+        return {
+            id: scraped.toolCallId,
+            toolCallId: scraped.toolCallId,
+            status: scraped.failed ? "failed" : "completed",
+        };
+    }
+    return null;
+}
+/** A final `end_turn` is the child's own completion signal when the parent result is absent. */
+function readChildTerminalStatus(entries) {
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (entry?.type !== "assistant")
+            continue;
+        return entry.message?.stop_reason === "end_turn" ? "completed" : null;
+    }
+    return null;
+}
+/**
+ * The parent's tool input is the same identity source the live path reads; meta.json contributes
+ * provider details only after that declaration has admitted the child.
+ */
+function declareSubagent(subagent, link, toolCall, parentSubagentId) {
+    const title = toolCall?.title ?? subagent.meta?.agentType;
+    const description = toolCall?.description ?? subagent.meta?.description;
+    const firstTimestamp = normalizeProviderReplayTimestamp(subagent.entries[0]?.timestamp);
+    return {
+        kind: "declared",
+        id: link.id,
+        ...(title ? { title } : {}),
+        ...(description ? { description } : {}),
+        ...(link.toolCallId ? { toolCallId: link.toolCallId } : {}),
+        ...(parentSubagentId ? { parentSubagentId } : {}),
+        ...(firstTimestamp ? { timestamp: firstTimestamp } : {}),
+    };
+}
+function observeSubtitle(subagent, link, title) {
+    const runtime = readRuntime(subagent.entries);
+    const usage = readUsage(subagent.entries);
+    const hasDetails = runtime.model !== undefined ||
+        runtime.effort !== undefined ||
+        (usage?.totalTokens !== undefined && usage.totalTokens > 0);
+    if (!hasDetails)
+        return null;
+    const subtitle = buildClaudeSubagentSubtitle({
+        title,
+        ...runtime,
+        ...(usage ? { usage } : {}),
+    });
+    if (!subtitle)
+        return null;
+    const timestamp = normalizeProviderReplayTimestamp(subagent.entries.at(-1)?.timestamp);
+    return {
+        kind: "subtitle",
+        id: link.id,
+        subtitle,
+        ...(timestamp ? { timestamp } : {}),
+    };
+}
+function observeSubagent(subagent, parent, convertEntry, parentSubagentId) {
+    const link = resolveParentLink(subagent, parent);
+    if (!link)
+        return [];
+    const toolCall = parent.toolCalls.get(link.toolCallId);
+    const observations = [
+        declareSubagent(subagent, link, toolCall, parentSubagentId),
+    ];
+    const subtitle = observeSubtitle(subagent, link, toolCall?.title ?? subagent.meta?.agentType);
+    if (subtitle)
+        observations.push(subtitle);
+    for (const entry of subagent.entries) {
+        const timestamp = normalizeProviderReplayTimestamp(entry.timestamp);
+        for (const item of convertEntry(entry)) {
+            observations.push({
+                kind: "timeline",
+                id: link.id,
+                item,
+                ...(timestamp ? { timestamp } : {}),
+            });
+        }
+    }
+    // Prefer the parent's result because it carries failure. If that result is missing, the child's
+    // final end_turn still proves completion. Any other shape remains running.
+    const terminalStatus = link.status ?? readChildTerminalStatus(subagent.entries);
+    if (terminalStatus) {
+        const lastTimestamp = normalizeProviderReplayTimestamp(subagent.entries.at(-1)?.timestamp);
+        observations.push({
+            kind: "status",
+            id: link.id,
+            status: terminalStatus,
+            ...(lastTimestamp ? { timestamp: lastTimestamp } : {}),
+        });
+    }
+    return observations;
+}
+function recordReplayToolOwners(owners, entries, subagentId) {
+    for (const entry of entries) {
+        if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+            continue;
+        for (const block of entry.message.content) {
+            if (block?.type === "tool_use" && typeof block.id === "string") {
+                owners.set(block.id, subagentId);
+            }
+        }
+    }
+}
+export function observeReplaySubagents(input) {
+    const observations = [];
+    const toolOwners = new Map();
+    const unresolved = [...input.subagents].sort((left, right) => (left.meta?.spawnDepth ?? 1) - (right.meta?.spawnDepth ?? 1));
+    const resolvedParents = new Map();
+    // Claude stores every descendant beside the root transcript. Resolve one generation at a
+    // time: a child is admitted only when its tool id is declared by a transcript whose own parent
+    // has already been proven. This preserves the old boundary against unrelated ambient sidecars.
+    let madeProgress = true;
+    while (unresolved.length > 0 && madeProgress) {
+        madeProgress = false;
+        for (let index = unresolved.length - 1; index >= 0; index--) {
+            const subagent = unresolved[index];
+            if (!subagent)
+                continue;
+            const resolved = resolveReplayOwner(subagent, input.parent, resolvedParents);
+            if (!resolved)
+                continue;
+            const { ownerId, parent, link } = resolved;
+            // Only proven descendants may own notifications; ambient sidecars cannot claim them.
+            recordReplayToolOwners(toolOwners, subagent.entries, link.id);
+            observations.push(...observeSubagent(subagent, parent, input.convertEntry, ownerId));
+            if (subagent.parentFacts)
+                resolvedParents.set(link.id, subagent.parentFacts);
+            unresolved.splice(index, 1);
+            madeProgress = true;
+        }
+    }
+    return { observations, toolOwners };
+}
+function resolveReplayOwner(subagent, rootParent, resolvedParents) {
+    const rootLink = resolveParentLink(subagent, rootParent);
+    if (rootLink)
+        return { parent: rootParent, link: rootLink };
+    for (const [ownerId, parent] of resolvedParents) {
+        const link = resolveParentLink(subagent, parent);
+        if (link)
+            return { ownerId, parent, link };
+    }
+    return null;
+}
+//# sourceMappingURL=replay-source.js.map

package/dist/server/server/agent/providers/claude/subagents/workflow-output.d.ts

@@ -0,0 +1,4 @@
+export declare function readClaudeWorkflowResultFile(outputFile: string): string | undefined;
+export declare function parseClaudeWorkflowResult(contents: string): string | undefined;
+export declare function formatClaudeWorkflowResult(result: unknown): string | undefined;
+//# sourceMappingURL=workflow-output.d.ts.map

package/dist/server/server/agent/providers/claude/subagents/workflow-output.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+const MAX_WORKFLOW_OUTPUT_BYTES = 1024 * 1024;
+const MAX_WORKFLOW_RESULT_CHARS = 100000;
+export function readClaudeWorkflowResultFile(outputFile) {
+    let descriptor;
+    try {
+        descriptor = fs.openSync(outputFile, "r");
+        const buffer = Buffer.alloc(MAX_WORKFLOW_OUTPUT_BYTES + 1);
+        let bytesRead = 0;
+        while (bytesRead < buffer.length) {
+            const count = fs.readSync(descriptor, buffer, bytesRead, buffer.length - bytesRead, null);
+            if (count === 0)
+                break;
+            bytesRead += count;
+        }
+        if (bytesRead > MAX_WORKFLOW_OUTPUT_BYTES)
+            return undefined;
+        return parseClaudeWorkflowResult(buffer.subarray(0, bytesRead).toString("utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+    }
+}
+export function parseClaudeWorkflowResult(contents) {
+    if (Buffer.byteLength(contents, "utf8") > MAX_WORKFLOW_OUTPUT_BYTES)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch {
+        return undefined;
+    }
+    const record = toRecord(parsed);
+    return record && Object.hasOwn(record, "result")
+        ? formatClaudeWorkflowResult(record.result)
+        : undefined;
+}
+export function formatClaudeWorkflowResult(result) {
+    const unwrapped = unwrapSingleValue(result);
+    let text;
+    if (typeof unwrapped === "string") {
+        text = unwrapped.trim();
+    }
+    else if (typeof unwrapped === "number" || typeof unwrapped === "boolean") {
+        text = String(unwrapped);
+    }
+    else if (unwrapped !== null && unwrapped !== undefined) {
+        try {
+            const json = JSON.stringify(unwrapped, null, 2);
+            if (json)
+                text = `\`\`\`json\n${json}\n\`\`\``;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!text)
+        return undefined;
+    return text.length <= MAX_WORKFLOW_RESULT_CHARS
+        ? text
+        : `${text.slice(0, MAX_WORKFLOW_RESULT_CHARS)}\n\n…`;
+}
+function unwrapSingleValue(value) {
+    let current = value;
+    for (let depth = 0; depth < 8; depth += 1) {
+        const record = toRecord(current);
+        if (!record)
+            return current;
+        const keys = Object.keys(record);
+        if (keys.length !== 1)
+            return current;
+        current = record[keys[0]];
+    }
+    return current;
+}
+function toRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+//# sourceMappingURL=workflow-output.js.map

package/dist/server/server/agent/providers/claude/subagents/workflow-replay-source.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
+import type { SubagentObservation } from "./observation.js";
+import type { ClaudeReplayEntry } from "./replay-source.js";
+declare const ClaudeWorkflowRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    timestamp: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    summary: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    workflowName: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    status: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    startTime: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    defaultModel: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    totalTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    result: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ClaudeWorkflowRun = z.infer<typeof ClaudeWorkflowRunSchema>;
+export interface ClaudeWorkflowParentEntry {
+    message?: {
+        content?: unknown;
+    };
+}
+export declare function parseClaudeWorkflowRun(contents: string): ClaudeWorkflowRun | null;
+/**
+ * Rebuild workflow rows from Claude's persisted run summaries.
+ *
+ * The parent tool result links a Workflow tool-use id to a run id. The run summary owns the
+ * terminal outcome and presentation facts. A nonterminal summary cannot still be live after the
+ * provider runtime was recreated, so replay terminalizes it as failed instead of resurrecting a
+ * row that can never receive another update.
+ */
+export declare function observeReplayWorkflows(input: {
+    workflows: readonly ClaudeWorkflowRun[];
+    parentEntries: readonly ClaudeWorkflowParentEntry[];
+    entriesByRunId?: ReadonlyMap<string, readonly ClaudeReplayEntry[]>;
+    convertEntry?: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
+}): SubagentObservation[];
+export {};
+//# sourceMappingURL=workflow-replay-source.d.ts.map