@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/space.js

@@ -0,0 +1,54 @@
+/**
+ * Space metadata carried on chat messages (`ChatMessage.space`).
+ *
+ * Stored as one JSON column so new Space features (reactions, pins, …) can
+ * add fields here without another schema migration. Keep this file free of
+ * runtime imports — the web bundler can't resolve "./x.js" between shared/
+ * files.
+ */
+const ID_RE = /^[\w-]{1,64}$/;
+function cleanId(value) {
+    return typeof value === "string" && ID_RE.test(value) ? value : undefined;
+}
+/** Validate untrusted client input; drops anything malformed. */
+export function sanitizeSpaceMeta(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const raw = input;
+    const meta = {};
+    if (raw.origin === "space" || raw.origin === "agent")
+        meta.origin = raw.origin;
+    const threadId = cleanId(raw.threadId);
+    if (threadId)
+        meta.threadId = threadId;
+    if (raw.handoff && typeof raw.handoff === "object") {
+        const h = raw.handoff;
+        const agentId = cleanId(h.agentId);
+        const messageId = cleanId(h.messageId);
+        if (agentId && messageId)
+            meta.handoff = { agentId, messageId };
+    }
+    if (Array.isArray(raw.mentionUserIds)) {
+        const ids = raw.mentionUserIds
+            .map((id) => (typeof id === "string" && id.length <= 128 ? id : undefined))
+            .filter((id) => Boolean(id));
+        if (ids.length)
+            meta.mentionUserIds = [...new Set(ids)].slice(0, 25);
+    }
+    if (raw.offRecord === true)
+        meta.offRecord = true;
+    return Object.keys(meta).length ? meta : undefined;
+}
+export function parseSpaceMetaJson(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        return sanitizeSpaceMeta(JSON.parse(raw));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function spaceMetaJson(meta) {
+    return meta && Object.keys(meta).length ? JSON.stringify(meta) : null;
+}

package/dist/shared/spaceFeed.d.ts

@@ -0,0 +1,78 @@
+import type { ChatAttachment, ChatMessage } from "./events.js";
+import type { SpaceHandoffRef } from "./space.js";
+/**
+ * The Space timeline: a Slack-style view across every agent in a room.
+ * Only people's messages and each agent's final reply per turn — no tool
+ * calls, and nothing from a turn that is still running. Thread replies are
+ * grouped under their root post.
+ */
+export interface SpaceHumanEntry {
+    kind: "human";
+    key: string;
+    ts: number;
+    senderName: string;
+    senderColor?: string;
+    senderUserId?: string;
+    content: string;
+    /** Agents this message was sent to (one per @mention); empty = team chat. */
+    agentIds: string[];
+    attachments?: ChatAttachment[];
+    threadId?: string;
+    handoff?: SpaceHandoffRef;
+    mentionUserIds?: string[];
+    /** This post and its thread stay out of team memory. */
+    offRecord?: boolean;
+}
+/** What an agent's run changed — shown as a compact footer on its post. */
+export interface SpaceRunStats {
+    /** Tool calls during the turn (hidden in the Space). */
+    steps: number;
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+    /** Pull request links mentioned in the reply. */
+    prUrls: string[];
+}
+export interface SpaceAgentEntry {
+    kind: "agent";
+    key: string;
+    ts: number;
+    agentId: string;
+    content: string;
+    modelId?: string;
+    error: boolean;
+    stats: SpaceRunStats;
+    threadId?: string;
+}
+export type SpaceEntry = SpaceHumanEntry | SpaceAgentEntry;
+export type SpaceReplier = {
+    kind: "human";
+    name: string;
+    userId?: string;
+} | {
+    kind: "agent";
+    agentId: string;
+};
+export interface SpaceThreadSummary {
+    count: number;
+    lastTs: number;
+    /** Distinct repliers, most recent first. */
+    repliers: SpaceReplier[];
+}
+export interface SpaceTimeline {
+    /** Top-level posts (thread replies excluded). */
+    main: SpaceEntry[];
+    /** rootId → replies, oldest first. */
+    threads: Record<string, SpaceEntry[]>;
+    /** Running agents → thread their current turn belongs to (if any). */
+    activeThreadByAgent: Record<string, string | undefined>;
+}
+export declare function buildSpaceTimeline(messages: ChatMessage[], runningAgentIds: ReadonlySet<string>): SpaceTimeline;
+export declare function summarizeThread(replies: SpaceEntry[] | undefined): SpaceThreadSummary | null;
+/** Markdown → readable one-paragraph text for the collapsed preview. */
+export declare function plainPreview(markdown: string): string;
+export declare const SPACE_PREVIEW_CHARS = 200;
+export declare function truncatePreview(text: string, limit?: number): {
+    text: string;
+    truncated: boolean;
+};

package/dist/shared/spaceFeed.js

@@ -0,0 +1,194 @@
+// Type-only imports above: the web bundler can't resolve runtime "./x.js"
+// imports between shared/ files, so mirror the constant here.
+const SPACE_CHANNEL = "space";
+/** Same message fanned out to several agents arrives as separate rows. */
+const FANOUT_WINDOW_MS = 10_000;
+const PR_URL_RE = /https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+/g;
+function newTurn(threadId, visibleInSpace = false) {
+    return { steps: 0, files: new Set(), additions: 0, deletions: 0, threadId, visibleInSpace };
+}
+function addDiff(turn, msg) {
+    const patch = msg.diffPatch;
+    if (!patch || msg.reverted)
+        return;
+    let sawHeader = false;
+    for (const line of patch.split("\n")) {
+        const header = /^\+\+\+ (?:b\/)?(.+)$/.exec(line);
+        if (header) {
+            if (header[1] !== "/dev/null")
+                turn.files.add(header[1].trim());
+            sawHeader = true;
+            continue;
+        }
+        if (/^(---|diff |index |@@)/.test(line))
+            continue;
+        if (line.startsWith("+"))
+            turn.additions += 1;
+        else if (line.startsWith("-"))
+            turn.deletions += 1;
+    }
+    if (!sawHeader)
+        turn.files.add(msg.id);
+}
+function humanEntry(msg, agentIds) {
+    return {
+        kind: "human",
+        key: msg.id,
+        ts: msg.ts,
+        senderName: msg.senderName || "Someone",
+        senderColor: msg.senderColor,
+        senderUserId: msg.senderUserId,
+        content: msg.content,
+        agentIds,
+        attachments: msg.attachments,
+        threadId: msg.space?.threadId,
+        handoff: msg.space?.handoff,
+        mentionUserIds: msg.space?.mentionUserIds,
+        offRecord: msg.space?.offRecord,
+    };
+}
+export function buildSpaceTimeline(messages, runningAgentIds) {
+    const entries = [];
+    const pending = new Map();
+    const flush = (agentId) => {
+        const turn = pending.get(agentId);
+        pending.delete(agentId);
+        const last = turn?.last;
+        if (!turn || !last || !turn.visibleInSpace)
+            return;
+        entries.push({
+            kind: "agent",
+            key: last.id,
+            ts: last.ts,
+            agentId,
+            content: last.content,
+            modelId: last.modelId,
+            error: last.status === "error",
+            threadId: turn.threadId,
+            stats: {
+                steps: turn.steps,
+                filesChanged: turn.files.size,
+                additions: turn.additions,
+                deletions: turn.deletions,
+                prUrls: [...new Set(last.content.match(PR_URL_RE) ?? [])],
+            },
+        });
+    };
+    for (const msg of messages) {
+        const agentId = msg.agentId;
+        if (agentId === SPACE_CHANNEL) {
+            if (msg.role === "user")
+                entries.push(humanEntry(msg, []));
+            else if ((msg.senderName === "Keel" || msg.senderName === "Eigen") && msg.content.trim()) {
+                entries.push({
+                    kind: "agent",
+                    key: msg.id,
+                    ts: msg.ts,
+                    agentId: "keel",
+                    content: msg.content,
+                    error: false,
+                    threadId: msg.space?.threadId,
+                    stats: { steps: 0, filesChanged: 0, additions: 0, deletions: 0, prUrls: [] },
+                });
+            }
+            continue;
+        }
+        if (msg.role === "user") {
+            const fromSpace = msg.space?.origin === "space";
+            if (agentId) {
+                flush(agentId);
+                pending.set(agentId, newTurn(msg.space?.threadId, fromSpace));
+            }
+            if (!fromSpace)
+                continue;
+            const prev = entries[entries.length - 1];
+            if (agentId &&
+                prev?.kind === "human" &&
+                prev.agentIds.length > 0 &&
+                prev.content === msg.content &&
+                prev.senderName === (msg.senderName || "Someone") &&
+                prev.senderUserId === msg.senderUserId &&
+                prev.threadId === msg.space?.threadId &&
+                msg.ts - prev.ts <= FANOUT_WINDOW_MS) {
+                if (!prev.agentIds.includes(agentId))
+                    prev.agentIds.push(agentId);
+                continue;
+            }
+            entries.push(humanEntry(msg, agentId ? [agentId] : []));
+            continue;
+        }
+        if (!agentId)
+            continue;
+        const turn = pending.get(agentId) ?? newTurn();
+        pending.set(agentId, turn);
+        if (msg.role === "tool") {
+            turn.steps += 1;
+            addDiff(turn, msg);
+        }
+        else if (msg.role === "assistant" &&
+            msg.status !== "streaming" &&
+            msg.content.trim()) {
+            turn.last = msg;
+        }
+    }
+    const activeThreadByAgent = {};
+    for (const [agentId, turn] of [...pending]) {
+        // Still working — the reply lands in the Space once the turn ends.
+        if (runningAgentIds.has(agentId)) {
+            activeThreadByAgent[agentId] = turn.threadId;
+            continue;
+        }
+        flush(agentId);
+    }
+    entries.sort((a, b) => a.ts - b.ts);
+    const main = [];
+    const threads = {};
+    for (const entry of entries) {
+        if (entry.threadId)
+            (threads[entry.threadId] ??= []).push(entry);
+        else
+            main.push(entry);
+    }
+    return { main, threads, activeThreadByAgent };
+}
+export function summarizeThread(replies) {
+    if (!replies?.length)
+        return null;
+    const repliers = [];
+    const seen = new Set();
+    for (const r of [...replies].reverse()) {
+        const id = r.kind === "agent" ? `a:${r.agentId}` : `h:${r.senderUserId || r.senderName}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        repliers.push(r.kind === "agent"
+            ? { kind: "agent", agentId: r.agentId }
+            : { kind: "human", name: r.senderName, userId: r.senderUserId });
+    }
+    return { count: replies.length, lastTs: replies[replies.length - 1].ts, repliers };
+}
+/** Markdown → readable one-paragraph text for the collapsed preview. */
+export function plainPreview(markdown) {
+    return markdown
+        .replace(/```[\s\S]*?```/g, " [code] ")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/^\s{0,3}(#{1,6}|>|[-*+]|\d+\.)\s+/gm, "")
+        .replace(/(\*\*|__|~~)(.+?)\1/g, "$2")
+        .replace(/(^|\W)[*_](\S[^*_]*?)[*_](?=\W|$)/g, "$1$2")
+        .replace(/\|/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export const SPACE_PREVIEW_CHARS = 200;
+export function truncatePreview(text, limit = SPACE_PREVIEW_CHARS) {
+    if (text.length <= limit)
+        return { text, truncated: false };
+    const cut = text.slice(0, limit);
+    const space = cut.lastIndexOf(" ");
+    return {
+        text: `${(space > limit * 0.7 ? cut.slice(0, space) : cut).trimEnd()}…`,
+        truncated: true,
+    };
+}

package/dist/shared/stringifyUnknown.d.ts

@@ -0,0 +1 @@
+export { errorMessage, stringifyUnknown } from "./backends/cursor.js";

package/dist/shared/stringifyUnknown.js

@@ -0,0 +1 @@
+export { errorMessage, stringifyUnknown } from "./backends/cursor.js";

package/dist/shared/swarm.d.ts

@@ -0,0 +1,320 @@
+import type { AgentBackendKind } from "./backends/types.js";
+export declare const SWARM_STATUSES: readonly ["draft", "planning", "researching", "awaiting_approval", "building", "paused", "stopped", "done", "failed"];
+export type SwarmStatus = (typeof SWARM_STATUSES)[number];
+/** Statuses where the runner schedules agent cycles. */
+export declare const ACTIVE_SWARM_STATUSES: readonly ["planning", "researching", "building"];
+export declare const TERMINAL_SWARM_STATUSES: readonly ["stopped", "done", "failed"];
+export type SwarmPhase = "research" | "build";
+export declare const SWARM_ROLES: readonly ["orchestrator", "researcher", "critic", "ranker", "synthesizer", "verifier", "engineer", "integrator"];
+export type SwarmRole = (typeof SWARM_ROLES)[number];
+/** Roles that write code and can only be spawned in the build phase. */
+export declare const REPO_ROLES: readonly SwarmRole[];
+export declare const WORKER_ROLES: readonly SwarmRole[];
+export type SwarmAgentStatus = "idle" | "running" | "retired" | "error";
+export declare const SWARM_TASK_STATUSES: readonly ["pending", "claimed", "done", "failed", "cancelled"];
+export type SwarmTaskStatus = (typeof SWARM_TASK_STATUSES)[number];
+export declare const SWARM_TASK_KINDS: readonly ["research", "critique", "rank", "synthesize", "verify", "build", "integrate"];
+export type SwarmTaskKind = (typeof SWARM_TASK_KINDS)[number];
+export declare const SWARM_POST_KINDS: readonly ["finding", "question", "answer", "proposal", "critique", "decision", "directive", "progress"];
+export type SwarmPostKind = (typeof SWARM_POST_KINDS)[number];
+export declare const SWARM_BASE_CHANNELS: readonly ["plan", "findings", "questions", "decisions"];
+export type SwarmBaseChannel = (typeof SWARM_BASE_CHANNELS)[number];
+export declare const SWARM_HYPOTHESIS_STATUSES: readonly ["proposed", "promoted", "rejected"];
+export type SwarmHypothesisStatus = (typeof SWARM_HYPOTHESIS_STATUSES)[number];
+export declare const SWARM_CRITIQUE_VERDICTS: readonly ["support", "refute", "needs_evidence"];
+export type SwarmCritiqueVerdict = (typeof SWARM_CRITIQUE_VERDICTS)[number];
+export declare const SWARM_ARTIFACT_KINDS: readonly ["report", "design", "notes", "benchmark", "data", "code_ref", "other"];
+export type SwarmArtifactKind = (typeof SWARM_ARTIFACT_KINDS)[number];
+export declare const DEFAULT_SWARM_BUDGET_USD = 25;
+export declare const MAX_SWARM_BUDGET_USD = 2000;
+export declare const DEFAULT_SWARM_DEADLINE_HOURS = 24;
+export declare const MAX_SWARM_DEADLINE_HOURS: number;
+export declare const DEFAULT_SWARM_MAX_WORKERS = 5;
+export declare const MAX_SWARM_WORKERS = 8;
+export declare const DEFAULT_SWARM_MAX_RUNNING = 3;
+export declare const MAX_SWARM_RUNNING = 6;
+export declare const DEFAULT_SWARM_MAX_CYCLES = 200;
+export declare const MAX_SWARM_CYCLES = 2000;
+export declare const SWARM_STALL_LIMIT = 2;
+export declare const SWARM_IDLE_ORCHESTRATOR_LIMIT = 3;
+export declare const SWARM_MIN_CRITIQUED_HYPOTHESES = 4;
+export declare const SWARM_BUDGET_WARN_RATIO = 0.8;
+export declare const MAX_SWARM_TITLE = 160;
+export declare const MAX_SWARM_GOAL = 12000;
+export declare const MAX_SWARM_POST = 8000;
+export declare const MAX_SWARM_NOTES = 12000;
+export declare const MAX_SWARM_TASK_SPEC = 4000;
+export declare const MAX_SWARM_LEDGER_FIELD = 12000;
+export declare const MAX_SWARM_ARTIFACT = 200000;
+export declare const MAX_SWARM_BRIEF = 3000;
+export declare const SWARM_ELO_START = 1200;
+export declare const SWARM_ELO_K = 32;
+export interface SwarmInfo {
+    id: string;
+    orgId: string | null;
+    creatorId: string;
+    creatorName?: string | null;
+    title: string;
+    goal: string;
+    status: SwarmStatus;
+    phase: SwarmPhase;
+    repoUrl: string | null;
+    startingRef: string;
+    /** Default agent for the swarm's workers. */
+    backend: AgentBackendKind;
+    /** Run workers on this Machine instead of the cloud (null = cloud). */
+    machineId?: string | null;
+    machineName?: string | null;
+    modelId: string;
+    budgetUsd: number;
+    spentUsd: number;
+    tokensUsed: number;
+    deadlineAt: number | null;
+    maxWorkers: number;
+    maxRunning: number;
+    maxCycles: number;
+    cyclesDone: number;
+    stallCount: number;
+    stopReason: string | null;
+    approvalNote: string | null;
+    createdAt: number;
+    updatedAt: number;
+    startedAt: number | null;
+    finishedAt: number | null;
+    runningAgents?: number;
+    totalAgents?: number;
+}
+export interface SwarmAgentInfo {
+    id: string;
+    swarmId: string;
+    role: SwarmRole;
+    label: string;
+    brief: string;
+    status: SwarmAgentStatus;
+    /** Agent this worker runs on (may differ per worker). */
+    backend: AgentBackendKind;
+    /** Machine override for this worker (null = the swarm's choice). */
+    machineId?: string | null;
+    machineName?: string | null;
+    modelId: string;
+    cursorAgentId: string | null;
+    hasRepo: boolean;
+    branch: string | null;
+    currentTaskId: string | null;
+    cycles: number;
+    spentUsd: number;
+    tokensUsed: number;
+    lastCycleAt: number | null;
+    lastBoardCallAt: number | null;
+    runStartedAt: number | null;
+    lastError: string | null;
+    createdAt: number;
+    /** Agent that spawned this worker. Null for the orchestrator. */
+    spawnedBy: string | null;
+}
+export interface SwarmTaskInfo {
+    id: string;
+    swarmId: string;
+    title: string;
+    spec: string;
+    kind: SwarmTaskKind;
+    status: SwarmTaskStatus;
+    ownerAgentId: string | null;
+    roleHint: SwarmRole | null;
+    blockedBy: string[];
+    priority: number;
+    resultMd: string | null;
+    attempts: number;
+    createdAt: number;
+    updatedAt: number;
+    completedAt: number | null;
+}
+export interface SwarmPostInfo {
+    id: string;
+    swarmId: string;
+    authorAgentId: string | null;
+    authorUserId: string | null;
+    authorLabel: string;
+    authorRole: SwarmRole | "human" | "system";
+    channel: string;
+    kind: SwarmPostKind;
+    bodyMd: string;
+    refs: string[];
+    mentions: string[];
+    createdAt: number;
+}
+export interface SwarmLedgerInfo {
+    swarmId: string;
+    revision: number;
+    factsMd: string;
+    guessesMd: string;
+    planMd: string;
+    openQuestionsMd: string;
+    progress: SwarmProgressEntry | null;
+    updatedBy: string | null;
+    updatedAt: number;
+}
+export interface SwarmProgressEntry {
+    isRequestSatisfied: boolean;
+    isProgressBeingMade: boolean;
+    isInLoop: boolean;
+    nextFocus: string;
+    reason: string;
+}
+export interface SwarmHypothesisInfo {
+    id: string;
+    swarmId: string;
+    title: string;
+    claimMd: string;
+    evidenceMd: string;
+    parentIds: string[];
+    elo: number;
+    matches: number;
+    wins: number;
+    critiques: number;
+    status: SwarmHypothesisStatus;
+    authorAgentId: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface SwarmCritiqueInfo {
+    id: string;
+    hypothesisId: string;
+    authorAgentId: string | null;
+    verdict: SwarmCritiqueVerdict;
+    score: number;
+    bodyMd: string;
+    createdAt: number;
+}
+export interface SwarmArtifactInfo {
+    id: string;
+    swarmId: string;
+    agentId: string | null;
+    kind: SwarmArtifactKind;
+    name: string;
+    size: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface SwarmEventInfo {
+    id: string;
+    swarmId: string;
+    agentId: string | null;
+    kind: string;
+    message: string;
+    createdAt: number;
+}
+export interface SwarmMessageInfo {
+    id: string;
+    agentId: string;
+    cycle: number;
+    role: "user" | "assistant" | "tool" | "error";
+    content: string;
+    toolName: string | null;
+    status: "running" | "done" | "error" | null;
+    ts: number;
+}
+export interface SwarmSnapshot {
+    swarm: SwarmInfo;
+    agents: SwarmAgentInfo[];
+    tasks: SwarmTaskInfo[];
+    posts: SwarmPostInfo[];
+    hypotheses: SwarmHypothesisInfo[];
+    critiques: SwarmCritiqueInfo[];
+    ledger: SwarmLedgerInfo | null;
+    artifacts: SwarmArtifactInfo[];
+    events: SwarmEventInfo[];
+    canEdit: boolean;
+}
+export declare const isSwarmStatus: (v: unknown) => v is SwarmStatus;
+export declare const isSwarmRole: (v: unknown) => v is SwarmRole;
+export declare const isSwarmTaskKind: (v: unknown) => v is SwarmTaskKind;
+export declare const isSwarmTaskStatus: (v: unknown) => v is SwarmTaskStatus;
+export declare const isSwarmPostKind: (v: unknown) => v is SwarmPostKind;
+export declare const isSwarmArtifactKind: (v: unknown) => v is SwarmArtifactKind;
+export declare const isSwarmCritiqueVerdict: (v: unknown) => v is SwarmCritiqueVerdict;
+export declare const isSwarmHypothesisStatus: (v: unknown) => v is SwarmHypothesisStatus;
+export declare function isActiveSwarmStatus(status: SwarmStatus): boolean;
+export declare function isTerminalSwarmStatus(status: SwarmStatus): boolean;
+export declare function canStartSwarm(status: SwarmStatus): boolean;
+export declare function canPauseSwarm(status: SwarmStatus): boolean;
+export declare function canResumeSwarm(status: SwarmStatus): boolean;
+export declare function canStopSwarm(status: SwarmStatus): boolean;
+export declare function isSwarmChannel(value: unknown): value is string;
+export declare function roleNeedsRepo(role: SwarmRole): boolean;
+/** When the human attached a repo, every agent gets a checkout so they can read it. */
+export declare function swarmAgentUsesRepo(swarm: Pick<SwarmInfo, "repoUrl">, _role?: SwarmRole): boolean;
+/** Engineers / integrators only exist once the research report is approved. */
+export declare function roleAllowedInPhase(role: SwarmRole, phase: SwarmPhase): boolean;
+export declare function canEditSwarm(swarm: {
+    creatorId: string;
+    orgId?: string | null;
+}, actor: {
+    userId: string;
+    orgRole?: string | null;
+}): boolean;
+export declare function clampSwarmBudgetUsd(raw: unknown): number;
+export declare function clampSwarmDeadlineHours(raw: unknown): number;
+export declare function clampSwarmMaxWorkers(raw: unknown): number;
+export declare function clampSwarmMaxRunning(raw: unknown): number;
+export declare function clampSwarmMaxCycles(raw: unknown): number;
+export type SwarmEloOutcome = "a" | "b" | "draw";
+export declare function nextEloRatings(ratingA: number, ratingB: number, outcome: SwarmEloOutcome, k?: number): {
+    a: number;
+    b: number;
+};
+export interface SwarmLimitState {
+    status: SwarmStatus;
+    budgetUsd: number;
+    spentUsd: number;
+    deadlineAt: number | null;
+    maxCycles: number;
+    cyclesDone: number;
+}
+export type SwarmLimitVerdict = {
+    action: "continue";
+} | {
+    action: "pause";
+    reason: "budget";
+} | {
+    action: "stop";
+    reason: "deadline" | "max_cycles";
+};
+/** Hard limits the runner enforces before starting any cycle. */
+export declare function evaluateSwarmLimits(state: SwarmLimitState, now: number): SwarmLimitVerdict;
+export declare function shouldWarnBudget(spentUsd: number, budgetUsd: number): boolean;
+export interface SwarmDoneGateInput {
+    phase: SwarmPhase;
+    hasReport: boolean;
+    critiquedHypotheses: number;
+    latestVerificationPassed: boolean | null;
+    openBuildTasks: number;
+    minCritiquedHypotheses?: number;
+}
+/** A swarm may only finish with a report, enough vetted ideas, and a passing verifier. */
+export declare function evaluateDoneGate(input: SwarmDoneGateInput): {
+    ok: boolean;
+    missing: string[];
+};
+export declare function taskDependenciesMet(task: Pick<SwarmTaskInfo, "blockedBy">, byId: Map<string, Pick<SwarmTaskInfo, "status">>): boolean;
+export declare function taskMatchesRole(task: Pick<SwarmTaskInfo, "roleHint" | "kind">, role: SwarmRole): boolean;
+export declare function extractMentions(body: string): string[];
+export declare function slugifySwarmLabel(raw: string, fallback?: string): string;
+export declare function swarmTitleFromGoal(goal: string): string;
+/** Compact label for a swarm's stored Cursor model id (no catalog required). */
+export declare function formatSwarmModelLabel(modelId: string | null | undefined): string;
+export interface SwarmDigestInput {
+    agentId: string;
+    agentLabel: string;
+    since: number;
+    posts: Pick<SwarmPostInfo, "id" | "authorLabel" | "authorRole" | "channel" | "kind" | "bodyMd" | "mentions" | "createdAt">[];
+    tasks: Pick<SwarmTaskInfo, "id" | "title" | "status" | "ownerAgentId" | "kind">[];
+    hypotheses: Pick<SwarmHypothesisInfo, "id" | "title" | "elo" | "critiques" | "status">[];
+    agents: Pick<SwarmAgentInfo, "id" | "label" | "role" | "status">[];
+    maxChars?: number;
+}
+/**
+ * Deterministic board digest injected into every cycle prompt. Agents get the
+ * decisions, directives, and anything addressed to them — not the whole board.
+ */
+export declare function buildBoardDigest(input: SwarmDigestInput): string;