@ericsanchezok/synergy-workbench 0.0.0-stage → 3.1.1

package/AGENTS.md

@@ -0,0 +1,30 @@
+# workbench Package
+
+Product Projects, statistics and performance read models, activity presentation and notifications. Keep product read models out of core execution accounting. Session, rollout and retained usage evidence remain canonical in Harness. Statistics routes and compatibility projections consume the public usage service; keep accounting formulas in that owner. Read the root AGENTS.md and the owning architecture document before changes.
+
+File review Git comparisons and revisioned session notes belong in `src/review`. Keep comparisons read-only, fence workspace generations and content versions, and use retained Harness snapshots for historical versions. Verify `bun test test/review`, regenerate the SDK after schema changes, and follow [File review](../../docs/reference/file-review.md).
+
+- Keep domain tools, routes, configuration and migrations with their implementation.
+- Own configuration schemas, normalization, reference checks and secret handling in `src/config-schema.ts`; consumers use its typed reader and the host composes its registration.
+- Import other packages only through declared public exports; preserve cancellation, permissions and persisted data.
+- Tests live under test/ and use isolated homes through the testing support package.
+
+Run bun run typecheck and the affected tests, then the root package and dependency checks.
+
+Keep stable Workbench availability separate from the default-off `kanban` restart experiment declared in `./features`. The board's UI and subscriptions use its own capability; statistics and other Workbench consumers remain independent. Follow [feature lifecycle](../../docs/architecture/feature-lifecycle.md).
+
+Project directory configuration, explicit sharing and the central migration belong to `src/project/directories.ts` and `src/project/migration.ts`. Preserve Scope identity and historical Worktree sources when changing the main folder. Run `bun test test/project/directories.test.ts` for creation, revision, busy-resource, migration and multi-repository behavior.
+
+Project task defaults belong to `src/project/task-defaults.ts` and its scoped HTTP adapter. Verify project-only writes and concurrent edits with `bun test test/project/task-defaults.test.ts`; regenerate the SDK after changing its schemas.
+
+The managed-worktree janitor schedules per Scope and drains active sweeps during disposal. Run `bun test test/project/worktree-janitor.test.ts` for scheduler ownership changes.
+
+Expose composition through `./component`; keep registration side-effect free until the factory is selected. Declare required components, optional ordering, worker roles and lazy HTTP adapters explicitly. Runtime-scoped reload and lifecycle contributions must preserve isolated instances and failed-start cleanup.
+
+Keep published `synergy` component metadata aligned with the factory version, requirements and packaged entry. Component CLI contributions belong in `src/cli-adapter.ts` when this owner supplies commands; keep their handlers lazy and independent of the complete product.
+
+Task execution presentation belongs in `src/execution`. Use public Harness Rollout and usage queries and the public `context` reconciliation; keep evidence storage layouts and accounting formulas in Harness. Verify `bun test test/execution`, regenerate the SDK after schema changes, and preserve Scope/round/descendant checks, lazy content and revisioned updates.
+
+Execution projections implement the Server contribution contract. Compute detail updates only for retained subscribers or explicit legacy clients; invalidation must not refresh LRU activity. Keep snapshot revisions and field/context deltas independently recoverable and bounded.
+
+Existing-resource presentation belongs in `src/presentation`. Use the shared util `WorkbenchView` protocol and Server's public event-client contribution, never Bus/history-driven effects or a second socket. Keep Session/Scope routing, captured Workspace generations, same-connection receipts, identity-based applied validation and Runtime-only deduplication. Verify `bun test test/tool/workbench-view.test.ts test/presentation/service.test.ts`; callback-bound broker tests are unit evidence, not frontend acceptance.

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# Workbench
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Product Projects, statistics and performance read models, activity presentation, task execution details and notifications.
+
+Keep product read models out of core execution accounting. Session and rollout evidence remain canonical in Harness.
+
+Cross-package imports use the explicit entries in `package.json`. Tests and fixtures belong in this package’s `test/` tree. Full API composition tests belong in `presets/test/`.
+
+Run `bun run typecheck`, `bun run test`, and `bun run test:coverage` from this package. Build an importable library with `bun script/build-workspace.ts packages/workbench` from the repository root; `bun script/pack-workspace.ts packages/workbench .artifacts/packages` builds its workspace dependency closure.
+
+Task execution queries live in `src/execution` and consume public Harness Rollout and usage exports. The scoped session API exposes summary, process/records trajectory, type-specific node detail and versioned content ranges/sections/search/download. Financial presentation is shared with statistics; formulas and immutable prices remain in Harness. Verify ownership, lifecycle, paging, grouped purposes, retained children and large content with `bun test test/execution`.
+
+`workbench_view` presents existing Notes, Workspace files, Browser pages and immutable Assets through `src/presentation`. It does not create resources, navigate pages or perform arbitrary UI actions. Only protocol-ready, target-supporting frontends actively displaying the caller's Scope and Session are eligible. Multiple eligible frontends require an explicit returned `clientId`; no frontend is elected or broadcast to. File opens capture the caller Session's valid Workspace identity and generation, never the viewer's directory.
+
+Presentation waits for a matching receipt from the selected connection. `applied` opens include the requested visible resource; hides confirm the known view identity as hidden. Resource identity excludes location. Content can remain `loading` after presentation is applied. The default receipt window is 30 seconds; `timeoutSeconds` accepts any positive finite duration without a product maximum. Cancellation after dispatch, active-view changes, send failure, disconnection and missing receipts leave the effect `unknown`, with cancellation sent when possible and no automatic retry.
+
+Tool-call identities deduplicate within the Runtime and reject changed arguments. `status` with `requestId` reads only the same Scope/Session's retained confirmed receipt; without one it asks an eligible frontend for current views. Disconnect releases views and receipts, retaining only an in-memory no-replay identity tombstone until Runtime disposal. No command queue or durable state is added. Verify the real socket/tool cases with `bun test test/tool/workbench-view.test.ts` and broker failure/lifecycle units with `bun test test/presentation/service.test.ts`.

package/dist/agents.js

@@ -0,0 +1,11 @@
+import { createPerformanceAnalystAgent } from "./performance/prompt/builder.js";
+import { AgentBuiltins } from "@ericsanchezok/synergy-harness/agent/builtins";
+export function createDomainAgents(ctx) {
+    const performanceAnalyst = createPerformanceAnalystAgent(ctx);
+    return {
+        [performanceAnalyst.name]: performanceAnalyst,
+    };
+}
+export function registerWorkbenchAgents() {
+    AgentBuiltins.register("workbench", createDomainAgents);
+}

package/dist/cli-adapter.js

@@ -0,0 +1,8 @@
+export const commands = [
+    {
+        command: "stats",
+        describe: "show token usage and cost statistics",
+        storage: "maintenance",
+        load: async () => (await import("./stats/cli/stats.js")).StatsCommand,
+    },
+];

package/dist/component.js

@@ -0,0 +1,65 @@
+import { componentFeatures } from "./features.js";
+import { BusEvent } from "@ericsanchezok/synergy-harness/bus/bus-event";
+import { Vcs } from "./project/vcs.js";
+import { Ide } from "./project/ide.js";
+import { ReviewState } from "./review/state.js";
+import { ExecutionSchema } from "./execution/schema.js";
+import { registerProjectMigrations } from "./project/migration.js";
+import { PushBridge } from "./push/bridge.js";
+import { version } from "../package.json" with { type: "json" };
+import { registerWorkbenchAgents } from "./agents.js";
+import { registerProjectTools } from "./project/tools.js";
+import { registerProjectStartup } from "./project/startup.js";
+import { registerProjectSessionHealth } from "./project/session-health.js";
+import { registerConfig } from "./config-schema.js";
+import { Usage } from "@ericsanchezok/synergy-harness/usage";
+import { ExecutionService } from "./execution/service.js";
+import { WorkbenchPresentation } from "./presentation/service.js";
+import { registerPresentationTools } from "./presentation/tools.js";
+export function workbench() {
+    return {
+        id: "workbench",
+        features: componentFeatures,
+        apiVersion: 1,
+        version,
+        requires: { "local-runtime": version },
+        workers: { agent: new URL("./worker.js", import.meta.url) },
+        services() {
+            let dispose;
+            let stopUsage;
+            let stopExecution;
+            let stopPresentation;
+            return {
+                resident: {
+                    async start() {
+                        dispose = PushBridge.init();
+                        stopUsage = Usage.service();
+                        stopExecution = ExecutionService.init();
+                        stopPresentation = WorkbenchPresentation.init();
+                    },
+                    async stop() {
+                        stopPresentation?.();
+                        stopPresentation = undefined;
+                        await stopUsage?.();
+                        stopExecution?.();
+                        stopUsage = undefined;
+                        dispose?.();
+                        dispose = undefined;
+                        await PushBridge.flush();
+                    },
+                },
+            };
+        },
+        adapters: { cli: new URL("./cli-adapter.js", import.meta.url), http: new URL("./http.js", import.meta.url) },
+        register() {
+            BusEvent.register(...Object.values(Vcs.Event), ...Object.values(Ide.Event), ReviewState.Updated, ExecutionSchema.Updated, ExecutionSchema.ProjectionUpdated);
+            registerConfig();
+            registerProjectMigrations();
+            registerWorkbenchAgents();
+            registerProjectTools();
+            registerPresentationTools();
+            registerProjectStartup();
+            registerProjectSessionHealth();
+        },
+    };
+}

package/dist/config-schema.js

@@ -0,0 +1,265 @@
+import { ConfigDomain } from "@ericsanchezok/synergy-harness/config/domain";
+import z from "zod";
+import { ConfigExtensions } from "@ericsanchezok/synergy-harness/config/extensions";
+export const Keybinds = z
+    .object({
+    leader: z.string().optional().default("ctrl+x").describe("Leader key for keybind combinations"),
+    app_exit: z.string().optional().default("ctrl+c,ctrl+d,<leader>q").describe("Exit the application"),
+    editor_open: z.string().optional().default("<leader>e").describe("Open external editor"),
+    theme_list: z.string().optional().default("<leader>t").describe("List available themes"),
+    sidebar_toggle: z.string().optional().default("<leader>b").describe("Toggle sidebar"),
+    scrollbar_toggle: z.string().optional().default("none").describe("Toggle session scrollbar"),
+    username_toggle: z.string().optional().default("none").describe("Toggle username visibility"),
+    status_view: z.string().optional().default("<leader>s").describe("View status"),
+    session_export: z.string().optional().default("<leader>x").describe("Export session to editor"),
+    session_new: z.string().optional().default("<leader>n").describe("Create a new session"),
+    session_list: z.string().optional().default("<leader>l").describe("List all sessions"),
+    session_timeline: z.string().optional().default("<leader>g").describe("Show session timeline"),
+    session_fork: z.string().optional().default("none").describe("Fork session from message"),
+    session_rename: z.string().optional().default("none").describe("Rename session"),
+    session_interrupt: z.string().optional().default("escape").describe("Interrupt current session"),
+    session_compact: z.string().optional().default("<leader>c").describe("Compact the session"),
+    messages_page_up: z.string().optional().default("pageup").describe("Scroll messages up by one page"),
+    messages_page_down: z.string().optional().default("pagedown").describe("Scroll messages down by one page"),
+    messages_half_page_up: z.string().optional().default("ctrl+alt+u").describe("Scroll messages up by half page"),
+    messages_half_page_down: z.string().optional().default("ctrl+alt+d").describe("Scroll messages down by half page"),
+    messages_first: z.string().optional().default("ctrl+g,home").describe("Navigate to first message"),
+    messages_last: z.string().optional().default("ctrl+alt+g,end").describe("Navigate to last message"),
+    messages_next: z.string().optional().default("none").describe("Navigate to next message"),
+    messages_previous: z.string().optional().default("none").describe("Navigate to previous message"),
+    messages_last_user: z.string().optional().default("none").describe("Navigate to last user message"),
+    messages_copy: z.string().optional().default("<leader>y").describe("Copy message"),
+    messages_undo: z.string().optional().default("<leader>u").describe("Undo message history only"),
+    messages_redo: z.string().optional().default("<leader>r").describe("Redo message history only"),
+    messages_toggle_conceal: z
+        .string()
+        .optional()
+        .default("<leader>h")
+        .describe("Toggle code block concealment in messages"),
+    tool_details: z.string().optional().default("none").describe("Toggle tool details visibility"),
+    model_list: z.string().optional().default("<leader>m").describe("List available models"),
+    model_cycle_recent: z.string().optional().default("f2").describe("Next recently used model"),
+    model_cycle_recent_reverse: z.string().optional().default("shift+f2").describe("Previous recently used model"),
+    model_cycle_favorite: z.string().optional().default("none").describe("Next favorite model"),
+    model_cycle_favorite_reverse: z.string().optional().default("none").describe("Previous favorite model"),
+    command_list: z.string().optional().default("ctrl+p").describe("List available commands"),
+    agent_list: z.string().optional().default("<leader>a").describe("List agents"),
+    agent_cycle: z.string().optional().default("tab").describe("Next agent"),
+    agent_cycle_reverse: z.string().optional().default("shift+tab").describe("Previous agent"),
+    variant_cycle: z.string().optional().default("ctrl+t").describe("Cycle model variants"),
+    input_clear: z.string().optional().default("ctrl+c").describe("Clear input field"),
+    input_paste: z.string().optional().default("ctrl+v").describe("Paste from clipboard"),
+    input_submit: z.string().optional().default("return").describe("Submit input"),
+    input_newline: z
+        .string()
+        .optional()
+        .default("shift+return,ctrl+return,alt+return,ctrl+j")
+        .describe("Insert newline in input"),
+    input_move_left: z.string().optional().default("left,ctrl+b").describe("Move cursor left in input"),
+    input_move_right: z.string().optional().default("right,ctrl+f").describe("Move cursor right in input"),
+    input_move_up: z.string().optional().default("up").describe("Move cursor up in input"),
+    input_move_down: z.string().optional().default("down").describe("Move cursor down in input"),
+    input_select_left: z.string().optional().default("shift+left").describe("Select left in input"),
+    input_select_right: z.string().optional().default("shift+right").describe("Select right in input"),
+    input_select_up: z.string().optional().default("shift+up").describe("Select up in input"),
+    input_select_down: z.string().optional().default("shift+down").describe("Select down in input"),
+    input_line_home: z.string().optional().default("ctrl+a").describe("Move to start of line in input"),
+    input_line_end: z.string().optional().default("ctrl+e").describe("Move to end of line in input"),
+    input_select_line_home: z.string().optional().default("ctrl+shift+a").describe("Select to start of line in input"),
+    input_select_line_end: z.string().optional().default("ctrl+shift+e").describe("Select to end of line in input"),
+    input_visual_line_home: z.string().optional().default("alt+a").describe("Move to start of visual line in input"),
+    input_visual_line_end: z.string().optional().default("alt+e").describe("Move to end of visual line in input"),
+    input_select_visual_line_home: z
+        .string()
+        .optional()
+        .default("alt+shift+a")
+        .describe("Select to start of visual line in input"),
+    input_select_visual_line_end: z
+        .string()
+        .optional()
+        .default("alt+shift+e")
+        .describe("Select to end of visual line in input"),
+    input_buffer_home: z.string().optional().default("home").describe("Move to start of buffer in input"),
+    input_buffer_end: z.string().optional().default("end").describe("Move to end of buffer in input"),
+    input_select_buffer_home: z
+        .string()
+        .optional()
+        .default("shift+home")
+        .describe("Select to start of buffer in input"),
+    input_select_buffer_end: z.string().optional().default("shift+end").describe("Select to end of buffer in input"),
+    input_delete_line: z.string().optional().default("ctrl+shift+d").describe("Delete line in input"),
+    input_delete_to_line_end: z.string().optional().default("ctrl+k").describe("Delete to end of line in input"),
+    input_delete_to_line_start: z.string().optional().default("ctrl+u").describe("Delete to start of line in input"),
+    input_backspace: z.string().optional().default("backspace,shift+backspace").describe("Backspace in input"),
+    input_delete: z.string().optional().default("ctrl+d,delete,shift+delete").describe("Delete character in input"),
+    input_undo: z.string().optional().default("ctrl+-,super+z").describe("Undo in input"),
+    input_redo: z.string().optional().default("ctrl+.,super+shift+z").describe("Redo in input"),
+    input_word_forward: z
+        .string()
+        .optional()
+        .default("alt+f,alt+right,ctrl+right")
+        .describe("Move word forward in input"),
+    input_word_backward: z
+        .string()
+        .optional()
+        .default("alt+b,alt+left,ctrl+left")
+        .describe("Move word backward in input"),
+    input_select_word_forward: z
+        .string()
+        .optional()
+        .default("alt+shift+f,alt+shift+right")
+        .describe("Select word forward in input"),
+    input_select_word_backward: z
+        .string()
+        .optional()
+        .default("alt+shift+b,alt+shift+left")
+        .describe("Select word backward in input"),
+    input_delete_word_forward: z
+        .string()
+        .optional()
+        .default("alt+d,alt+delete,ctrl+delete")
+        .describe("Delete word forward in input"),
+    input_delete_word_backward: z
+        .string()
+        .optional()
+        .default("ctrl+w,ctrl+backspace,alt+backspace")
+        .describe("Delete word backward in input"),
+    history_previous: z.string().optional().default("up").describe("Previous history item"),
+    history_next: z.string().optional().default("down").describe("Next history item"),
+    session_child_cycle: z.string().optional().default("<leader>right").describe("Next child session"),
+    session_child_cycle_reverse: z.string().optional().default("<leader>left").describe("Previous child session"),
+    session_parent: z.string().optional().default("<leader>up").describe("Go to parent session"),
+    terminal_suspend: z.string().optional().default("ctrl+z").describe("Suspend terminal"),
+    terminal_title_toggle: z.string().optional().default("none").describe("Toggle terminal title"),
+    tips_toggle: z.string().optional().default("<leader>h").describe("Toggle tips on home screen"),
+})
+    .strict()
+    .meta({
+    ref: "KeybindsConfig",
+});
+export const Layout = z.enum(["auto", "stretch"]).meta({
+    ref: "LayoutConfig",
+});
+const QuickSwitcherModel = z
+    .object({
+    providerID: z.string().describe("Provider id for the quick switcher model preference"),
+    modelID: z.string().describe("Model id for the quick switcher model preference"),
+    state: z.enum(["add", "remove"]).describe("Whether to force-add or force-remove the model from the quick switcher"),
+})
+    .strict()
+    .meta({ ref: "QuickSwitcherModelConfig" });
+export const QuickSwitcher = z
+    .object({
+    models: z.array(QuickSwitcherModel).optional().describe("Per-model quick switcher visibility preferences"),
+})
+    .strict()
+    .meta({ ref: "QuickSwitcherConfig" });
+export const ConfigShape = {
+    locale: z.enum(["system", "en", "zh-CN"]).optional().describe("UI locale (system = follow OS, default: system)"),
+    theme: z.string().optional().describe("Theme name to use for the interface"),
+    activityDisplay: z
+        .enum(["full", "balanced", "minimal"])
+        .optional()
+        .describe("Execution process detail: full = expanded process, balanced = current stage with completed process collapsed, minimal = compact progress. All modes use the same process view (default: balanced)"),
+    defaultSessionWorkspace: z
+        .enum(["main", "worktree"])
+        .optional()
+        .describe("Default workspace for new sessions started from the Web composer: main = run in the main checkout, " +
+        "worktree = start each new session in an isolated git worktree (default: main). " +
+        "Programmatic session creation (API, channels, Cortex) always uses the main checkout."),
+    defaultSessionEnvironmentProfile: z
+        .string()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe("Execution profile for new Web/Desktop composer sessions. Omitted follows the global resource default; null disables execution selection. References an existing global profile without defining hosts or credentials."),
+    keybinds: Keybinds.optional().describe("Custom keybind configurations"),
+    compactReasoning: z
+        .boolean()
+        .optional()
+        .describe("Show a compact reasoning preview in the execution process (default: false)"),
+    preferWorkBrief: z
+        .boolean()
+        .optional()
+        .describe("Prefer a tool call's purpose description over its action and target when available (default: false)"),
+    quick_switcher: QuickSwitcher.optional().describe("Quick switcher model visibility preferences"),
+    welcomeGames: z
+        .boolean()
+        .optional()
+        .describe("Show interactive games on the new-task greeting (default: true). Set false to render a plain greeting."),
+    layout: Layout.optional().describe("@deprecated Always uses stretch layout."),
+    toast: z
+        .object({
+        muted: z
+            .array(z.enum(["info", "success", "warning", "error"]))
+            .optional()
+            .describe("Toast types to suppress. The underlying logic still runs but the visual card is not rendered."),
+        durationOverrides: z
+            .record(z.enum(["info", "success", "warning", "error"]), z.number().int().positive().max(30000))
+            .optional()
+            .describe("Override auto-dismiss duration in ms per toast type (max 30s)."),
+    })
+        .strict()
+        .optional()
+        .describe("Toast notification preferences"),
+};
+const contribution = {
+    shape: ConfigShape,
+    references(raw, providerID) {
+        const config = raw;
+        return (config.quick_switcher?.models ?? []).flatMap((model, index) => model.providerID === providerID ? [`quick_switcher.models[${index}]`] : []);
+    },
+    normalize(raw) {
+        const result = raw;
+        if (result.activityDisplay === undefined)
+            result.activityDisplay = "balanced";
+        if (result.compactReasoning === undefined)
+            result.compactReasoning = false;
+        if (result.preferWorkBrief === undefined)
+            result.preferWorkBrief = false;
+        if (!result.keybinds)
+            result.keybinds = Keybinds.parse({});
+    },
+};
+export function registerConfig() {
+    ConfigExtensions.register("workbench", contribution);
+    for (const domain of [
+        {
+            id: "general",
+            filename: "00-general.jsonc",
+            label: "General",
+            ownedKeys: [
+                "theme",
+                "keybinds",
+                "toast",
+                "compactReasoning",
+                "preferWorkBrief",
+                "welcomeGames",
+                "locale",
+                "activityDisplay",
+                "defaultSessionWorkspace",
+                "defaultSessionEnvironmentProfile",
+                "layout",
+            ],
+            mergePolicy: "merge",
+            reloadTargets: ["config"],
+            uiSection: "general",
+            importable: true,
+        },
+        {
+            id: "models",
+            filename: "10-models.jsonc",
+            label: "Models",
+            ownedKeys: ["quick_switcher"],
+            mergePolicy: "merge",
+            reloadTargets: ["config"],
+            uiSection: "models",
+            importable: true,
+        },
+    ])
+        ConfigDomain.register(domain);
+}
+export async function readConfig() {
+    const { Config } = await import("@ericsanchezok/synergy-harness/config/config");
+    return Config.current();
+}

package/dist/execution/activity.js

@@ -0,0 +1,78 @@
+export var ExecutionActivity;
+(function (ExecutionActivity) {
+    function project(rows, root) {
+        const byID = new Map(rows.map((node) => [node.id, node]));
+        const requests = new Set(rows.filter((node) => node.evidenceKind === "attempt").map((node) => node.parentID));
+        const instructions = new Set(rows.filter((node) => node.kind === "subtask").map((node) => node.sessionID + ":" + node.runID));
+        const nodes = rows
+            .filter((node) => node.kind === "subtask" ||
+            node.kind === "tool" ||
+            (node.kind === "input" &&
+                (node.sessionID === root || !instructions.has(node.sessionID + ":" + node.runID))) ||
+            node.evidenceKind === "attempt" ||
+            (node.evidenceKind === "call" && !requests.has(node.id)))
+            .map((node, index) => ({
+            ...node,
+            activity: {
+                index,
+                count: 1,
+                endIndex: index,
+                instruction: node.kind === "subtask" || (node.kind === "input" && node.sessionID !== root),
+            },
+        }));
+        const segments = [];
+        for (const node of nodes) {
+            let ancestor = node;
+            const seen = new Set();
+            while (ancestor && ancestor.sessionID !== root && ancestor.parentID && !seen.has(ancestor.id)) {
+                seen.add(ancestor.id);
+                ancestor = byID.get(ancestor.parentID);
+            }
+            const runID = ancestor?.sessionID === root ? ancestor.runID : null;
+            const last = segments.at(-1);
+            if (last?.runID === runID) {
+                last.to = node.activity.index;
+                last.count++;
+            }
+            else
+                segments.push({ runID, from: node.activity.index, to: node.activity.index, count: 1, rounds: 1 });
+        }
+        const chunks = [];
+        const size = Math.max(1, Math.ceil(segments.length / 160));
+        for (let index = 0; index < segments.length; index += size) {
+            const values = segments.slice(index, index + size);
+            chunks.push({
+                runID: values.length === 1 ? values[0].runID : null,
+                from: values[0].from,
+                to: values.at(-1).to,
+                count: values.reduce((sum, value) => sum + value.count, 0),
+                rounds: new Set(values.map((value) => value.runID)).size,
+            });
+        }
+        return {
+            nodes,
+            segments: chunks,
+            humanInputs: nodes.filter((node) => node.kind === "input" && !node.activity.instruction).length,
+            taskInstructions: nodes.filter((node) => node.activity.instruction).length,
+        };
+    }
+    ExecutionActivity.project = project;
+    function aggregate(nodes, kind) {
+        const lane = nodes.filter((node) => kind === "input"
+            ? node.kind === "input" || node.kind === "subtask"
+            : kind === "model"
+                ? node.evidenceKind === "call" || node.evidenceKind === "attempt"
+                : node.kind === "tool");
+        const size = Math.max(1, Math.ceil(lane.length / 160));
+        const result = [];
+        for (let index = 0; index < lane.length; index += size) {
+            const bucket = lane.slice(index, index + size);
+            result.push({
+                ...bucket[0],
+                activity: { ...bucket[0].activity, count: bucket.length, endIndex: bucket.at(-1).activity.index },
+            });
+        }
+        return result;
+    }
+    ExecutionActivity.aggregate = aggregate;
+})(ExecutionActivity || (ExecutionActivity = {}));