@loompad/cli 0.1.0 → 1.1.1

package/dist/daemon/client.d.ts

@@ -2,7 +2,11 @@
  * Thin daemon client used by every surface (CLI now, app later).
  * Also owns daemon lifecycle: autostart-on-demand, health, shutdown.
  */
-import type { CostSummary, LoomEvent, ProjectStatus, RouteState, RouteStepSpec, UnifiedMemory } from "../types.js";
+import type { AgentConfig, CostSummary, LoomEvent, ProjectStatus, RouteState, RouteStepSpec, UnifiedMemory } from "../types.js";
+import type { Checkpoint, RestoreResult } from "../core/checkpoint.js";
+import type { OrchestraRun } from "../core/orchestra.js";
+import type { QueueItem } from "../core/prompt-queue.js";
+import type { LogLine, ServerConfig, ServerStatus } from "../core/servers.js";
 import { type DaemonConfig } from "../core/registry.js";
 import type { Memory } from "../core/brain.js";
 import type { BoardData } from "./board.js";
@@ -11,12 +15,100 @@ export declare class DaemonError extends Error {
     readonly body?: Record<string, unknown> | undefined;
     constructor(message: string, status?: number | undefined, body?: Record<string, unknown> | undefined);
 }
+/** What the daemon says about whether this copy of Loom is current. */
+export interface UpdateStatus {
+    version: string;
+    rev: string;
+    root: string | null;
+    git: {
+        behind: number;
+        ahead: number;
+        branch: string;
+    } | null;
+    latest: string | null;
+    release: {
+        version: string;
+        tag: string;
+        url: string;
+        publishedAt: string | null;
+    } | null;
+    behindRelease: boolean;
+    install: "git" | "npm-global" | "unknown";
+    canApply: boolean;
+    refusal: string | null;
+    /** Exactly what applying would run, in order. */
+    steps: string[];
+}
+/** What the daemon says about a project's prompt queue. */
+export interface QueueView {
+    queue: QueueItem[];
+    paused: boolean;
+    /** Why it paused itself (a refused send, a Stop, a restart). */
+    reason?: string;
+    /** What the head is waiting for, when it's waiting on something. */
+    waitingFor?: string;
+}
+export interface OnboardJobView {
+    id: string;
+    state: "running" | "done" | "failed";
+    team: string | null;
+    repo: string | null;
+    from: string | null;
+    steps: Array<{
+        id: string;
+        label: string;
+        state: string;
+        detail?: string;
+    }>;
+    project?: {
+        id: string;
+        name: string;
+        dir: string;
+    };
+    agents?: string[];
+    crews?: string[];
+    error?: string;
+}
 export declare class DaemonClient {
     private cfg;
     constructor(cfg: DaemonConfig);
     static fromDisk(): DaemonClient | null;
     get baseUrl(): string;
     private request;
+    /** The leaderboard (optionally since a time) and per-day turn counts. */
+    turnStats(id: string, opts?: {
+        days?: number;
+        since?: number;
+    }): Promise<{
+        leaderboard: Array<{
+            agentId: string;
+            turns: number;
+            ok: number;
+            errors: number;
+            totalCostUsd: number;
+            medianMs: number | null;
+        }>;
+        days: Array<{
+            date: string;
+            turns: number;
+            errors: number;
+            costUsd: number;
+        }>;
+        total: number;
+    }>;
+    chats(id: string): Promise<{
+        chats: Array<{
+            id: string;
+            title: string;
+        }>;
+    }>;
+    /** One page of a chat's events, newest `limit`, before an id when paging back. */
+    chatEvents(id: string, chat: string, opts?: {
+        before?: number;
+        limit?: number;
+    }): Promise<{
+        events: LoomEvent[];
+    }>;
     health(): Promise<{
         ok: boolean;
     }>;
@@ -28,9 +120,466 @@ export declare class DaemonClient {
             id: string;
         };
     }>;
+    /** Stop tracking a project. Registry-only — its .loom/ stays on disk. */
+    forgetProject(id: string): Promise<{
+        removed: boolean;
+        keptOnDisk: string;
+    }>;
     project(id: string): Promise<{
         project: ProjectStatus;
     }>;
+    models(id: string, agentId: string): Promise<{
+        kind: string;
+        count: number;
+        models: string[];
+    }>;
+    /**
+     * Add an agent to a project's roster.
+     *
+     * `as` names the instance. Leave it off and the daemon picks the next free id
+     * for the kind, so asking twice gives you two sessions rather than an error.
+     */
+    addAgent(id: string, kind: string, opts?: {
+        as?: string;
+        role?: string;
+        options?: Record<string, unknown>;
+    }): Promise<AgentConfig>;
+    /** Which agents this machine can drive, and how many of each are here. */
+    availableAgents(id: string): Promise<{
+        ades: Array<{
+            kind: string;
+            label: string;
+            tier: string;
+            installed: boolean | null;
+            inProject: boolean;
+            instances: number;
+            canAddAnother: boolean;
+        }>;
+    }>;
+    /**
+     * Fan a subtask out to a child agent alongside the parent's turn.
+     *
+     * The parent keeps the baton — this is one turn borrowing another pair of
+     * hands, not a handoff.
+     */
+    orchestraRuns(id: string): Promise<{
+        runs: OrchestraRun[];
+        active: string | null;
+    }>;
+    orchestraRun(id: string, runId: string): Promise<{
+        run: OrchestraRun;
+    }>;
+    startOrchestra(id: string, body: {
+        goal: string;
+        orchestrator?: string;
+        workers?: string[];
+        maxParallel?: number;
+        maxRounds?: number;
+        plan?: boolean;
+        maxUsd?: number;
+        race?: boolean;
+    }): Promise<{
+        run: OrchestraRun;
+    }>;
+    orchestraAction(id: string, runId: string, action: "abort" | "reply" | "apply" | "cleanup" | "resume", body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    team(): Promise<Record<string, unknown>>;
+    teamAction(action: string, body?: Record<string, unknown>): Promise<{
+        result: unknown;
+        team: Record<string, unknown>;
+    }>;
+    /** One-link onboarding (daemon/onboard.ts). */
+    inviteTeammate(id: string, body?: {
+        teamId?: string;
+        grant?: boolean;
+    }): Promise<{
+        link: string;
+        expiresAt: number;
+        team: {
+            id: string;
+            name: string;
+        };
+        repo: string;
+        grant: boolean;
+        grantNote?: string;
+        message: string;
+    }>;
+    previewInvite(link: string): Promise<{
+        team: string | null;
+        repo: string | null;
+        from: string | null;
+        hub: string;
+        signedIn: boolean;
+        member: boolean;
+        crews: string[];
+        github: string | null;
+    }>;
+    startJoin(body: {
+        link: string;
+        dir?: string;
+        into?: string;
+        github?: string;
+        secret?: string;
+        token?: string;
+    }): Promise<{
+        job: OnboardJobView;
+    }>;
+    joinStatus(job: string): Promise<{
+        job: OnboardJobView;
+    }>;
+    /** Agent Teams (core/crew.ts). */
+    crews(id: string): Promise<{
+        crews: Array<Record<string, any>>;
+        templates: string[];
+    }>;
+    createCrew(id: string, body: Record<string, unknown>): Promise<{
+        crew: Record<string, any>;
+    }>;
+    crewDiff(id: string, crew: string): Promise<{
+        diff: string;
+    }>;
+    removeCrew(id: string, crew: string): Promise<{
+        ok: boolean;
+    }>;
+    /** Proof: check the newest finished turn in a chat (daemon/proof.ts). */
+    /** A chat as one self-contained HTML page (core/replay.ts). */
+    replay(id: string, chat: string): Promise<string>;
+    shift(id: string): Promise<Record<string, any>>;
+    startShift(id: string, body: {
+        tasks: string[];
+        to?: string;
+        until?: string;
+        maxUsd?: number;
+    }): Promise<Record<string, any>>;
+    stopShift(id: string): Promise<Record<string, any>>;
+    proof(id: string, body?: {
+        chat?: string;
+        at?: number;
+        testCommand?: string;
+    }): Promise<Record<string, any>>;
+    crewAction(id: string, crew: string, action: string, body?: Record<string, unknown>): Promise<Record<string, any>>;
+    shareProject(id: string, teamId?: string): Promise<{
+        repo: string;
+        teamId: string;
+    }>;
+    unshareProject(id: string): Promise<{
+        ok: boolean;
+    }>;
+    /** The team brain for a project (Phase 3): status, memories with tiers, inbox. */
+    teamBrain(id: string, opts?: {
+        sync?: boolean;
+        history?: boolean;
+    }): Promise<TeamBrainView>;
+    teamBrainAction(id: string, action: string, body?: Record<string, unknown>): Promise<TeamBrainView & {
+        result: unknown;
+    }>;
+    /** Goal PRs on their way to main, and teammates' goals to adopt (Phase 4). */
+    landing(id: string, opts?: {
+        poll?: boolean;
+    }): Promise<{
+        goals: Array<Record<string, unknown>>;
+        adoptable: Array<Record<string, unknown>>;
+    }>;
+    landingAction(id: string, action: string, body?: Record<string, unknown>): Promise<{
+        result: unknown;
+        goals: Array<Record<string, unknown>>;
+    }>;
+    teamDoctor(id: string): Promise<{
+        repo: string | null;
+        branch: string;
+        findings: Array<{
+            level: string;
+            what: string;
+            fix?: string;
+        }>;
+        fixable: string[];
+    }>;
+    teamDoctorFix(id: string): Promise<{
+        prUrl: string | null;
+        files: string[];
+    }>;
+    runner(): Promise<Record<string, unknown>>;
+    runnerAction(action: string, body?: Record<string, unknown>): Promise<{
+        result: unknown;
+    }>;
+    runners(id: string): Promise<{
+        runners: Array<Record<string, unknown>>;
+        jobs: Array<Record<string, unknown>>;
+    }>;
+    runnersAction(id: string, action: string, body?: Record<string, unknown>): Promise<{
+        result: unknown;
+        runners: Array<Record<string, unknown>>;
+        jobs: Array<Record<string, unknown>>;
+    }>;
+    deploys(id: string): Promise<{
+        deployments: Array<Record<string, unknown>>;
+    }>;
+    releaseNotes(id: string, since: string): Promise<{
+        markdown: string;
+    }>;
+    cloud(): Promise<Record<string, unknown>>;
+    cloudAction(action: "enable" | "disable" | "rotate", body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    spawnSubtask(id: string, parent: string, agentId: string, task: string, chat?: string): Promise<{
+        id: string;
+        agentId: string;
+    }>;
+    subtasks(id: string): Promise<{
+        subtasks: Array<{
+            id: string;
+            parent: string;
+            agentId: string;
+            task: string;
+        }>;
+    }>;
+    listTasks(id: string): Promise<{
+        tasks: Array<{
+            id: string;
+            title: string;
+            column: string;
+            agent?: string;
+            blockedBy?: string[];
+        }>;
+    }>;
+    createTask(id: string, title: string, opts?: {
+        column?: string;
+        agent?: string;
+        blockedBy?: string[];
+    }): Promise<{
+        task: {
+            id: string;
+            title: string;
+            column: string;
+        };
+    }>;
+    saveRoute(id: string, name: string, steps: string[]): Promise<{
+        routes: Record<string, unknown>;
+    }>;
+    deleteRoute(id: string, name: string): Promise<{
+        routes: Record<string, unknown>;
+    }>;
+    /** Re-run the last failed turn on a different agent, failure attached. */
+    retryTurn(id: string, agentId: string): Promise<{
+        agentId: string;
+        retried: string;
+    }>;
+    budgets(id: string): Promise<{
+        budgets: Record<string, number>;
+        status: Record<string, {
+            budgetUsd: number;
+            spentTodayUsd: number;
+            over: boolean;
+        }>;
+    }>;
+    setBudget(id: string, agentId: string, usdPerDay: number): Promise<{
+        budgets: Record<string, number>;
+    }>;
+    version(): Promise<{
+        rev: string;
+        node: string;
+        platform: string;
+        uptimeSec: number;
+        pid: number;
+    }>;
+    forgetMemory(id: string, memoryId: string): Promise<{
+        forgotten: boolean;
+    }>;
+    renameProject(id: string, name: string): Promise<{
+        project: {
+            id: string;
+            name: string;
+        };
+    }>;
+    searchEvents(id: string, q: string, limit?: number): Promise<{
+        hits: LoomEvent[];
+    }>;
+    snapshot(id: string): Promise<Record<string, unknown>>;
+    restore(id: string, doc: unknown): Promise<{
+        brain: {
+            added: number;
+            known: number;
+        };
+        tasks: number;
+    }>;
+    /** Rewind (#101): points the working tree can be put back to. */
+    checkpoints(id: string): Promise<{
+        checkpoints: Checkpoint[];
+    }>;
+    rewind(id: string, checkpointId: string): Promise<RestoreResult>;
+    staleSessions(id: string): Promise<{
+        stale: Array<{
+            agentId: string;
+            busyMs: number;
+        }>;
+    }>;
+    reapSession(id: string, agentId: string): Promise<{
+        respawned: boolean;
+    }>;
+    logs(opts?: {
+        level?: "error" | "warn" | "info";
+        project?: string;
+    }): Promise<{
+        logs: Array<{
+            id: number;
+            at: number;
+            level: string;
+            scope: string;
+            message: string;
+            detail?: string;
+            project?: string;
+        }>;
+    }>;
+    searchBrain(id: string, q: string, opts?: {
+        agent?: string;
+        explain?: boolean;
+        limit?: number;
+    }): Promise<{
+        hits: Array<{
+            memory: Memory;
+            score: number;
+            detail?: Record<string, unknown>;
+        }>;
+    }>;
+    brainConflicts(id: string): Promise<{
+        conflicts: Array<{
+            a: {
+                text: string;
+            };
+            b: {
+                text: string;
+            };
+            similarity: number;
+            signal: string;
+        }>;
+    }>;
+    prompts(q?: string): Promise<{
+        saved: Array<{
+            id: string;
+            title: string;
+            text: string;
+            pinned: boolean;
+            uses: number;
+        }>;
+        recent?: string[];
+    }>;
+    savePrompt(input: {
+        title?: string;
+        text: string;
+        pinned?: boolean;
+    }): Promise<{
+        prompt: {
+            id: string;
+            title: string;
+        };
+    }>;
+    updatePrompt(promptId: string, patch: {
+        title?: string;
+        text?: string;
+        pinned?: boolean;
+        used?: boolean;
+    }): Promise<{
+        prompt: {
+            id: string;
+        };
+    }>;
+    deletePrompt(promptId: string): Promise<{
+        ok: boolean;
+    }>;
+    skillsCatalog(id: string): Promise<{
+        skills: Array<{
+            id: string;
+            name?: string;
+            description?: string;
+            enabled?: boolean;
+            origin?: string;
+            installed?: boolean;
+        }>;
+    }>;
+    setSkill(id: string, skillId: string, enabled: boolean): Promise<unknown>;
+    installSkill(id: string, from: {
+        gitUrl?: string;
+        dir?: string;
+        force?: boolean;
+    }): Promise<{
+        skill: {
+            id: string;
+            name?: string;
+            also?: string[];
+        };
+    }>;
+    removeSkill(id: string, skillId: string): Promise<unknown>;
+    mcps(id: string, probe?: boolean): Promise<{
+        mcps: Array<{
+            name: string;
+            url?: string;
+            command?: string;
+            args?: string[];
+            enabledForSession?: boolean;
+            connected?: boolean;
+            description?: string;
+        }>;
+    }>;
+    installMcp(id: string, mcp: {
+        name: string;
+        url?: string;
+        command?: string;
+        args?: string[];
+        headers?: Record<string, string>;
+        env?: Record<string, string>;
+    }): Promise<{
+        installed: {
+            name: string;
+            connected?: boolean;
+        } | null;
+    }>;
+    patchMcp(id: string, mcp: Record<string, unknown> & {
+        name: string;
+    }): Promise<unknown>;
+    removeMcp(id: string, name: string): Promise<unknown>;
+    mcpHealth(id: string): Promise<{
+        health: Record<string, {
+            up: boolean;
+            failures: number;
+            probedAt: number;
+        }>;
+    }>;
+    listSpecs(id: string): Promise<{
+        specs: Array<{
+            path: string;
+            bytes: number;
+        }>;
+        running: {
+            id: string;
+            file: string;
+        } | null;
+    }>;
+    runSpec(id: string, file: string): Promise<{
+        run: {
+            id: string;
+            file: string;
+        };
+    }>;
+    costSeries(id: string, days?: number): Promise<{
+        days: number;
+        series: Array<{
+            day: string;
+            usd: number;
+            turns: number;
+            tokensIn: number;
+            tokensOut: number;
+            byAgent: Record<string, {
+                usd: number;
+                turns: number;
+            }>;
+        }>;
+    }>;
+    /** The brain as a portable document — see Brain.export. */
+    exportBrain(id: string): Promise<Record<string, unknown>>;
+    importBrain(id: string, doc: unknown): Promise<{
+        added: number;
+        known: number;
+    }>;
+    removeAgent(id: string, agentId: string): Promise<{
+        removed: boolean;
+    }>;
     events(id: string, since?: number, limit?: number): Promise<{
         events: LoomEvent[];
     }>;
@@ -41,9 +590,80 @@ export declare class DaemonClient {
         from: string | null;
         to: string;
     }>;
+    servers(id: string): Promise<{
+        servers: ServerStatus[];
+        suggested: ServerConfig[];
+    }>;
+    setServers(id: string, servers: ServerConfig[]): Promise<{
+        servers: ServerStatus[];
+    }>;
+    serverAction(id: string, name: string, action: "start" | "stop" | "restart"): Promise<{
+        server: ServerStatus;
+    }>;
+    serverLog(id: string, name: string, limit?: number): Promise<{
+        lines: LogLine[];
+    }>;
+    digest(id: string, since: number): Promise<{
+        since: number;
+        lines: Array<{
+            at: number;
+            kind: string;
+            text: string;
+            eventId: number;
+            chat?: string;
+        }>;
+        turns: number;
+        costUsd: number;
+        waiting: string[];
+    }>;
+    updates(refresh?: boolean): Promise<UpdateStatus>;
+    applyUpdate(): Promise<{
+        started: boolean;
+        steps: string[];
+    }>;
     interrupt(id: string): Promise<{
         interrupted: string | null;
     }>;
+    queue(id: string): Promise<QueueView>;
+    queueAdd(id: string, body: {
+        text: string;
+        target?: unknown;
+        chat?: string;
+        plan?: boolean;
+        when?: unknown;
+    }): Promise<QueueView & {
+        item: QueueItem;
+    }>;
+    queueEdit(id: string, itemId: string, patch: {
+        text?: string;
+        target?: unknown;
+        to?: number;
+        when?: unknown;
+    }): Promise<QueueView>;
+    queueRemove(id: string, itemId: string): Promise<QueueView>;
+    queueClear(id: string): Promise<QueueView & {
+        dropped: number;
+    }>;
+    saveQueueRecipe(id: string, name: string): Promise<{
+        recipe: {
+            name: string;
+            steps: unknown[];
+        };
+    }>;
+    runQueueRecipe(id: string, name: string): Promise<QueueView & {
+        added: number;
+    }>;
+    recipes(): Promise<{
+        recipes: Array<{
+            name: string;
+            steps: Array<{
+                text: string;
+                to: string;
+            }>;
+            fromProject?: string;
+        }>;
+    }>;
+    queuePause(id: string, paused: boolean): Promise<QueueView>;
     decision(id: string, text: string): Promise<{
         event: LoomEvent;
     }>;
@@ -53,6 +673,18 @@ export declare class DaemonClient {
     }): Promise<{
         route: RouteState;
     }>;
+    /** One prompt, several models, a thread each. */
+    askModels(id: string, text: string, models: string[], opts?: {
+        title?: string;
+        briefing?: boolean;
+    }): Promise<{
+        asked: Array<{
+            chat: string;
+            model: string;
+            provider: string;
+            agentId: string;
+        }>;
+    }>;
     routeState(id: string): Promise<{
         route: RouteState | null;
     }>;
@@ -99,6 +731,7 @@ export declare class DaemonClient {
         token: string;
         expiresAt: number;
         url: string;
+        link?: string;
     }>;
     pairedClients(): Promise<{
         clients: Array<{
@@ -125,3 +758,34 @@ export declare class DaemonClient {
 export declare function ensureDaemon(): Promise<DaemonClient>;
 export declare function daemonRunning(): Promise<DaemonConfig | null>;
 export declare function stopDaemon(): Promise<boolean>;
+export interface TeamBrainView {
+    status: Record<string, unknown>;
+    memories: Array<{
+        id: string;
+        text: string;
+        kind: string;
+        tier: string;
+        author: string | null;
+        confirmedBy: string[];
+        mine: boolean;
+        state: string;
+        untrusted?: boolean;
+    }>;
+    inbox: Array<{
+        id: string;
+        type: string;
+        detail: string;
+        a: {
+            id: string;
+            text: string;
+            tier: string;
+            author: string | null;
+        };
+        b?: {
+            id: string;
+            text: string;
+            tier: string;
+            author: string | null;
+        };
+    }>;
+}