@loompad/cli 0.1.0 → 1.1.2

package/dist/types.d.ts

@@ -4,7 +4,7 @@
  * The event log is the source of truth; everything else (agent memory,
  * board views, phone surfaces) is a projection of it.
  */
-export type EventKind = "message" | "tool_call" | "tool_result" | "file_edit" | "decision" | "handoff" | "suggestion" | "needs_input" | "run_complete" | "agent_join" | "agent_leave" | "role_change" | "route_started" | "route_step" | "route_paused" | "route_resumed" | "route_completed" | "route_failed" | "turn_diff" | "memory_import" | "memory_add" | "memory_update" | "memory_forget" | "status" | "error";
+export type EventKind = "message" | "tool_call" | "tool_result" | "file_edit" | "decision" | "handoff" | "suggestion" | "needs_input" | "run_complete" | "agent_join" | "agent_leave" | "role_change" | "route_started" | "route_step" | "route_paused" | "route_resumed" | "route_completed" | "route_failed" | "turn_diff" | "checkpoint" | "subtask_started" | "subtask_done" | "subtask_failed" | "orchestra" | "crew" | "approval" | "memory_import" | "memory_add" | "memory_update" | "memory_forget" | "status" | "proof" | "shift" | "error";
 /**
  * The chat every event belongs to. A project can hold several conversations;
  * they share one brain, one baton and one working tree — only the talking is
@@ -33,6 +33,52 @@ export interface ChatInfo {
     id: string;
     title: string;
     createdAt: number;
+    /**
+     * Who answers in this thread, if the thread has an opinion.
+     *
+     * Without it, a chat is a label on events and whoever holds the baton
+     * answers everywhere — which means two threads can't be talking to two
+     * agents. With it, switching threads switches who you're talking to.
+     */
+    agentId?: string;
+    /**
+     * The model for this thread, for agents that can change model per turn.
+     * Only the `model` kind can; binding one to an agent that can't is refused
+     * at the point of binding rather than ignored at the point of sending.
+     */
+    model?: string;
+    /** Kept at the top of the sidebar, under Main. */
+    pinned?: boolean;
+    /** Out of the sidebar, not forgotten: its history stays in the log. */
+    archived?: boolean;
+    /** A sidebar folder this thread is filed under (a plain name; folders exist while a thread is in them). */
+    folder?: string;
+    /**
+     * What made this thread, when something did: an Orchestra run or race (its
+     * own thread and one per task), a crew (its channel and one per teammate),
+     * or an import. Computed on read from the runs, crews and imports — never
+     * stored — so the sidebar can fold a run's dozen threads into one row.
+     */
+    group?: {
+        kind: "orchestra" | "race" | "crew" | "import";
+        id: string;
+        title: string;
+        status?: string;
+        at: number;
+    };
+    /** Event ids marked as worth coming back to (newest last, capped). */
+    starred?: number[];
+    /** Your verdict on replies: event id → up (1) or down (-1), with who wrote it. */
+    ratings?: Record<string, {
+        v: 1 | -1;
+        agent: string;
+    }>;
+    /**
+     * The id of the newest agent reply in this thread. Computed from the log on
+     * read, never stored: a client compares it with what it last saw to show
+     * an unread dot.
+     */
+    lastReplyId?: number;
 }
 /**
  * An agent's job, in your words. Free text: call an agent "architect",
@@ -58,6 +104,15 @@ export interface AgentConfig {
     options?: Record<string, unknown>;
     /** Override the ADE's native memory files to import into the shared brain. */
     memoryFiles?: string[];
+    /** Off agents stay in the roster but aren't spawned and can't hold the baton. Default on. */
+    enabled?: boolean;
+    /**
+     * Standing instructions for this agent in this project ("prefer pnpm",
+     * "never touch migrations"), sent ahead of every turn it takes.
+     */
+    instructions?: string;
+    /** A picture for this agent, as a small image data URL (≤ ~96px). */
+    avatar?: string;
 }
 /** One ADE's native memory pulled into the unified brain. */
 export interface MemorySource {
@@ -85,6 +140,20 @@ export type RouteStepSpec = string | {
     step: string;
     role?: string;
     instruction?: string;
+    /**
+     * Where to go when THIS step errors: an earlier step's id/role, to retry
+     * from there instead of failing the route. "review fails → back to
+     * execute" as data. Guarded by RouteState.maxLoops.
+     */
+    onFail?: string;
+    /**
+     * Run this step only when the previous turn meets this condition:
+     * `changed>10`, `lines>200`, `touched:src/db/**`. Mechanical facts from
+     * the turn's diff, never a judgement — "send big changes to a reviewer
+     * and small ones straight on" without a person deciding each time.
+     * See core/step-conditions.ts. Written inline too: `reviewer?lines>200`.
+     */
+    when?: string;
 };
 /** How shared memory is rendered on handoff. */
 export interface ProjectionConfig {
@@ -95,6 +164,9 @@ export interface ProjectionConfig {
 }
 /** The brain's phase-2 extractor — learning from each turn. See core/brain-extract.ts. */
 export interface BrainConfig {
+    /** Opt into versioned native continuity (SQLite, Codex/Claude only).
+     * Legacy memory/extraction remains available when false. */
+    continuity?: boolean;
     /**
      * Who reads finished turns for memory:
      *   "auto" (default) — a small Claude, when the CLI is available; a no-op when not.
@@ -103,16 +175,152 @@ export interface BrainConfig {
     extractor?: "auto" | "off";
     /** Model for the extractor call; small+fast is right. */
     model?: string;
+    /**
+     * The dense retrieval channel — the one that can follow a synonym.
+     *
+     * Off by default, and deliberately not a dependency: the 23MB model needs a
+     * ~470MB ONNX runtime that Loom asks you to install rather than shipping to
+     * everyone. With it missing, retrieval is the three lexical channels it has
+     * always been. See core/semantic.ts.
+     */
+    semantic?: boolean;
 }
+import type { ServerConfig } from "./core/servers.js";
 export interface ProjectConfig {
     name: string;
     agents: AgentConfig[];
+    /** Agent Teams: named crews of roster agents with roles (core/crew.ts). */
+    crews?: import("./core/crew.js").CrewConfig[];
+    /** Loop watch: an agent re-running the same failing command. "notify" (default), "nudge" (stop it and tell it to step back), or "off". */
+    watchdog?: {
+        auto?: "notify" | "nudge" | "off";
+    };
+    /** Blast-Radius Shield: a destructive command an agent runs. "notify" (default), "stop" (stop the turn; the default on a night shift), or "off". */
+    shield?: {
+        auto?: "notify" | "stop" | "off";
+    };
+    /** Quota Relay: who carries on when an agent runs out of quota (daemon/runtime/relay.ts). */
+    relay?: import("./daemon/runtime/relay.js").RelayConfig;
+    /** Proof: how an agent's "done" is checked (daemon/proof.ts). */
+    proof?: import("./daemon/proof.js").ProofConfig;
     /** Agent that receives messages when nobody holds the baton. */
     defaultAgent?: string;
     /** Named multi-hop pipelines; steps are agent ids/roles, optionally with instructions. */
     routes?: Record<string, RouteStepSpec[]>;
     projection?: ProjectionConfig;
     brain?: BrainConfig;
+    /** Which SKILL.md skills are injected into the briefing, by skill id. */
+    skills?: Record<string, boolean>;
+    /** MCP servers this project can offer agents (mirrors the Anthropic API shape). */
+    mcps?: McpServerConfig[];
+    /**
+     * Dev servers Loom can run for this project — the thing the Browser tab
+     * previews. Suggested from package.json on init, confirmed by a person;
+     * nothing starts on its own. See core/servers.ts.
+     */
+    servers?: ServerConfig[];
+    /**
+     * Spend caps for this project. Daily per-agent budgets live in the daemon's
+     * own config; this is the one a single goal may spend before it stops and
+     * says so.
+     */
+    budgets?: {
+        perGoalUsd?: number;
+    };
+    /**
+     * How many orchestra goals may run at once. One by default — two goals
+     * editing the same files is a merge nobody can explain. Above one, a goal
+     * starts only when its paths can't collide with what's running
+     * (core/goal-lanes.ts).
+     */
+    maxConcurrentGoals?: number;
+    /** Safety nets. Off by default. */
+    safety?: {
+        /** Checkpoint brain+board+config to .loom/snapshots before every route. */
+        snapshotBeforeRoutes?: boolean;
+    };
+    /** Git policies. Off by default — committing is a policy, not a mechanic. */
+    git?: {
+        /** Commit each turn's changes as they land, agent as co-author. */
+        commitPerTurn?: boolean;
+        /** Dragging a card to Working checks out task/<id>-<slug>. */
+        branchPerTask?: boolean;
+        /**
+         * Each adapter works in its own worktree on branch agent/<id>, so parallel
+         * edits can't collide in the filesystem. Merging is manual unless
+         * `mergeOnHandoff` is on; `git merge agent/<id>` is always available.
+         */
+        worktreePerAgent?: boolean;
+        /**
+         * With worktrees on: when the baton passes A → B, merge `agent/A` into B's
+         * checkout so the work travels with the baton. Refuses rather than
+         * guesses — uncommitted work on either side, or a merge already in
+         * progress, is reported instead of merged. A conflict is left in the tree
+         * to be resolved and stops a route. See core/worktree-merge.ts.
+         */
+        mergeOnHandoff?: boolean;
+        /**
+         * What happens to finished work, in one setting (the status-bar toggle):
+         *   none   — nothing is committed for you; orchestra work waits on its branch
+         *   commit — each turn is committed; a finished orchestra merges into your branch
+         *   push   — commit, then push
+         *   pr     — commit; a finished orchestra pushes its own branch and opens a PR
+         * Implies commitPerTurn for everything but "none".
+         */
+        delivery?: GitDelivery;
+    };
+    /** Team Hub sharing — see ProjectTeamShare. */
+    team?: ProjectTeamShare | null;
+}
+export type GitDelivery = "none" | "commit" | "push" | "pr";
+/**
+ * Team sharing for a project (docs/teams-architecture.md, D8). Set by an
+ * explicit "Share with team"; `optOut` records an explicit "don't", which
+ * beats the auto-match on the project's git remote.
+ */
+export interface ProjectTeamShare {
+    teamId?: string;
+    repo?: string;
+    optOut?: boolean;
+}
+export declare const GIT_DELIVERIES: GitDelivery[];
+/** One MCP server, in the shape the Anthropic API's `mcp_servers` accepts. */
+export interface McpServerConfig {
+    name: string;
+    url: string;
+    description?: string;
+    icon?: string;
+    /**
+     * Did the server answer a bounded probe just now? Measured by
+     * core/mcp.ts#probeMcpServer when the list is served — NOT "has a url typed
+     * into it", which is what this used to mean and was never a connection.
+     * Absent when nothing has probed it (e.g. straight off disk).
+     */
+    connected?: boolean;
+    /** When `connected` was last measured (epoch ms), so a stale badge is spottable. */
+    probedAt?: number;
+    enabledForSession?: boolean;
+    /**
+     * Remote transport. Defaults to http; /sse endpoints are detected. Only
+     * meaningful alongside `url`.
+     */
+    transport?: "http" | "sse";
+    /**
+     * Extra HTTP headers for a remote server — an `Authorization: Bearer …` for a
+     * hosted endpoint that needs one. Only meaningful alongside `url`; see
+     * core/mcp.ts for which CLIs are known to honour them.
+     */
+    headers?: Record<string, string>;
+    /** A local (stdio) server instead of a remote one: the process to run. */
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    /**
+     * The catalog provider this row was installed from ("github", "linear", …),
+     * when it came from one. A stable key for a bundled logo — NOT a claim about
+     * the server, and absent for anything typed in by hand.
+     */
+    slug?: string;
 }
 export type RouteStatus = "running" | "waiting_human" | "completed" | "failed" | "aborted";
 export type RouteMode = "static" | "dynamic";
@@ -137,6 +345,17 @@ export interface RouteState {
     updatedAt: number;
     reason?: string;
     pendingQuestion?: string;
+    /** onFail jump budget: re-entries consumed so far, and the cap. */
+    loops?: number;
+    maxLoops?: number;
+    /** Parallel to steps: where each step jumps on error (static routes). */
+    stepOnFail?: Array<string | null>;
+    /**
+     * Parallel to steps: the condition each step needs from the previous turn,
+     * or null when it always runs. Stored as written so the thread can say why
+     * a step was skipped in the same words the route was defined in.
+     */
+    stepWhen?: Array<string | null>;
     /** Project cost total when the route started (internal baseline). */
     costStartUsd?: number;
     /** Spend attributed to this route (set when it ends). */
@@ -149,20 +368,116 @@ export interface ProjectInfo {
 }
 export interface SendInput {
     text: string;
+    /**
+     * The conversation this turn belongs to (default: the main chat). Provider
+     * agents keep one native session per chat, so each conversation has its own
+     * native history.
+     */
+    chat?: string;
+    /**
+     * "plan": the agent investigates and proposes a plan without changing
+     * anything, in its own plan mode (Codex collaboration mode, Claude's plan
+     * permission mode). Provider agents only.
+     */
+    interactionMode?: "default" | "plan";
+    /** App-owned conversation binding; native IDs never cross chat/workspace scopes.
+     * Context is injected into the ordinary input on every invocation. */
+    continuity?: {
+        runId: string;
+        bindingId: string;
+        sessionEpoch: number;
+        nativeSessionId: string | null;
+        context: string;
+    };
     /** One-shot handoff briefing injected alongside this turn. */
     briefing?: string;
+    /**
+     * Use this model for this turn.
+     *
+     * Only set for adapters that can honour it — the runtime checks before it
+     * sends, so an adapter receiving this can act on it rather than wonder. A
+     * CLI that bakes its model into a spawned process is never handed one.
+     */
+    model?: string;
+    /**
+     * The project's MCP servers, rendered for this turn (see core/mcp.ts). The
+     * runtime builds it, the adapters that have a real flag for it pass it to
+     * their CLI, and the ones that don't ignore it — an adapter with no MCP
+     * surface must not pretend otherwise. The file is deleted when the turn ends,
+     * so an adapter may only use it during `send`.
+     */
+    mcp?: McpTurnConfig;
+}
+/** What an adapter needs to put this project's MCP servers in front of its CLI. */
+export interface McpTurnConfig {
+    /** Path to a `{"mcpServers": {…}}` document, alive for this turn only. */
+    configPath: string;
+    /** The same servers, for a CLI that takes config values rather than a file. */
+    servers: ResolvedMcpServer[];
+}
+/**
+ * One server as an MCP config document wants it: a remote endpoint, or a local
+ * process. `type` is spelled out even for stdio (where the CLIs infer it from
+ * `command`) so a generated file reads unambiguously.
+ */
+export type McpServerEntry = {
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+} | {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
+/** A configured server that survived selection, keyed for the config document. */
+export interface ResolvedMcpServer {
+    /** The key under `mcpServers` — a sanitised form of the display name. */
+    key: string;
+    /** The name as configured, for events and API responses. */
+    name: string;
+    entry: McpServerEntry;
 }
 export interface AdapterEvent {
     kind: EventKind;
     payload: Record<string, unknown>;
 }
+/**
+ * A piece of a reply that is still being written.
+ *
+ * Shown live and never logged: the finished `message` event is the record,
+ * and this is only the view of it arriving. Logging every token would put a
+ * few hundred rows in the event log for one paragraph, and a reader who opens
+ * the thread later wants the paragraph, not its typing.
+ */
+export interface StreamDelta {
+    text: string;
+    /** The model's working-out rather than its answer. */
+    reasoning?: boolean;
+}
+/** A StreamDelta placed: which agent is writing it, in which thread. */
+export interface LiveText extends StreamDelta {
+    agentId: string;
+    chat: string;
+    /**
+     * Where this piece starts in what the agent has typed since its last
+     * finished message (of the same kind). A window that opens mid-reply gets
+     * the text so far from the log route and uses this to stitch on without
+     * repeating or dropping characters.
+     */
+    off?: number;
+}
 export interface AgentCapabilities {
     tier: AgentTier;
-    send: boolean;
-    stream: boolean;
-    injectMemory: boolean;
-    interrupt: boolean;
-    diff: boolean;
+    /**
+     * Does this agent's CLI really accept MCP server config for a turn?
+     *
+     * Off unless verified against the actual command line, because the runtime
+     * only bothers resolving and writing a config for agents that can be handed
+     * one. Claiming it for an agent that ignores the flag would show MCP servers
+     * as "in use" by something that never saw them.
+     */
+    mcp: boolean;
 }
 export interface BaseAgent {
     readonly id: string;
@@ -176,6 +491,8 @@ export interface BaseAgent {
     injectMemory(projection: string): Promise<void>;
     /** Subscribe to live events; returns unsubscribe. */
     onEvent(cb: (e: AdapterEvent) => void): () => void;
+    /** Subscribe to a reply as it's written (see StreamDelta); returns unsubscribe. */
+    onStream?(cb: (d: StreamDelta) => void): () => void;
 }
 /** Full-duplex adapter — may hold the baton. */
 export interface Adapter extends BaseAgent {
@@ -184,6 +501,8 @@ export interface Adapter extends BaseAgent {
     /** Working-tree changes attributable to the agent (porcelain-ish). */
     diff(): Promise<string>;
     busy(): boolean;
+    /** Answer a structured question the agent's turn is blocked on (a needs_input with a requestId). */
+    respondToUserInput?(chat: string, requestId: string, answers: Record<string, unknown>): Promise<void>;
 }
 /** Read-mostly bridge — never holds the baton (GUI agents). */
 export interface Bridge extends BaseAgent {
@@ -196,12 +515,54 @@ export interface AgentStatus {
     role: AgentRole;
     tier: AgentTier;
     available: boolean;
+    /** Native continuity: the harness CLI version seen by the last health probe. */
+    cliVersion?: string | null;
     busy: boolean;
     holdsBaton: boolean;
     /** The model override in effect, or "" for the CLI's own default. */
     model: string;
+    /** Switched on? An off agent stays in the roster but isn't spawned. */
+    enabled?: boolean;
+    /** Permission mode in effect: bypass | auto | ask. See core/permissions.ts. */
+    permissions?: string;
+    /** Standing instructions sent ahead of every turn (see AgentConfig). */
+    instructions?: string;
+    /** Model agents: sampling overrides (absent = the provider's default). */
+    sampling?: {
+        temperature?: number;
+        maxTokens?: number;
+    };
+    /** The agent's own picture, when one was set. */
+    avatar?: string;
+    /** Native harnesses: tokens in context and the model's window, from the last report. */
+    context?: AgentContextUsage | null;
+    /** Native harnesses: the provider account's usage-limit windows, from the last report. */
+    limits?: ProviderLimits | null;
+}
+export interface AgentContextUsage {
+    usedTokens: number;
+    /** The model's context window, when the harness has said. */
+    maxTokens: number | null;
+    /** The harness is compacting its context right now. */
+    compacting: boolean;
+    /** When the harness last finished compacting (ms). */
+    compactedAt: number | null;
+    at: number;
+}
+export interface ProviderLimits {
+    provider: string;
+    windows: Array<{
+        id: string;
+        usedPercent: number;
+        windowMinutes?: number;
+        resetsAt?: number;
+    }>;
+    /** The window whose limit was hit, when one was. */
+    reached: string | null;
+    at: number;
 }
 export interface ProjectStatus {
+    continuity?: boolean;
     id: string;
     name: string;
     dir: string;
@@ -221,16 +582,34 @@ export interface ProjectStatus {
     routeNames?: string[];
     /** Lifetime spend across all agents in this project (USD). */
     costUsd?: number;
+    /**
+     * Agents a firing alert has paused (self-heal), keyed by agent id. Carried in
+     * the status payload and not only in state on disk, so a client can render
+     * "paused" rather than showing an agent that will refuse every prompt.
+     */
+    quarantine?: Record<string, {
+        reason: string;
+        since: number;
+        displaced: boolean;
+    }>;
+    /** The live or latest orchestra run, compact. See core/orchestra.ts. */
+    orchestra?: Record<string, unknown> | null;
+    /** The project's folder no longer exists (moved or deleted). */
+    missing?: boolean;
 }
 export interface AgentCost {
     agentId: string;
     usd: number;
     turns: number;
     ms: number;
+    tokensIn: number;
+    tokensOut: number;
 }
 export interface CostSummary {
     totalUsd: number;
     turns: number;
     totalMs: number;
+    tokensIn: number;
+    tokensOut: number;
     byAgent: AgentCost[];
 }

package/dist/types.js

@@ -12,6 +12,7 @@
 export const MAIN_CHAT = "main";
 /** Roles Loom suggests when it sets a project up. Only suggestions. */
 export const SUGGESTED_ROLES = ["planner", "executor", "reviewer", "general"];
+export const GIT_DELIVERIES = ["none", "commit", "push", "pr"];
 export function isAdapter(a) {
     return a.capabilities.tier === "adapter";
 }

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoCH;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC;AA4ChC,uEAAuE;AACvE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,CAAU,CAAC;AAsKvF,MAAM,UAAU,SAAS,CAAC,CAAW;IACnC,OAAO,CAAC,CAAC,YAAY,CAAC,IAAI,KAAK,SAAS,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0DH;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC;AAiFhC,uEAAuE;AACvE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,CAAU,CAAC;AAsMvF,MAAM,CAAC,MAAM,cAAc,GAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AA8O9E,MAAM,UAAU,SAAS,CAAC,CAAW;IACnC,OAAO,CAAC,CAAC,YAAY,CAAC,IAAI,KAAK,SAAS,CAAC;AAC3C,CAAC"}

package/dist/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Loom's version, from package.json — one source, so the CLI, the TUI and the
+ * daemon's API can't drift from the release (they each said 0.1.0 by hand).
+ * dist/version.js sits one level below package.json in the repo and in the
+ * desktop app's staged daemon alike.
+ */
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,16 @@
+/**
+ * Loom's version, from package.json — one source, so the CLI, the TUI and the
+ * daemon's API can't drift from the release (they each said 0.1.0 by hand).
+ * dist/version.js sits one level below package.json in the repo and in the
+ * desktop app's staged daemon alike.
+ */
+import fs from "node:fs";
+export const VERSION = (() => {
+    try {
+        return String(JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0.0.0");
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,SAAS,CAAC;AAEzB,MAAM,CAAC,MAAM,OAAO,GAAW,CAAC,GAAG,EAAE;IACnC,IAAI,CAAC;QACH,OAAO,MAAM,CAAE,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAA0B,CAAC,OAAO,IAAI,OAAO,CAAC,CAAC;IAC/I,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,OAAO,CAAC;IACjB,CAAC;AACH,CAAC,CAAC,EAAE,CAAC"}