@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/swarm.js

@@ -0,0 +1,328 @@
+export const SWARM_STATUSES = [
+    "draft",
+    "planning",
+    "researching",
+    "awaiting_approval",
+    "building",
+    "paused",
+    "stopped",
+    "done",
+    "failed",
+];
+/** Statuses where the runner schedules agent cycles. */
+export const ACTIVE_SWARM_STATUSES = ["planning", "researching", "building"];
+export const TERMINAL_SWARM_STATUSES = ["stopped", "done", "failed"];
+export const SWARM_ROLES = [
+    "orchestrator",
+    "researcher",
+    "critic",
+    "ranker",
+    "synthesizer",
+    "verifier",
+    "engineer",
+    "integrator",
+];
+/** Roles that write code and can only be spawned in the build phase. */
+export const REPO_ROLES = ["engineer", "integrator"];
+export const WORKER_ROLES = SWARM_ROLES.filter((role) => role !== "orchestrator");
+export const SWARM_TASK_STATUSES = [
+    "pending",
+    "claimed",
+    "done",
+    "failed",
+    "cancelled",
+];
+export const SWARM_TASK_KINDS = [
+    "research",
+    "critique",
+    "rank",
+    "synthesize",
+    "verify",
+    "build",
+    "integrate",
+];
+export const SWARM_POST_KINDS = [
+    "finding",
+    "question",
+    "answer",
+    "proposal",
+    "critique",
+    "decision",
+    "directive",
+    "progress",
+];
+export const SWARM_BASE_CHANNELS = ["plan", "findings", "questions", "decisions"];
+export const SWARM_HYPOTHESIS_STATUSES = [
+    "proposed",
+    "promoted",
+    "rejected",
+];
+export const SWARM_CRITIQUE_VERDICTS = ["support", "refute", "needs_evidence"];
+export const SWARM_ARTIFACT_KINDS = [
+    "report",
+    "design",
+    "notes",
+    "benchmark",
+    "data",
+    "code_ref",
+    "other",
+];
+export const DEFAULT_SWARM_BUDGET_USD = 25;
+export const MAX_SWARM_BUDGET_USD = 2000;
+export const DEFAULT_SWARM_DEADLINE_HOURS = 24;
+export const MAX_SWARM_DEADLINE_HOURS = 24 * 14;
+export const DEFAULT_SWARM_MAX_WORKERS = 5;
+export const MAX_SWARM_WORKERS = 8;
+export const DEFAULT_SWARM_MAX_RUNNING = 3;
+export const MAX_SWARM_RUNNING = 6;
+export const DEFAULT_SWARM_MAX_CYCLES = 200;
+export const MAX_SWARM_CYCLES = 2000;
+export const SWARM_STALL_LIMIT = 2;
+export const SWARM_IDLE_ORCHESTRATOR_LIMIT = 3;
+export const SWARM_MIN_CRITIQUED_HYPOTHESES = 4;
+export const SWARM_BUDGET_WARN_RATIO = 0.8;
+export const MAX_SWARM_TITLE = 160;
+export const MAX_SWARM_GOAL = 12_000;
+export const MAX_SWARM_POST = 8_000;
+export const MAX_SWARM_NOTES = 12_000;
+export const MAX_SWARM_TASK_SPEC = 4_000;
+export const MAX_SWARM_LEDGER_FIELD = 12_000;
+export const MAX_SWARM_ARTIFACT = 200_000;
+export const MAX_SWARM_BRIEF = 3_000;
+export const SWARM_ELO_START = 1200;
+export const SWARM_ELO_K = 32;
+function includes(list, value) {
+    return typeof value === "string" && list.includes(value);
+}
+export const isSwarmStatus = (v) => includes(SWARM_STATUSES, v);
+export const isSwarmRole = (v) => includes(SWARM_ROLES, v);
+export const isSwarmTaskKind = (v) => includes(SWARM_TASK_KINDS, v);
+export const isSwarmTaskStatus = (v) => includes(SWARM_TASK_STATUSES, v);
+export const isSwarmPostKind = (v) => includes(SWARM_POST_KINDS, v);
+export const isSwarmArtifactKind = (v) => includes(SWARM_ARTIFACT_KINDS, v);
+export const isSwarmCritiqueVerdict = (v) => includes(SWARM_CRITIQUE_VERDICTS, v);
+export const isSwarmHypothesisStatus = (v) => includes(SWARM_HYPOTHESIS_STATUSES, v);
+export function isActiveSwarmStatus(status) {
+    return ACTIVE_SWARM_STATUSES.includes(status);
+}
+export function isTerminalSwarmStatus(status) {
+    return TERMINAL_SWARM_STATUSES.includes(status);
+}
+export function canStartSwarm(status) {
+    return status === "draft";
+}
+export function canPauseSwarm(status) {
+    return isActiveSwarmStatus(status) || status === "awaiting_approval";
+}
+export function canResumeSwarm(status) {
+    return status === "paused";
+}
+export function canStopSwarm(status) {
+    return !isTerminalSwarmStatus(status);
+}
+export function isSwarmChannel(value) {
+    if (typeof value !== "string")
+        return false;
+    if (SWARM_BASE_CHANNELS.includes(value))
+        return true;
+    return /^task:[A-Za-z0-9_-]{4,40}$/.test(value);
+}
+export function roleNeedsRepo(role) {
+    return REPO_ROLES.includes(role);
+}
+/** When the human attached a repo, every agent gets a checkout so they can read it. */
+export function swarmAgentUsesRepo(swarm, _role) {
+    return Boolean(swarm.repoUrl);
+}
+/** Engineers / integrators only exist once the research report is approved. */
+export function roleAllowedInPhase(role, phase) {
+    if (role === "orchestrator")
+        return false;
+    if (roleNeedsRepo(role))
+        return phase === "build";
+    return true;
+}
+export function canEditSwarm(swarm, actor) {
+    if (swarm.creatorId === actor.userId)
+        return true;
+    return actor.orgRole === "owner" || actor.orgRole === "admin";
+}
+function clampNumber(raw, min, max, fallback) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(max, Math.max(min, n));
+}
+export function clampSwarmBudgetUsd(raw) {
+    return Math.round(clampNumber(raw, 1, MAX_SWARM_BUDGET_USD, DEFAULT_SWARM_BUDGET_USD) * 100) / 100;
+}
+export function clampSwarmDeadlineHours(raw) {
+    return clampNumber(raw, 1, MAX_SWARM_DEADLINE_HOURS, DEFAULT_SWARM_DEADLINE_HOURS);
+}
+export function clampSwarmMaxWorkers(raw) {
+    return Math.round(clampNumber(raw, 1, MAX_SWARM_WORKERS, DEFAULT_SWARM_MAX_WORKERS));
+}
+export function clampSwarmMaxRunning(raw) {
+    return Math.round(clampNumber(raw, 1, MAX_SWARM_RUNNING, DEFAULT_SWARM_MAX_RUNNING));
+}
+export function clampSwarmMaxCycles(raw) {
+    return Math.round(clampNumber(raw, 5, MAX_SWARM_CYCLES, DEFAULT_SWARM_MAX_CYCLES));
+}
+export function nextEloRatings(ratingA, ratingB, outcome, k = SWARM_ELO_K) {
+    const expectedA = 1 / (1 + 10 ** ((ratingB - ratingA) / 400));
+    const scoreA = outcome === "a" ? 1 : outcome === "b" ? 0 : 0.5;
+    const delta = k * (scoreA - expectedA);
+    const round = (n) => Math.round(n * 10) / 10;
+    return { a: round(ratingA + delta), b: round(ratingB - delta) };
+}
+/** Hard limits the runner enforces before starting any cycle. */
+export function evaluateSwarmLimits(state, now) {
+    if (state.spentUsd >= state.budgetUsd)
+        return { action: "pause", reason: "budget" };
+    if (state.deadlineAt !== null && now >= state.deadlineAt) {
+        return { action: "stop", reason: "deadline" };
+    }
+    if (state.cyclesDone >= state.maxCycles)
+        return { action: "stop", reason: "max_cycles" };
+    return { action: "continue" };
+}
+export function shouldWarnBudget(spentUsd, budgetUsd) {
+    return budgetUsd > 0 && spentUsd >= budgetUsd * SWARM_BUDGET_WARN_RATIO;
+}
+/** A swarm may only finish with a report, enough vetted ideas, and a passing verifier. */
+export function evaluateDoneGate(input) {
+    const missing = [];
+    const minCritiqued = input.minCritiquedHypotheses ?? SWARM_MIN_CRITIQUED_HYPOTHESES;
+    if (!input.hasReport)
+        missing.push("a `report` artifact from the synthesizer");
+    if (input.critiquedHypotheses < minCritiqued) {
+        missing.push(`at least ${minCritiqued} critiqued hypotheses (have ${input.critiquedHypotheses})`);
+    }
+    if (input.latestVerificationPassed !== true) {
+        missing.push("a passing verify_result from the verifier after the latest report");
+    }
+    if (input.phase === "build" && input.openBuildTasks > 0) {
+        missing.push(`${input.openBuildTasks} build task(s) still open`);
+    }
+    return { ok: missing.length === 0, missing };
+}
+export function taskDependenciesMet(task, byId) {
+    return task.blockedBy.every((id) => byId.get(id)?.status === "done");
+}
+export function taskMatchesRole(task, role) {
+    if (task.roleHint)
+        return task.roleHint === role;
+    switch (task.kind) {
+        case "research":
+            return role === "researcher";
+        case "critique":
+            return role === "critic";
+        case "rank":
+            return role === "ranker";
+        case "synthesize":
+            return role === "synthesizer";
+        case "verify":
+            return role === "verifier";
+        case "build":
+            return role === "engineer";
+        case "integrate":
+            return role === "integrator";
+    }
+}
+export function extractMentions(body) {
+    const out = new Set();
+    for (const match of body.matchAll(/(^|\s)@([A-Za-z0-9][A-Za-z0-9_-]{0,39})/g)) {
+        out.add(match[2].toLowerCase());
+    }
+    return [...out];
+}
+export function slugifySwarmLabel(raw, fallback = "agent") {
+    const slug = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32);
+    return slug || fallback;
+}
+export function swarmTitleFromGoal(goal) {
+    const firstLine = goal.trim().split(/\n/)[0] || "Swarm";
+    const clean = firstLine.replace(/\s+/g, " ").trim();
+    return clean.length > 80 ? `${clean.slice(0, 77).trimEnd()}…` : clean;
+}
+/** Compact label for a swarm's stored Cursor model id (no catalog required). */
+export function formatSwarmModelLabel(modelId) {
+    const id = (modelId ?? "").trim();
+    if (!id || id === "auto")
+        return "Auto";
+    const leaf = id.includes("/") ? id.split("/").pop() || id : id;
+    return leaf.length > 28 ? `${leaf.slice(0, 26).trimEnd()}…` : leaf;
+}
+function clip(text, max) {
+    const t = text.trim();
+    return t.length > max ? `${t.slice(0, max - 1).trimEnd()}…` : t;
+}
+/**
+ * Deterministic board digest injected into every cycle prompt. Agents get the
+ * decisions, directives, and anything addressed to them — not the whole board.
+ */
+export function buildBoardDigest(input) {
+    const maxChars = input.maxChars ?? 9_000;
+    const labelLc = input.agentLabel.toLowerCase();
+    const sorted = [...input.posts].sort((a, b) => a.createdAt - b.createdAt);
+    const directives = sorted
+        .filter((p) => p.kind === "directive" || p.channel === "plan")
+        .slice(-6);
+    const decisions = sorted.filter((p) => p.kind === "decision").slice(-5);
+    const forMe = sorted
+        .filter((p) => p.createdAt > input.since &&
+        (p.mentions.includes(input.agentId) || p.mentions.includes(labelLc)))
+        .slice(-8);
+    const fresh = sorted
+        .filter((p) => p.createdAt > input.since &&
+        (p.kind === "finding" || p.kind === "critique" || p.kind === "proposal"))
+        .slice(-10);
+    const openQuestions = sorted
+        .filter((p) => p.kind === "question" && p.createdAt > input.since)
+        .slice(-5);
+    const line = (p, max = 420) => `- [${p.kind} · #${p.channel} · ${p.authorLabel}] ${clip(p.bodyMd.replace(/\s+/g, " "), max)} (post ${p.id})`;
+    const sections = [];
+    sections.push(`### Team\n${input.agents
+        .filter((a) => a.status !== "retired")
+        .map((a) => `- @${a.label} — ${a.role}${a.id === input.agentId ? " (you)" : ""} · ${a.status}`)
+        .join("\n")}`);
+    if (directives.length) {
+        sections.push(`### Current directives\n${directives.map((p) => line(p, 600)).join("\n")}`);
+    }
+    if (decisions.length) {
+        sections.push(`### Decisions\n${decisions.map((p) => line(p)).join("\n")}`);
+    }
+    if (forMe.length) {
+        sections.push(`### Addressed to you\n${forMe.map((p) => line(p, 600)).join("\n")}`);
+    }
+    if (fresh.length) {
+        sections.push(`### New since your last cycle\n${fresh.map((p) => line(p)).join("\n")}`);
+    }
+    if (openQuestions.length) {
+        sections.push(`### Open questions\n${openQuestions.map((p) => line(p)).join("\n")}`);
+    }
+    const top = [...input.hypotheses]
+        .filter((h) => h.status !== "rejected")
+        .sort((a, b) => b.elo - a.elo)
+        .slice(0, 8);
+    if (top.length) {
+        sections.push(`### Hypothesis leaderboard\n${top
+            .map((h, i) => `${i + 1}. ${clip(h.title, 140)} — Elo ${Math.round(h.elo)}, ${h.critiques} critique(s) (${h.id})`)
+            .join("\n")}`);
+    }
+    const openTasks = input.tasks.filter((t) => t.status === "pending" || t.status === "claimed");
+    if (openTasks.length) {
+        sections.push(`### Open tasks\n${openTasks
+            .slice(0, 14)
+            .map((t) => `- ${t.id} [${t.kind} · ${t.status}${t.ownerAgentId === input.agentId ? " · yours" : ""}] ${clip(t.title, 140)}`)
+            .join("\n")}`);
+    }
+    let out = sections.join("\n\n");
+    if (out.length > maxChars)
+        out = `${out.slice(0, maxChars - 40).trimEnd()}\n…(digest truncated — call board_read)`;
+    return out;
+}

package/dist/shared/swarmVisual.d.ts

@@ -0,0 +1,79 @@
+import { type SwarmAgentInfo, type SwarmAgentStatus, type SwarmRole, type SwarmTaskInfo, type SwarmTaskKind, type SwarmTaskStatus } from "./swarm";
+export type SwarmVisualStatus = "idle" | "working" | "dead" | "error";
+export declare const ROLE_HEX: Record<SwarmRole, string>;
+/** Deeper role colors for the light theme (the pastels above wash out on white). */
+export declare const ROLE_HEX_LIGHT: Record<SwarmRole, string>;
+export type SwarmSceneTheme = "light" | "dark";
+export declare function roleHex(role: SwarmRole, theme?: SwarmSceneTheme): string;
+export declare const ROLE_FLOORS: Record<SwarmRole, {
+    y: number;
+    z: number;
+    xBias: number;
+    label: string;
+}>;
+export declare const WORK_BOARD: {
+    y: number;
+    z: number;
+    x: number;
+};
+export type Vec3 = [number, number, number];
+export declare const ZERO_VEC: Vec3;
+export declare function addVec(a: Vec3, b: Vec3): Vec3;
+export interface SwarmVisualAgentNode {
+    id: string;
+    kind: "agent";
+    role: SwarmRole;
+    label: string;
+    brief: string;
+    status: SwarmAgentStatus;
+    visualStatus: SwarmVisualStatus;
+    spawnedBy: string | null;
+    currentTaskId: string | null;
+    taskTitle: string | null;
+    position: Vec3;
+    scale: number;
+}
+export interface SwarmVisualWorkNode {
+    id: string;
+    kind: "work";
+    title: string;
+    taskKind: SwarmTaskKind;
+    status: SwarmTaskStatus;
+    ownerAgentId: string | null;
+    position: Vec3;
+}
+export interface SwarmVisualEdge {
+    id: string;
+    type: "spawn" | "work";
+    from: string;
+    to: string;
+}
+export interface SwarmVisualFloor {
+    role: SwarmRole;
+    label: string;
+    center: Vec3;
+    width: number;
+    depth: number;
+}
+export interface SwarmVisualGraph {
+    agents: SwarmVisualAgentNode[];
+    work: SwarmVisualWorkNode[];
+    edges: SwarmVisualEdge[];
+    floors: SwarmVisualFloor[];
+}
+export declare function visualStatusFor(status: SwarmAgentStatus): SwarmVisualStatus;
+export declare function agentVisibleInGraph(agent: Pick<SwarmAgentInfo, "status" | "createdAt" | "role">, opts?: {
+    includeRetired?: boolean;
+    asOf?: number | null;
+}): boolean;
+export declare function replayCast(agents: SwarmAgentInfo[], opts?: {
+    includeRetired?: boolean;
+}): SwarmAgentInfo[];
+/** Perlin smootherstep — slow in and out, no linear snap. */
+export declare function smootherstep(t: number): number;
+export declare function buildSwarmVisualGraph(input: {
+    agents: SwarmAgentInfo[];
+    tasks: SwarmTaskInfo[];
+    includeRetired?: boolean;
+    asOf?: number | null;
+}): SwarmVisualGraph;

package/dist/shared/swarmVisual.js

@@ -0,0 +1,212 @@
+import { SWARM_ROLES, } from "./swarm";
+export const ROLE_HEX = {
+    orchestrator: "#f0c674",
+    researcher: "#8ec5ff",
+    critic: "#f59e9e",
+    ranker: "#c4a7ff",
+    synthesizer: "#7ee2c4",
+    verifier: "#3ecf8e",
+    engineer: "#f7a86b",
+    integrator: "#f7d56b",
+};
+/** Deeper role colors for the light theme (the pastels above wash out on white). */
+export const ROLE_HEX_LIGHT = {
+    orchestrator: "#c48a12",
+    researcher: "#2f7fd1",
+    critic: "#d4525a",
+    ranker: "#7c5cd6",
+    synthesizer: "#159b77",
+    verifier: "#17a34a",
+    engineer: "#dd6f24",
+    integrator: "#b8930a",
+};
+export function roleHex(role, theme = "dark") {
+    return (theme === "light" ? ROLE_HEX_LIGHT : ROLE_HEX)[role];
+}
+export const ROLE_FLOORS = {
+    orchestrator: { y: 5.2, z: -3.1, xBias: 0, label: "Orchestrator" },
+    researcher: { y: 3.35, z: -0.7, xBias: -3.6, label: "Research" },
+    critic: { y: 2.15, z: 0.55, xBias: 0.15, label: "Critique" },
+    ranker: { y: 1.35, z: 0.15, xBias: 3.35, label: "Rank" },
+    synthesizer: { y: 0.35, z: 2.05, xBias: -1.35, label: "Synthesize" },
+    verifier: { y: -0.25, z: 2.25, xBias: 2.15, label: "Verify" },
+    engineer: { y: -1.45, z: 1.35, xBias: 5.15, label: "Build" },
+    integrator: { y: -1.45, z: 2.45, xBias: 6.45, label: "Integrate" },
+};
+export const WORK_BOARD = { y: -2.35, z: 4.35, x: 0 };
+export const ZERO_VEC = [0, 0, 0];
+export function addVec(a, b) {
+    return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
+export function visualStatusFor(status) {
+    if (status === "running")
+        return "working";
+    if (status === "retired")
+        return "dead";
+    if (status === "error")
+        return "error";
+    return "idle";
+}
+export function agentVisibleInGraph(agent, opts = {}) {
+    if (opts.asOf != null && agent.createdAt > opts.asOf)
+        return false;
+    if (agent.role === "orchestrator")
+        return true;
+    if (!opts.includeRetired && agent.status === "retired")
+        return false;
+    return true;
+}
+export function replayCast(agents, opts = {}) {
+    return agents
+        .filter((agent) => agentVisibleInGraph(agent, { includeRetired: opts.includeRetired, asOf: null }))
+        .slice()
+        .sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+}
+/** Perlin smootherstep — slow in and out, no linear snap. */
+export function smootherstep(t) {
+    const x = Math.min(1, Math.max(0, t));
+    return x * x * x * (x * (x * 6 - 15) + 10);
+}
+function layoutAgents(agents) {
+    const byRole = new Map();
+    for (const role of SWARM_ROLES)
+        byRole.set(role, []);
+    for (const agent of agents) {
+        (byRole.get(agent.role) ?? []).push(agent);
+    }
+    const positions = new Map();
+    for (const role of SWARM_ROLES) {
+        const lane = ROLE_FLOORS[role];
+        const list = (byRole.get(role) ?? [])
+            .slice()
+            .sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+        const n = list.length;
+        list.forEach((agent, i) => {
+            const x = lane.xBias + (i - (n - 1) / 2) * 1.55;
+            const z = lane.z + (i % 2 === 0 ? 0 : 0.32);
+            positions.set(agent.id, [x, lane.y, z]);
+        });
+    }
+    return positions;
+}
+function floorsFor(agents) {
+    const floors = [];
+    for (const role of SWARM_ROLES) {
+        const nodes = agents.filter((a) => a.role === role);
+        if (!nodes.length)
+            continue;
+        const xs = nodes.map((n) => n.position[0]);
+        const zs = nodes.map((n) => n.position[2]);
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minZ = Math.min(...zs);
+        const maxZ = Math.max(...zs);
+        const padX = role === "orchestrator" ? 1.6 : 1.25;
+        const padZ = role === "orchestrator" ? 1.3 : 1.05;
+        floors.push({
+            role,
+            label: ROLE_FLOORS[role].label,
+            center: [(minX + maxX) / 2, ROLE_FLOORS[role].y - 0.02, (minZ + maxZ) / 2],
+            width: Math.max(2.2, maxX - minX + padX * 2),
+            depth: Math.max(1.6, maxZ - minZ + padZ * 2),
+        });
+    }
+    return floors;
+}
+function workPositions(count) {
+    const cols = Math.min(4, Math.max(1, count));
+    const rows = Math.ceil(count / cols);
+    return Array.from({ length: count }, (_, i) => {
+        const col = i % cols;
+        const row = Math.floor(i / cols);
+        const x = WORK_BOARD.x + (col - (cols - 1) / 2) * 1.85;
+        const z = WORK_BOARD.z + (row - (rows - 1) / 2) * 1.15;
+        return [x, WORK_BOARD.y, z];
+    });
+}
+export function buildSwarmVisualGraph(input) {
+    const layoutPool = replayCast(input.agents, { includeRetired: input.includeRetired });
+    const visible = input.agents
+        .filter((agent) => agentVisibleInGraph(agent, input))
+        .slice()
+        .sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id));
+    const visibleIds = new Set(visible.map((a) => a.id));
+    const positions = layoutAgents(layoutPool);
+    const taskById = new Map(input.tasks.map((t) => [t.id, t]));
+    const agents = visible.map((agent) => {
+        const current = agent.currentTaskId ? taskById.get(agent.currentTaskId) : undefined;
+        const owned = input.tasks.find((t) => t.ownerAgentId === agent.id && t.status !== "cancelled");
+        return {
+            id: agent.id,
+            kind: "agent",
+            role: agent.role,
+            label: agent.label,
+            brief: agent.brief,
+            status: agent.status,
+            visualStatus: visualStatusFor(agent.status),
+            spawnedBy: agent.spawnedBy,
+            currentTaskId: agent.currentTaskId,
+            taskTitle: current?.title ?? owned?.title ?? null,
+            position: positions.get(agent.id) ?? [0, 0, 0],
+            scale: agent.role === "orchestrator" ? 1.45 : 1,
+        };
+    });
+    const workSource = input.tasks.filter((task) => {
+        if (task.status === "cancelled")
+            return false;
+        if (task.ownerAgentId && visibleIds.has(task.ownerAgentId))
+            return true;
+        return visible.some((a) => a.currentTaskId === task.id);
+    });
+    const ranked = workSource
+        .slice()
+        .sort((a, b) => {
+        const rank = (t) => t.status === "claimed" ? 0 : visible.some((agent) => agent.currentTaskId === t.id) ? 1 : 2;
+        return rank(a) - rank(b) || b.updatedAt - a.updatedAt;
+    })
+        .slice(0, 12);
+    const spots = workPositions(ranked.length);
+    const work = ranked.map((task, i) => ({
+        id: task.id,
+        kind: "work",
+        title: task.title,
+        taskKind: task.kind,
+        status: task.status,
+        ownerAgentId: task.ownerAgentId,
+        position: spots[i] ?? [WORK_BOARD.x, WORK_BOARD.y, WORK_BOARD.z],
+    }));
+    const workIds = new Set(work.map((node) => node.id));
+    const orch = agents.find((a) => a.role === "orchestrator");
+    const edges = [];
+    for (const agent of agents) {
+        if (agent.role === "orchestrator")
+            continue;
+        const parent = (agent.spawnedBy && visibleIds.has(agent.spawnedBy) && agent.spawnedBy) || orch?.id || null;
+        if (!parent)
+            continue;
+        edges.push({
+            id: `spawn:${parent}:${agent.id}`,
+            type: "spawn",
+            from: parent,
+            to: agent.id,
+        });
+    }
+    const seenWork = new Set();
+    const addWork = (from, to) => {
+        const id = `work:${from}:${to}`;
+        if (seenWork.has(id) || !workIds.has(to) || !visibleIds.has(from))
+            return;
+        seenWork.add(id);
+        edges.push({ id, type: "work", from, to });
+    };
+    for (const agent of agents) {
+        if (agent.currentTaskId)
+            addWork(agent.id, agent.currentTaskId);
+    }
+    for (const node of work) {
+        if (node.ownerAgentId && (node.status === "claimed" || node.status === "done")) {
+            addWork(node.ownerAgentId, node.id);
+        }
+    }
+    return { agents, work, edges, floors: floorsFor(agents) };
+}

package/dist/shared/terminalFilter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Filter terminal noise that pollutes shared Cursor Agent sessions.
+ *
+ * xterm.js answers Device Attribute / cursor-position queries via onData.
+ * Those replies must not be forwarded to the PTY — but real input
+ * (arrows, PageUp/Down, mouse wheel, typed text) must pass through.
+ */
+/** DA / CPR / focus replies xterm emits — never forward these to the PTY. */
+export declare function isTerminalAutoReply(data: string): boolean;
+/** SGR / legacy mouse reports (including wheel buttons 64/65). */
+export declare function isMouseSequence(data: string): boolean;
+/** Strip leaked DA gibberish from output shown in the browser. */
+export declare function sanitizeTerminalOutput(data: string): string;

package/dist/shared/terminalFilter.js

@@ -0,0 +1,46 @@
+/**
+ * Filter terminal noise that pollutes shared Cursor Agent sessions.
+ *
+ * xterm.js answers Device Attribute / cursor-position queries via onData.
+ * Those replies must not be forwarded to the PTY — but real input
+ * (arrows, PageUp/Down, mouse wheel, typed text) must pass through.
+ */
+/** DA / CPR / focus replies xterm emits — never forward these to the PTY. */
+export function isTerminalAutoReply(data) {
+    if (!data)
+        return true;
+    // Primary / secondary DA: ESC [ ? … c  |  ESC [ > … c  |  ESC [ … c
+    if (/^\x1b\[\??[\d;]*c$/.test(data))
+        return true;
+    if (/^\x1b\[>[\d;]*c$/.test(data))
+        return true;
+    // Cursor Position Report: ESC [ row ; col R
+    if (/^\x1b\[\d+;\d+R$/.test(data))
+        return true;
+    // Device Status Report reply
+    if (/^\x1b\[\d*n$/.test(data))
+        return true;
+    // Focus in / out
+    if (data === "\x1b[I" || data === "\x1b[O")
+        return true;
+    // Bare non-printable controls (keep TAB/LF/CR — those are real input)
+    if (/^[\x00-\x08\x0b\x0c\x0e-\x1a\x1c-\x1f]+$/.test(data))
+        return true;
+    return false;
+}
+/** SGR / legacy mouse reports (including wheel buttons 64/65). */
+export function isMouseSequence(data) {
+    return (/^\x1b\[<[\d;]*[Mm]$/.test(data) ||
+        /^\x1b\[M.{3}$/.test(data));
+}
+/** Visible DA/DA2 garbage that already leaked into scrollback. */
+const VISIBLE_DA_GARBAGE = /(?:\x1b)?(?:\[>?[\d;]*c|\[\?[\d;]*c|\[>[\d;]+c)+/g;
+/** OSC / CSI fragments that sometimes render literally. */
+const LITERAL_CSI_NOISE = /(?:direct)?(?:\[>?[\d;]*c)+/gi;
+/** Strip leaked DA gibberish from output shown in the browser. */
+export function sanitizeTerminalOutput(data) {
+    return data
+        .replace(VISIBLE_DA_GARBAGE, "")
+        .replace(LITERAL_CSI_NOISE, "")
+        .replace(/(?:\[>?[\d;]*c){2,}/g, "");
+}