@sema-agent/server 7.131.0 → 7.133.0

package/dist/http/routes/workflows.d.ts

@@ -1,4 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { type WorkflowRun } from "@sema-agent/core";
+import { type Admit } from "../../trace/projection-table.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 /** SVC-5 的 steer 路——`handle()` 里位置在 tasks/runs 之后(鉴权门之后),故是**独立**的域入口。 */
 /** 路由体 = 从 `server.ts` 的 `handle()` 里**整段剪切**过来的原文(唯一改动:统一去缩进两格)。裸 `return;`
@@ -6,6 +8,354 @@ import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 export declare function handleWorkflows(req: IncomingMessage, res: ServerResponse, match: RouteMatch<WorkflowsRouteId>, ctx: RouteCtx): Promise<void>;
 /** 同上纪律(SVC-5 steer 段)。 */
 export declare function handleWorkflowAgentSteer(req: IncomingMessage, res: ServerResponse, match: RouteMatch<WorkflowAgentSteerRouteId>, ctx: RouteCtx): Promise<void>;
+type WorkflowPhaseRow = WorkflowRun["phases"][number];
+type WorkflowAgentRow = WorkflowRun["agents"][number];
+type WorkflowGroupRow = WorkflowRun["groups"][number];
+/**
+ * 组森林(`groups` 的 `rows` 与节点的 `children` 读同一份,每次投影建一次,经根传给两处):按 `groupId` 建索引(重号后写赢、位次取首次出现),父在索引里、
+ * 不是自己、且自己不在环上 ⇒ 挂到父下;否则(顶层 / 悬挂父 / 环成员)⇒ 挂到根下,一个都不丢。环判走父链、有界,坏存量既挂不住也
+ * 造不出 `JSON.stringify` 会抛的环。不跨调用记忆(内存店交出的可能是一只还在长的活对象),也不按节点重建(那是 O(N²·深度))。
+ */
+export interface GroupForest {
+    readonly roots: readonly WorkflowGroupRow[];
+    readonly childrenOf: ReadonlyMap<WorkflowGroupRow, readonly WorkflowGroupRow[]>;
+}
+/** 详情面九张表的铸键与 `rows` 读到的根:原记录 + 本次投影建一次的组森林。 */
+export interface WorkflowDetailRoot {
+    readonly run: WorkflowRun;
+    readonly forest: GroupForest;
+}
+/** `parks[]`(core 7.17.0 [ref] 义务①:park 真值来自店;读面**逐键挑**,不是展开)。 */
+export declare const WORKFLOW_PARK_ROW_DISPOSITIONS: {
+    readonly callKey: "forward";
+    readonly sessionId: "forward";
+    readonly token: "strip";
+    readonly originRunId: "forward";
+    readonly originUnconfirmed: {
+        readonly forward: Admit;
+    };
+    readonly parkedBy: "forward";
+    readonly generation: "forward";
+};
+export declare const WORKFLOW_PHASE_DISPOSITIONS: {
+    readonly title: {
+        readonly redact: "redactSecrets";
+    };
+    readonly status: "forward";
+    readonly detail: "strip";
+    readonly model: "strip";
+    readonly agentFailures: "strip";
+    readonly startedAt: "forward";
+    readonly endedAt: "forward";
+    readonly durationMs: {
+        readonly mint: (p: WorkflowPhaseRow) => number | undefined;
+    };
+    readonly done: {
+        readonly mint: (p: WorkflowPhaseRow, root: WorkflowDetailRoot) => number;
+    };
+    readonly total: {
+        readonly mint: (p: WorkflowPhaseRow, root: WorkflowDetailRoot) => number;
+    };
+};
+/** 活动拍(core 1.295 起两拍都带 `at`):结构位 + core 已脱敏的短 `arg`。表序让两拍各自保持生产者的键序(start 无 `isError`、end 无 `arg`)。 */
+export declare const WORKFLOW_AGENT_ACTIVITY_DISPOSITIONS: {
+    readonly phase: "forward";
+    readonly toolCallId: "forward";
+    readonly toolName: "forward";
+    readonly isError: "forward";
+    readonly at: "forward";
+    readonly arg: "forward";
+};
+export declare const WORKFLOW_AGENT_PENDING_APPROVAL_DISPOSITIONS: {
+    readonly askIds: "forward";
+    readonly oldestCreatedAtMs: "forward";
+};
+export declare const WORKFLOW_AGENT_DISPOSITIONS: {
+    readonly label: {
+        readonly redact: "redactSecrets";
+    };
+    readonly status: "forward";
+    readonly displayStatus: {
+        readonly mint: (a: WorkflowAgentRow, root: WorkflowDetailRoot) => import("@sema-agent/core").AgentDisplayStatus;
+    };
+    readonly taskStatus: "forward";
+    readonly callKey: "forward";
+    readonly groupId: "forward";
+    readonly phase: {
+        readonly redact: "redactSecrets";
+    };
+    readonly model: "forward";
+    readonly tokens: {
+        readonly mint: (a: WorkflowAgentRow) => number | undefined;
+    };
+    readonly turns: {
+        readonly mint: (a: WorkflowAgentRow) => number | undefined;
+    };
+    readonly toolCalls: "forward";
+    readonly activity: {
+        readonly nested: {
+            readonly phase: "forward";
+            readonly toolCallId: "forward";
+            readonly toolName: "forward";
+            readonly isError: "forward";
+            readonly at: "forward";
+            readonly arg: "forward";
+        };
+        readonly rows: "each";
+    };
+    readonly lastActivityAt: {
+        readonly mint: (a: WorkflowAgentRow) => number | undefined;
+    };
+    readonly durationMs: {
+        readonly mint: (a: WorkflowAgentRow) => number | undefined;
+    };
+    readonly queuedAt: "forward";
+    readonly startedAt: "forward";
+    readonly endedAt: "forward";
+    readonly replayed: "forward";
+    readonly prompt: "forward";
+    readonly output: "forward";
+    readonly pendingApproval: {
+        readonly nested: {
+            readonly askIds: "forward";
+            readonly oldestCreatedAtMs: "forward";
+        };
+        readonly admit: (raw: unknown) => boolean;
+    };
+    readonly approvalWaitedMs: {
+        readonly forward: (raw: unknown) => boolean;
+    };
+    readonly taskRunId: "forward";
+    readonly errorCode: "strip";
+    readonly errorMessage: "strip";
+    readonly stats: "strip";
+    readonly attempts: "strip";
+    readonly lastAttemptReason: "strip";
+    readonly sessionId: "strip";
+    readonly parkedCheckpointToken: "strip";
+    readonly worktreeDir: "strip";
+};
+export declare const WORKFLOW_GROUP_DISPOSITIONS: {
+    readonly groupId: "forward";
+    readonly parentGroupId: "forward";
+    readonly status: "forward";
+    readonly startedAt: "forward";
+    readonly endedAt: "forward";
+    readonly durationMs: {
+        readonly mint: (g: WorkflowGroupRow) => number | undefined;
+    };
+    readonly agentCallKeys: {
+        readonly mint: (g: WorkflowGroupRow, root: WorkflowDetailRoot) => string[];
+    };
+    readonly children: {
+        readonly mint: (g: WorkflowGroupRow, root: WorkflowDetailRoot) => unknown;
+    };
+};
+export declare const WORKFLOW_RUN_STATS_NESTED_DISPOSITIONS: {
+    readonly tokens: "forward";
+    readonly turns: "forward";
+    readonly tasks: "forward";
+    readonly costMicroUsd: "forward";
+};
+/** run 级用量(本 run 自己的 + 嵌套的,core R-5 分开记)。 */
+export declare const WORKFLOW_RUN_STATS_DISPOSITIONS: {
+    readonly tokens: "forward";
+    readonly turns: "forward";
+    readonly costMicroUsd: "forward";
+    readonly nested: {
+        readonly nested: {
+            readonly tokens: "forward";
+            readonly turns: "forward";
+            readonly tasks: "forward";
+            readonly costMicroUsd: "forward";
+        };
+    };
+};
+export declare const WORKFLOW_RUN_DISPOSITIONS: {
+    readonly id: "forward";
+    readonly scope: "forward";
+    readonly status: "forward";
+    readonly name: {
+        readonly redact: "redactSecrets";
+    };
+    readonly description: {
+        readonly redact: "redactSecrets";
+    };
+    readonly stats: {
+        readonly nested: {
+            readonly tokens: "forward";
+            readonly turns: "forward";
+            readonly costMicroUsd: "forward";
+            readonly nested: {
+                readonly nested: {
+                    readonly tokens: "forward";
+                    readonly turns: "forward";
+                    readonly tasks: "forward";
+                    readonly costMicroUsd: "forward";
+                };
+            };
+        };
+    };
+    readonly agentFailures: "forward";
+    readonly startedAt: "forward";
+    readonly endedAt: "forward";
+    readonly createdAt: "forward";
+    readonly durationMs: {
+        readonly mint: (run: WorkflowRun) => number | undefined;
+    };
+    readonly rev: "forward";
+    readonly error: {
+        readonly redact: "redactErrorMessage";
+    };
+    readonly errorCode: "forward";
+    readonly parks: {
+        readonly nested: {
+            readonly callKey: "forward";
+            readonly sessionId: "forward";
+            readonly token: "strip";
+            readonly originRunId: "forward";
+            readonly originUnconfirmed: {
+                readonly forward: Admit;
+            };
+            readonly parkedBy: "forward";
+            readonly generation: "forward";
+        };
+        readonly rows: "each";
+    };
+    readonly resumeAdmissionIncomplete: {
+        readonly forward: Admit;
+    };
+    readonly result: {
+        readonly redact: "redactSecrets";
+    };
+    readonly phases: {
+        readonly nested: {
+            readonly title: {
+                readonly redact: "redactSecrets";
+            };
+            readonly status: "forward";
+            readonly detail: "strip";
+            readonly model: "strip";
+            readonly agentFailures: "strip";
+            readonly startedAt: "forward";
+            readonly endedAt: "forward";
+            readonly durationMs: {
+                readonly mint: (p: WorkflowPhaseRow) => number | undefined;
+            };
+            readonly done: {
+                readonly mint: (p: WorkflowPhaseRow, root: WorkflowDetailRoot) => number;
+            };
+            readonly total: {
+                readonly mint: (p: WorkflowPhaseRow, root: WorkflowDetailRoot) => number;
+            };
+        };
+        readonly rows: "each";
+    };
+    readonly unphased: {
+        readonly mint: (run: WorkflowRun) => {
+            done: number;
+            total: number;
+        } | undefined;
+    };
+    readonly agents: {
+        readonly nested: {
+            readonly label: {
+                readonly redact: "redactSecrets";
+            };
+            readonly status: "forward";
+            readonly displayStatus: {
+                readonly mint: (a: WorkflowAgentRow, root: WorkflowDetailRoot) => import("@sema-agent/core").AgentDisplayStatus;
+            };
+            readonly taskStatus: "forward";
+            readonly callKey: "forward";
+            readonly groupId: "forward";
+            readonly phase: {
+                readonly redact: "redactSecrets";
+            };
+            readonly model: "forward";
+            readonly tokens: {
+                readonly mint: (a: WorkflowAgentRow) => number | undefined;
+            };
+            readonly turns: {
+                readonly mint: (a: WorkflowAgentRow) => number | undefined;
+            };
+            readonly toolCalls: "forward";
+            readonly activity: {
+                readonly nested: {
+                    readonly phase: "forward";
+                    readonly toolCallId: "forward";
+                    readonly toolName: "forward";
+                    readonly isError: "forward";
+                    readonly at: "forward";
+                    readonly arg: "forward";
+                };
+                readonly rows: "each";
+            };
+            readonly lastActivityAt: {
+                readonly mint: (a: WorkflowAgentRow) => number | undefined;
+            };
+            readonly durationMs: {
+                readonly mint: (a: WorkflowAgentRow) => number | undefined;
+            };
+            readonly queuedAt: "forward";
+            readonly startedAt: "forward";
+            readonly endedAt: "forward";
+            readonly replayed: "forward";
+            readonly prompt: "forward";
+            readonly output: "forward";
+            readonly pendingApproval: {
+                readonly nested: {
+                    readonly askIds: "forward";
+                    readonly oldestCreatedAtMs: "forward";
+                };
+                readonly admit: (raw: unknown) => boolean;
+            };
+            readonly approvalWaitedMs: {
+                readonly forward: (raw: unknown) => boolean;
+            };
+            readonly taskRunId: "forward";
+            readonly errorCode: "strip";
+            readonly errorMessage: "strip";
+            readonly stats: "strip";
+            readonly attempts: "strip";
+            readonly lastAttemptReason: "strip";
+            readonly sessionId: "strip";
+            readonly parkedCheckpointToken: "strip";
+            readonly worktreeDir: "strip";
+        };
+        readonly rows: "each";
+    };
+    readonly groups: {
+        readonly nested: {
+            readonly groupId: "forward";
+            readonly parentGroupId: "forward";
+            readonly status: "forward";
+            readonly startedAt: "forward";
+            readonly endedAt: "forward";
+            readonly durationMs: {
+                readonly mint: (g: WorkflowGroupRow) => number | undefined;
+            };
+            readonly agentCallKeys: {
+                readonly mint: (g: WorkflowGroupRow, root: WorkflowDetailRoot) => string[];
+            };
+            readonly children: {
+                readonly mint: (g: WorkflowGroupRow, root: WorkflowDetailRoot) => unknown;
+            };
+        };
+        readonly rows: (_groups: readonly WorkflowGroupRow[], root: WorkflowDetailRoot) => readonly import("@sema-agent/core").WorkflowGroup[];
+    };
+    readonly sourceTaskId: "strip";
+    readonly originatingSessionId: "strip";
+    readonly effectiveArgs: "strip";
+    readonly budgetOvershoot: "strip";
+    readonly timeoutInterruption: "strip";
+    readonly resultFull: "strip";
+    readonly completionId: "strip";
+    readonly resume: "strip";
+    readonly journalSkips: "strip";
+};
+/** SVC-4 v1 详情体 = 根表的一次解释(见上方表头注);组森林在这里建一次,经根交给 `rows` 与 `children`。 */
+export declare function summarizeWorkflowDetail(run: WorkflowRun): Record<string, unknown>;
 export declare const WORKFLOWS_ROUTES: readonly [{
     readonly id: "workflows-list";
     readonly path: "/v1/workflows";
@@ -36,4 +386,5 @@ export declare const WORKFLOW_AGENT_STEER_ROUTES: readonly [{
     readonly methods: readonly ["POST"];
 }];
 export type WorkflowAgentSteerRouteId = RouteIdsOf<typeof WORKFLOW_AGENT_STEER_ROUTES>;
+export {};
 //# sourceMappingURL=workflows.d.ts.map

package/dist/http/routes/workflows.js

@@ -6,7 +6,8 @@ import { journalEntryOfBody, journalEntryPayload, journalRowPayloadOf, readJourn
 import { decodeJsonColumn } from "../../plugins/sql-json-column.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { createHash } from "node:crypto";
-import { redactErrorMessage, redactHead } from "../../observability/run-terminal.js";
+import { redactHead } from "../../observability/run-terminal.js";
+import { projectByTable } from "../../trace/projection-table.js";
 const JOURNAL_PROJECTION_MEMO_CAP = 1024;
 const journalProjectionMemo = new Map();
 import { sendJson, sendError, sseHeaders } from "../send.js";
@@ -177,14 +178,7 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
             sendError(res, 400, "request.path_malformed", "malformed workflow path (invalid percent-encoding)");
             return;
         }
-        let body;
-        try {
-            body = (await readJson(req));
-        }
-        catch {
-            sendError(res, 400, "request.invalid_json", "invalid JSON body");
-            return;
-        }
+        const body = (await readJson(req));
         if (typeof body.content !== "string" || body.content.length === 0) {
             sendError(res, 400, "request.body_shape", "body must be { content: string (non-empty) }");
             return;
@@ -200,7 +194,7 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
             sendError(res, 413, "steer.content_too_large", `content exceeds ${STEER_IN_MAX_REQUEST_CHARS} characters (got ${body.content.length}); note only the first ${STEER_IN_MAX_CHARS} are delivered anyway`);
             return;
         }
-        const trusted = explicitOperatorOk(principal, deps.config.operatorPrincipals);
+        const trusted = explicitOperatorOk(principal, deps.config);
         const ownerScope = principal ?? "default";
         const wfRun = await getWorkflowRun(runs.store, wfRunId, ownerScope);
         if (!trusted && !wfRun) {
@@ -240,92 +234,18 @@ export async function handleWorkflowAgentSteer(req, res, match, ctx) {
         return;
     }
 }
-const LegApprovalKeysSchema = z
-    .object({
-    pendingApproval: z.object({ askIds: z.array(z.string().min(1)).min(1), oldestCreatedAtMs: z.number().finite() }).optional(),
-    approvalWaitedMs: z.number().finite().nonnegative().optional(),
-})
-    .loose();
-function projectLegApprovalKeys(agent) {
-    const parsed = LegApprovalKeysSchema.safeParse(agent);
-    if (!parsed.success)
-        return {};
-    const { pendingApproval, approvalWaitedMs } = parsed.data;
-    return {
-        ...(pendingApproval !== undefined ? { pendingApproval: { askIds: [...pendingApproval.askIds], oldestCreatedAtMs: pendingApproval.oldestCreatedAtMs } } : {}),
-        ...(approvalWaitedMs !== undefined ? { approvalWaitedMs } : {}),
-    };
-}
-function projectParkRow(p) {
-    return {
-        callKey: p.callKey,
-        sessionId: p.sessionId,
-        originRunId: p.originRunId,
-        ...(p.originUnconfirmed === true ? { originUnconfirmed: true } : {}),
-        ...(p.parkedBy !== undefined ? { parkedBy: p.parkedBy } : {}),
-        ...(p.generation !== undefined ? { generation: p.generation } : {}),
-    };
+const isTerminalAgentStatus = (s) => s === "completed" || s === "failed";
+const durationOf = (a) => a.startedAt === undefined || a.endedAt === undefined ? undefined : a.endedAt - a.startedAt;
+const isLiteralTrue = (raw) => raw === true;
+const LegPendingApprovalSchema = z.object({ askIds: z.array(z.string().min(1)).min(1), oldestCreatedAtMs: z.number().finite() });
+const LegApprovalWaitedMsSchema = z.number().finite().nonnegative();
+function rowsOf(list) {
+    return Array.isArray(list) ? list.filter((row) => typeof row === "object" && row !== null && !Array.isArray(row)) : [];
 }
-function summarizeWorkflowDetail(run) {
-    const isDone = (s) => s === "completed" || s === "failed";
-    const durationOf = (a) => a.startedAt === undefined || a.endedAt === undefined ? undefined : a.endedAt - a.startedAt;
-    const runPhases = run.phases ?? [];
-    const runAgents = run.agents ?? [];
-    const runGroups = run.groups ?? [];
-    const phases = runPhases.map((p) => {
-        const inPhase = runAgents.filter((a) => a.phase === p.title);
-        return {
-            title: redactSecrets(p.title),
-            status: p.status,
-            startedAt: p.startedAt,
-            endedAt: p.endedAt,
-            durationMs: durationOf(p),
-            done: inPhase.filter((a) => isDone(a.status)).length,
-            total: inPhase.length,
-        };
-    });
-    const phaseTitleSet = new Set(runPhases.map((p) => p.title));
-    const unphased = runAgents.filter((a) => a.phase === undefined || a.phase === "" || !phaseTitleSet.has(a.phase));
-    const unphasedView = unphased.length > 0
-        ? { done: unphased.filter((a) => isDone(a.status)).length, total: unphased.length }
-        : undefined;
-    const agents = runAgents.map((a) => ({
-        label: redactSecrets(a.label),
-        status: a.status,
-        displayStatus: deriveAgentDisplayStatus(a, run.status),
-        taskStatus: a.taskStatus,
-        callKey: a.callKey,
-        groupId: a.groupId,
-        phase: a.phase !== undefined ? redactSecrets(a.phase) : undefined,
-        model: a.model,
-        tokens: a.stats?.tokens,
-        turns: a.stats?.turns,
-        toolCalls: a.toolCalls,
-        activity: a.activity,
-        lastActivityAt: a.activity && a.activity.length > 0 ? a.activity[a.activity.length - 1].at : undefined,
-        durationMs: durationOf(a),
-        queuedAt: a.queuedAt,
-        startedAt: a.startedAt,
-        endedAt: a.endedAt,
-        replayed: a.replayed,
-        prompt: a.prompt,
-        output: a.output,
-        ...projectLegApprovalKeys(a),
-        taskRunId: a.taskRunId,
-    }));
+function groupForestOf(run) {
     const byId = new Map();
-    for (const g of runGroups) {
-        byId.set(g.groupId, {
-            groupId: g.groupId,
-            parentGroupId: g.parentGroupId,
-            status: g.status,
-            startedAt: g.startedAt,
-            endedAt: g.endedAt,
-            durationMs: durationOf(g),
-            agentCallKeys: runAgents.filter((a) => a.groupId === g.groupId).map((a) => a.callKey),
-            children: [],
-        });
-    }
+    for (const g of rowsOf(run.groups))
+        byId.set(g.groupId, g);
     const inCycle = (start) => {
         const seen = new Set();
         let cur = start;
@@ -338,36 +258,150 @@ function summarizeWorkflowDetail(run) {
         return false;
     };
     const roots = [];
+    const childrenOf = new Map();
     for (const node of byId.values()) {
+        childrenOf.set(node, childrenOf.get(node) ?? []);
         const parent = node.parentGroupId !== undefined ? byId.get(node.parentGroupId) : undefined;
-        if (parent && parent !== node && !inCycle(node))
-            parent.children.push(node);
+        if (parent && parent !== node && !inCycle(node)) {
+            const siblings = childrenOf.get(parent) ?? [];
+            siblings.push(node);
+            childrenOf.set(parent, siblings);
+        }
         else
             roots.push(node);
     }
-    return {
-        id: run.id,
-        scope: run.scope,
-        status: run.status,
-        ...(run.name !== undefined ? { name: redactSecrets(run.name) } : {}),
-        ...(run.description !== undefined ? { description: redactSecrets(run.description) } : {}),
-        stats: run.stats,
-        ...(run.agentFailures !== undefined ? { agentFailures: run.agentFailures } : {}),
-        startedAt: run.startedAt,
-        endedAt: run.endedAt,
-        createdAt: run.createdAt,
-        durationMs: durationOf(run),
-        rev: run.rev,
-        ...(run.error !== undefined ? { error: redactErrorMessage(run.error) ?? "" } : {}),
-        ...(run.errorCode !== undefined ? { errorCode: run.errorCode } : {}),
-        ...(run.parks !== undefined ? { parks: run.parks.map(projectParkRow) } : {}),
-        ...(run.resumeAdmissionIncomplete === true ? { resumeAdmissionIncomplete: true } : {}),
-        ...(run.result !== undefined ? { result: redactSecrets(run.result) } : {}),
-        phases,
-        ...(unphasedView ? { unphased: unphasedView } : {}),
-        agents,
-        groups: roots,
-    };
+    return { roots, childrenOf };
+}
+export const WORKFLOW_PARK_ROW_DISPOSITIONS = {
+    callKey: "forward",
+    sessionId: "forward",
+    token: "strip",
+    originRunId: "forward",
+    originUnconfirmed: { forward: isLiteralTrue },
+    parkedBy: "forward",
+    generation: "forward",
+};
+export const WORKFLOW_PHASE_DISPOSITIONS = {
+    title: { redact: "redactSecrets" },
+    status: "forward",
+    detail: "strip",
+    model: "strip",
+    agentFailures: "strip",
+    startedAt: "forward",
+    endedAt: "forward",
+    durationMs: { mint: (p) => durationOf(p) },
+    done: { mint: (p, root) => rowsOf(root.run.agents).filter((a) => a.phase === p.title && isTerminalAgentStatus(a.status)).length },
+    total: { mint: (p, root) => rowsOf(root.run.agents).filter((a) => a.phase === p.title).length },
+};
+export const WORKFLOW_AGENT_ACTIVITY_DISPOSITIONS = {
+    phase: "forward",
+    toolCallId: "forward",
+    toolName: "forward",
+    isError: "forward",
+    at: "forward",
+    arg: "forward",
+};
+export const WORKFLOW_AGENT_PENDING_APPROVAL_DISPOSITIONS = {
+    askIds: "forward",
+    oldestCreatedAtMs: "forward",
+};
+export const WORKFLOW_AGENT_DISPOSITIONS = {
+    label: { redact: "redactSecrets" },
+    status: "forward",
+    displayStatus: { mint: (a, root) => deriveAgentDisplayStatus(a, root.run.status) },
+    taskStatus: "forward",
+    callKey: "forward",
+    groupId: "forward",
+    phase: { redact: "redactSecrets" },
+    model: "forward",
+    tokens: { mint: (a) => a.stats?.tokens },
+    turns: { mint: (a) => a.stats?.turns },
+    toolCalls: "forward",
+    activity: { nested: WORKFLOW_AGENT_ACTIVITY_DISPOSITIONS, rows: "each" },
+    lastActivityAt: { mint: (a) => rowsOf(a.activity).at(-1)?.at },
+    durationMs: { mint: (a) => durationOf(a) },
+    queuedAt: "forward",
+    startedAt: "forward",
+    endedAt: "forward",
+    replayed: "forward",
+    prompt: "forward",
+    output: "forward",
+    pendingApproval: { nested: WORKFLOW_AGENT_PENDING_APPROVAL_DISPOSITIONS, admit: (raw) => LegPendingApprovalSchema.safeParse(raw).success },
+    approvalWaitedMs: { forward: (raw) => LegApprovalWaitedMsSchema.safeParse(raw).success },
+    taskRunId: "forward",
+    errorCode: "strip",
+    errorMessage: "strip",
+    stats: "strip",
+    attempts: "strip",
+    lastAttemptReason: "strip",
+    sessionId: "strip",
+    parkedCheckpointToken: "strip",
+    worktreeDir: "strip",
+};
+export const WORKFLOW_GROUP_DISPOSITIONS = {
+    groupId: "forward",
+    parentGroupId: "forward",
+    status: "forward",
+    startedAt: "forward",
+    endedAt: "forward",
+    durationMs: { mint: (g) => durationOf(g) },
+    agentCallKeys: { mint: (g, root) => rowsOf(root.run.agents).filter((a) => a.groupId === g.groupId).map((a) => a.callKey) },
+    children: {
+        mint: (g, root) => (root.forest.childrenOf.get(g) ?? []).map((c) => projectByTable("workflow_detail.groups[]", WORKFLOW_GROUP_DISPOSITIONS, c, root)),
+    },
+};
+export const WORKFLOW_RUN_STATS_NESTED_DISPOSITIONS = {
+    tokens: "forward",
+    turns: "forward",
+    tasks: "forward",
+    costMicroUsd: "forward",
+};
+export const WORKFLOW_RUN_STATS_DISPOSITIONS = {
+    tokens: "forward",
+    turns: "forward",
+    costMicroUsd: "forward",
+    nested: { nested: WORKFLOW_RUN_STATS_NESTED_DISPOSITIONS },
+};
+export const WORKFLOW_RUN_DISPOSITIONS = {
+    id: "forward",
+    scope: "forward",
+    status: "forward",
+    name: { redact: "redactSecrets" },
+    description: { redact: "redactSecrets" },
+    stats: { nested: WORKFLOW_RUN_STATS_DISPOSITIONS },
+    agentFailures: "forward",
+    startedAt: "forward",
+    endedAt: "forward",
+    createdAt: "forward",
+    durationMs: { mint: (run) => durationOf(run) },
+    rev: "forward",
+    error: { redact: "redactErrorMessage" },
+    errorCode: "forward",
+    parks: { nested: WORKFLOW_PARK_ROW_DISPOSITIONS, rows: "each" },
+    resumeAdmissionIncomplete: { forward: isLiteralTrue },
+    result: { redact: "redactSecrets" },
+    phases: { nested: WORKFLOW_PHASE_DISPOSITIONS, rows: "each" },
+    unphased: {
+        mint: (run) => {
+            const titles = new Set(rowsOf(run.phases).map((p) => p.title));
+            const loose = rowsOf(run.agents).filter((a) => a.phase === undefined || a.phase === "" || !titles.has(a.phase));
+            return loose.length > 0 ? { done: loose.filter((a) => isTerminalAgentStatus(a.status)).length, total: loose.length } : undefined;
+        },
+    },
+    agents: { nested: WORKFLOW_AGENT_DISPOSITIONS, rows: "each" },
+    groups: { nested: WORKFLOW_GROUP_DISPOSITIONS, rows: (_groups, root) => root.forest.roots },
+    sourceTaskId: "strip",
+    originatingSessionId: "strip",
+    effectiveArgs: "strip",
+    budgetOvershoot: "strip",
+    timeoutInterruption: "strip",
+    resultFull: "strip",
+    completionId: "strip",
+    resume: "strip",
+    journalSkips: "strip",
+};
+export function summarizeWorkflowDetail(run) {
+    return projectByTable("workflow_detail", WORKFLOW_RUN_DISPOSITIONS, run, { run, forest: groupForestOf(run) });
 }
 async function streamWorkflowRun(req, res, runId, scope) {
     sseHeaders(res);