@loompad/cli 0.1.0 → 1.1.1

package/dist/daemon/runtime.d.ts

@@ -1,40 +1,129 @@
-/**
- * ProjectRuntime — one live project inside the daemon: its event log, its
- * agents, and its baton. All mutations flow through here so the log stays
- * the single source of truth.
- */
-import type { AgentConfig, AnyAgent, ChatInfo, CostSummary, ProjectConfig, ProjectInfo, ProjectStatus, UnifiedMemory } from "../types.js";
-import type { RouteState, RouteStepSpec, RouterKind } from "../types.js";
 import { BatonManager } from "../core/baton.js";
+import { type Hit, type RetrieveOpts } from "../core/brain-index.js";
 import { Brain } from "../core/brain.js";
+import * as checkpoints from "../core/checkpoint.js";
 import { EventLog } from "../core/eventlog.js";
-import { RouteEngine } from "../core/routes.js";
+import { NativeUsage } from "./runtime/native-usage.js";
+import { OrchestraEngine, type OrchestraCoordinator } from "../core/orchestra.js";
+import { CrewEngine } from "../core/crew.js";
+import { type Loop } from "../core/loops.js";
+import { QuotaRelay } from "./runtime/relay.js";
+import { ProofRunner } from "./proof.js";
+import { NightShift } from "./shift.js";
+import { type PermissionMode } from "../core/permissions.js";
+import { type PreviewProxy } from "../core/preview-proxy.js";
+import { PromptQueue, type QueueCondition, type QueueInput, type QueueItem, type QueueState, type QueueTarget } from "../core/prompt-queue.js";
 import { type BoardTask } from "../core/registry.js";
+import { RouteEngine } from "../core/routes.js";
+import { Servers } from "../core/servers.js";
+import { type SkillInstallResult } from "../core/skill-install.js";
+import { type SkillCatalogEntry, type SkillManifest } from "../core/skills.js";
+import { type TurnFacts } from "../core/step-conditions.js";
+import { type TeamPolicy } from "../core/team-policy.js";
+import { type MergeOutcome } from "../core/worktree-merge.js";
 import { type WorkingTree } from "../core/worktree.js";
+import { type AgentDecision, type DecisionStats } from "../observability/decisions.js";
+import type { AgentConfig, AnyAgent, ChatInfo, CostSummary, McpServerConfig, ProjectConfig, ProjectInfo, ProjectStatus, RouteState, RouteStepSpec, RouterKind, UnifiedMemory } from "../types.js";
+import { type GitDelivery } from "../types.js";
+import { ServerFrame, TeamBrainHook } from './runtime-support.js';
+import { type TurnOptions, type TurnResult } from './runtime/turns.js';
+import { ContinuityEngine } from "../core/continuity/engine.js";
+import { HarnessMonitor } from "../core/continuity/capabilities.js";
+import { type LiveFrame } from "../providers/live.js";
+import { type AgentCheck } from "../adapters/base.js";
+import type { LiveText } from "../types.js";
+export { BudgetExceededError, CLOCK_TICK_MS, LOOM_ASK_TIMEOUT_MESSAGE, LOOM_ASK_TIMEOUT_MS, LoomAskTimeoutError, QuarantinedError, type ServerFrame, type TeamBrainHook, activityLine, planModeBriefing, relativeToProject, withLoomAskTimeout } from './runtime-support.js';
 export declare class ProjectRuntime {
+    private readonly accounting;
+    private readonly briefings;
+    private readonly queueCoordinator;
+    private readonly turns;
     readonly info: ProjectInfo;
     readonly config: ProjectConfig;
     readonly log: EventLog;
+    private readonly conversations;
     readonly baton: BatonManager;
     readonly routes: RouteEngine;
+    /** One orchestrator, many parallel workers — see core/orchestra.ts. */
+    readonly orchestra: OrchestraEngine;
+    /** Agent Teams: crews of agents with roles, one goal at a time (core/crew.ts). */
+    readonly crews: CrewEngine;
+    /** Loop watch: an agent stuck re-running the same failing command (core/loops.ts). */
+    private readonly loops;
+    /** agent × chat already nudged since a person last spoke there: a second loop is only reported. */
+    private readonly nudged;
+    /** agent × chat × command already flagged this turn by the shield. */
+    private readonly shielded;
+    /** Quota Relay: an agent out of quota mid-task hands its work to the next. */
+    readonly relay: QuotaRelay;
+    /** Proof: checks an agent's "done" against what ran and a clean re-run of the tests. */
+    readonly proofs: ProofRunner;
+    /** Night Shift: a line of tasks run while you're away, then one report (daemon/shift.ts). */
+    readonly shifts: NightShift;
+    /** Adapter kinds installed on this machine, probed once at open. */
+    private installedKinds;
     /** Memory as units — see core/brain.ts. Reads and writes through `log`. */
     readonly brain: Brain;
-    private agents;
-    private startedAgents;
+    continuity: ContinuityEngine | null;
+    /** Native harness reachability, polled while native continuity is on. */
+    readonly harnesses: HarnessMonitor;
+    /** Latest context and usage-limit readings from native harnesses. */
+    readonly nativeUsage: NativeUsage;
+    private readonly agentLifecycle;
+    private get agents();
     private configMtime;
-    /**
-     * Which conversation each agent's current turn belongs to. Set when a turn
-     * starts and left in place afterwards — an agent's trailing events (a late
-     * run_complete, a diff) still belong to the chat that prompted them.
-     */
-    private turnChat;
+    private journalFailure;
+    /** What you've lined up, run one at a time — see core/prompt-queue.ts. */
+    readonly queue: PromptQueue;
+    /** This project's dev servers — see core/servers.ts. */
+    readonly servers: Servers;
+    /** One preview proxy per server — see core/preview-proxy.ts. */
+    private proxies;
+    private serverListeners;
+    private streamListeners;
+    private liveListeners;
+    /** Streamed text and tool progress from provider agents, coalesced for clients. Not persisted. */
+    private readonly live;
     private constructor();
     static open(info: ProjectInfo): Promise<ProjectRuntime>;
-    private costs;
-    private costsByAgent;
     private rehydrateCosts;
     private trackCost;
     costSummary(): CostSummary;
+    budgets(): Record<string, number>;
+    setBudget(agentId: string, usdPerDay: number): Record<string, number>;
+    spendTodayFor(agentId: string, now?: number): number;
+    costSeries(days?: number, now?: number): Array<{
+        day: string;
+        usd: number;
+        turns: number;
+        tokensIn: number;
+        tokensOut: number;
+        byAgent: Record<string, {
+            usd: number;
+            turns: number;
+            tokensIn: number;
+            tokensOut: number;
+        }>;
+    }>;
+    budgetStatus(now?: number): Record<string, {
+        budgetUsd: number;
+        spentTodayUsd: number;
+        over: boolean;
+    }>;
+    private enforceQuarantine;
+    private enforceBudget;
+    private liftBudgetPause;
+    quarantined(): Record<string, {
+        reason: string;
+        since: number;
+        displaced: boolean;
+    }>;
+    quarantine(agentId: string, reason: string, displaced: boolean, now?: number): void;
+    unquarantine(agentId: string): {
+        reason: string;
+        since: number;
+        displaced: boolean;
+    } | null;
     /** Has .loom/config.json changed since this runtime was opened? */
     configStale(): boolean;
     /**
@@ -44,6 +133,27 @@ export declare class ProjectRuntime {
      * on an agent's turn to finish. Nothing is torn down: a role is a name, not
      * a capability, so no adapter needs restarting.
      */
+    /** An agent's picture: a small PNG/JPEG/WebP data URL, or null to clear. */
+    setAgentAvatar(agentId: string, dataUrl: string | null): {
+        id: string;
+        avatar: string | null;
+    } | null;
+    /**
+     * Ask an agent whether it's ready — installed, signed in, model listed —
+     * without sending it a prompt (see AdapterBase.selfCheck).
+     */
+    checkAgent(agentId: string): Promise<{
+        ok: boolean;
+        ms: number;
+        checks: AgentCheck[];
+    } | null>;
+    /** Standing instructions for an agent; empty clears them. */
+    setAgentInstructions(agentId: string, text: string): {
+        id: string;
+        instructions: string;
+    } | null;
+    /** The block an agent's standing instructions ride in, ahead of its turn. */
+    agentInstructions(agentId: string): string;
     setAgentRole(agentId: string, role: string): {
         id: string;
         role: string;
@@ -59,6 +169,8 @@ export declare class ProjectRuntime {
         brain?: {
             extractor?: "auto" | "off";
             model?: string;
+            semantic?: boolean;
+            continuity?: boolean;
         };
         projection?: {
             mode?: "template" | "llm";
@@ -66,6 +178,16 @@ export declare class ProjectRuntime {
             timeoutMs?: number;
         };
         defaultAgent?: string;
+        git?: {
+            commitPerTurn?: boolean;
+            branchPerTask?: boolean;
+            worktreePerAgent?: boolean;
+            mergeOnHandoff?: boolean;
+            delivery?: string;
+        };
+        safety?: {
+            snapshotBeforeRoutes?: boolean;
+        };
     }): ProjectConfig;
     /**
      * The slice of config the Settings screen edits, read back for display: the
@@ -78,12 +200,24 @@ export declare class ProjectRuntime {
         brain: {
             extractor: "auto" | "off";
             model: string;
+            semantic: boolean;
+            continuity: boolean;
         };
         projection: {
             mode: "template" | "llm";
             model: string;
         };
         defaultAgent: string;
+        git: {
+            commitPerTurn: boolean;
+            branchPerTask: boolean;
+            worktreePerAgent: boolean;
+            mergeOnHandoff: boolean;
+            delivery: GitDelivery;
+        };
+        safety: {
+            snapshotBeforeRoutes: boolean;
+        };
         agents: Array<{
             id: string;
             kind: string;
@@ -104,7 +238,32 @@ export declare class ProjectRuntime {
     addAgent(kind: string, opts?: {
         id?: string;
         role?: string;
+        options?: Record<string, unknown>;
     }): AgentConfig;
+    /**
+     * The next free instance id for a kind: `codex`, then `codex-2`, `codex-3`.
+     *
+     * The bare kind stays the first instance's id so existing projects, configs
+     * and route specs that name `codex` keep meaning what they meant.
+     */
+    private nextInstanceId;
+    /** How many instances of each kind the roster holds. */
+    instanceCounts(): Record<string, number>;
+    /**
+     * Where this agent works: its own worktree when the project opted in, the
+     * shared tree otherwise.
+     *
+     * With git.worktreePerAgent on, each adapter gets a sibling checkout on its
+     * own branch (agent/<id>), so two agents editing at once cannot collide in
+     * the filesystem. The trade is stated where it's decided: merging is
+     * MANUAL in this version — the branches are ordinary git branches and
+     * `git merge agent/<id>` is the handoff of record. Auto-merge on baton
+     * handoff is a different feature with different failure modes (conflicts
+     * mid-handoff), deliberately not smuggled in here.
+     */
+    private agentDirs;
+    agentDir(agentId: string): string;
+    private ensureAgentWorktree;
     /**
      * Create one agent and subscribe to it, exactly as the constructor does.
      *
@@ -127,18 +286,172 @@ export declare class ProjectRuntime {
      * Point an agent at a different model.
      *
      * The model is read once, when the adapter is constructed (createAgent hands
-     * it cfg.options), so changing it means building a fresh agent — which drops
-     * the CLI session the old one was resuming. That's the right behaviour for a
-     * model switch: continuing one model's conversation on another model is not a
-     * thing the underlying CLIs support anyway. Refused mid-turn, because swapping
-     * the process out from under a running turn would strand it.
+     * it cfg.options), so changing it means building a fresh adapter instance.
+     * Native resume data stays persisted; each adapter decides whether its harness
+     * can reuse it. Refused while a turn is preparing or running, because swapping
+     * the process out from under that turn would strand it.
      *
      * An empty model clears the override, so the CLI falls back to its own default
      * — the honest "Default" the picker offers.
      */
-    setAgentModel(agentId: string, model: string): AgentConfig;
+    setAgentModel(agentId: string, model: string, provider?: string): AgentConfig;
+    /**
+     * A model agent's sampling: temperature (0–2) and the reply's token cap.
+     * Null clears one back to the provider's default. Rebuilt like a model
+     * switch, because the adapter reads them when it's built.
+     */
+    setAgentSampling(agentId: string, s: {
+        temperature?: number | null;
+        maxTokens?: number | null;
+    }): AgentConfig;
+    /**
+     * Choose how much an agent may do without asking: bypass | auto | ask.
+     *
+     * Same shape as setAgentModel — the mode is read when the adapter is built
+     * (it becomes CLI flags, or the env of opencode's server), so the agent is
+     * rebuilt. Refused mid-turn for the same reason.
+     */
+    setAgentPermissions(agentId: string, mode: PermissionMode): AgentConfig;
     /** Write the roster, without tripping our own staleness check. */
     private saveConfig;
+    /**
+     * Where skills live — every layout, not just ours.
+     *
+     * See core/skills.ts#discoverSkillRoots for the list and the precedence. This
+     * used to be two hardcoded directories, which meant a machine with sixty
+     * skills in `~/.claude` reported the one that shipped in this repo.
+     */
+    private skillRoots;
+    /** The directory this project's own skills are installed into. */
+    private ownSkillsDir;
+    /** All available skills with this project's enabled state. */
+    getSkills(): SkillManifest[];
+    /**
+     * The catalog the picker renders: every discoverable skill, without the body.
+     *
+     * The bodies are the entire point of a skill and also the reason this exists
+     * separately from `getSkills()` — a machine with sixty installed skills has
+     * megabytes of markdown, and a list screen needs none of it.
+     *
+     * `installed` means "this file is inside the project directory", which is the
+     * same question `removeSkill` asks: those are the only ones Loom put there
+     * and the only ones it may delete.
+     */
+    skillsCatalog(): SkillCatalogEntry[];
+    /**
+     * Install a skill from a local directory or a git remote, into this project.
+     *
+     * Throws SkillInstallError for anything the user can fix (bad URL, unsafe id,
+     * a name that already exists) — the route turns those into a 400 with the
+     * message, because "invalid input" tells you nothing when the real answer is
+     * "that repo has no SKILL.md in it".
+     */
+    installSkill(input: {
+        gitUrl?: string;
+        dir?: string;
+        force?: boolean;
+    }): Promise<SkillInstallResult>;
+    /**
+     * Delete a project-installed skill from disk.
+     *
+     * Refused for anything outside the project. A skill in `~/.claude/skills` is
+     * the user's, shared with every other tool they run, and a project-scoped
+     * "remove" button that reached out and deleted it would be a data-loss bug
+     * dressed as a feature. The refusal says where the skill actually lives so
+     * the answer ("go delete it yourself, here") is in the message.
+     *
+     * The enabled flag goes with it: leaving `skills[id] = true` in config for a
+     * directory that no longer exists means the next turn's briefing silently
+     * loses a block the config still claims is on.
+     */
+    removeSkill(id: string): {
+        removed: true;
+        id: string;
+        path: string;
+    };
+    /**
+     * Switch one agent off (or back on) without taking it out of the roster.
+     *
+     * Refused while it holds the baton or is mid-turn, for the same reason
+     * `removeAgent` is: stopping it there would strand the lock on something that
+     * no longer exists, and the thread would show a turn nothing is running. The
+     * refusal names the fix rather than just saying no.
+     *
+     * Off really means off — the agent is stopped and dropped from the live map,
+     * not merely hidden. A roster entry that still answers is the kind of "off"
+     * that costs money.
+     */
+    setAgentEnabled(agentId: string, enabled: boolean): {
+        id: string;
+        enabled: boolean;
+    };
+    /** Enable/disable one skill for this project; returns the new enabled map. */
+    setSkillEnabled(id: string, on: boolean): Record<string, boolean>;
+    /** The ACTIVE SKILLS block to prepend to a briefing, or "" when none are on. */
+    activeSkillsBlock(): string;
+    private static DEFAULT_MCPS;
+    /** Configured MCP servers, merged over the built-in suggestions (deduped by name). */
+    getMcps(): McpServerConfig[];
+    /**
+     * The same list, with `connected` MEASURED rather than assumed.
+     *
+     * The old reading of that field was "a url is typed into this row", which the
+     * UI rendered as a green "connected" badge — a claim about a live connection
+     * made without ever opening one. Here every configured URL gets a bounded
+     * probe (see core/mcp.ts) and the answer is whatever came back. Rows with no
+     * URL aren't probed and report false, because "not configured" is not
+     * "connected".
+     */
+    /**
+     * Live health per configured MCP server, from the background poll.
+     *
+     * A server that died used to stay listed as connected, and its tools failed
+     * silently mid-turn — the agent just found them gone. The poll notices the
+     * transition, says so in the Console, and while a server is down it is left
+     * out of turn injection entirely: an absent tool the agent never saw beats a
+     * present tool that throws. When the server answers again it is included
+     * again automatically — that is the whole reconnect story for per-turn
+     * config files; there is no persistent connection to rebuild.
+     */
+    private mcpHealth;
+    private mcpTimer;
+    /** Poll every configured server once; log the transitions. */
+    pollMcpHealth(timeoutMs?: number): Promise<void>;
+    mcpHealthReport(): Record<string, {
+        up: boolean;
+        failures: number;
+        probedAt: number;
+    }>;
+    /**
+     * The servers a turn should carry: everything not known-down.
+     *
+     * Unknown (never probed — a fresh daemon, a just-added server) passes
+     * through; refusing a server nobody has measured would block first use on a
+     * poll that hasn't run yet. Only a measured, repeated failure withholds.
+     */
+    healthyMcps(): McpServerConfig[];
+    startMcpHealthLoop(intervalMs?: number): void;
+    getMcpsProbed(timeoutMs?: number): Promise<McpServerConfig[]>;
+    /** Add or update one MCP (by name); persists only the real (non-default) fields. */
+    upsertMcp(mcp: McpServerConfig): McpServerConfig[];
+    /**
+     * Remove a configured MCP server by name.
+     *
+     * `removed` is false when nothing was configured under that name, which the
+     * route answers with a 404 rather than a cheerful 200 — "deleted a thing that
+     * wasn't there" is the kind of success that hides a typo in a server name.
+     *
+     * Note what this does to a name that is also one of the built-in suggestion
+     * rows (GitHub, Slack, …): the *configuration* goes, and the suggestion comes
+     * back with an empty url, because those rows aren't installed servers, they're
+     * placeholders getMcps() merges in. That is the honest outcome — the server is
+     * gone, and what's left is an offer to add one — but a caller diffing the list
+     * for the name will still find it, so it should compare `url`/`command`.
+     */
+    removeMcp(name: string): {
+        removed: boolean;
+        mcps: McpServerConfig[];
+    };
     /**
      * Every conversation in this project, main first. Main is implicit: it's
      * always there and it owns every event written before chats existed, so it
@@ -146,68 +459,159 @@ export declare class ProjectRuntime {
      * haven't spoken in yet has no events to derive it from.
      */
     chats(): ChatInfo[];
-    createChat(title: string): ChatInfo;
-    renameChat(id: string, title: string): ChatInfo | null;
+    /** Which run, race, crew or import made each thread (ChatInfo.group). */
+    private chatGroups;
+    /** Pin, archive or file a thread. Main is always first and always there. */
+    setChatFlags(id: string, flags: {
+        pinned?: boolean;
+        archived?: boolean;
+        folder?: string | null;
+    }): ChatInfo | null;
+    /** Rate a reply up or down (0 clears). Main included. */
+    rateMessage(chatId: string, eventId: number, agent: string, v: number): Record<string, {
+        v: 1 | -1;
+        agent: string;
+    }> | null;
+    /** Every rating in every thread, per agent: how many up, how many down. */
+    ratingsByAgent(): Record<string, {
+        up: number;
+        down: number;
+    }>;
+    /** Star or unstar a message in a thread (main included). */
+    starMessage(chatId: string, eventId: number, on: boolean): number[] | null;
+    createChat(title: string, opts?: {
+        agentId?: string;
+        model?: string;
+    }): ChatInfo;
     /**
-     * Forget a conversation. Its events stay in the log — it's append-only, and
-     * the brain is built from all of them; deleting the thread you had with an
-     * agent shouldn't quietly rewrite what the project decided. The chat just
-     * stops being listed.
+     * May this thread be bound to this agent (and model)?
+     *
+     * A model bound to an agent that bakes its model into a spawned process
+     * would be a setting that silently did nothing, so it is refused here —
+     * where the person can act on it — rather than dropped at send time.
      */
+    private bindable;
+    /** Can this agent be handed a different model for one turn? */
+    private switchesModelPerTurn;
+    /** Bind (or unbind) who answers in a thread. */
+    setChatAgent(id: string, agentId: string | null, model?: string): ChatInfo | null;
+    /**
+     * Ask several models the same thing at once, each in its own thread.
+     *
+     * With free quota, asking five models costs what asking one costs, and
+     * "which of these is right" is a judgement a person makes in ten seconds.
+     * So: one prompt, one thread per model, all running at the same time.
+     *
+     * The agents are TRANSIENT — built for the ask, not added to the roster.
+     * Adding five agents to .loom/config.json to ask five questions would leave
+     * the project's roster as a record of everything anyone ever compared. What
+     * stays behind is the threads, which are the part worth keeping.
+     */
+    askModels(text: string, picks: Array<{
+        model: string;
+        provider?: string;
+    }>, opts?: {
+        title?: string;
+        briefing?: boolean;
+    }): Promise<Array<{
+        chat: string;
+        model: string;
+        provider: string;
+        agentId: string;
+    }>>;
+    /** What a thread has pinned, if anything. */
+    chatBinding(chat?: string): {
+        agentId?: string;
+        model?: string;
+    };
+    renameChat(id: string, title: string): ChatInfo | null;
     deleteChat(id: string): boolean;
     boardTasks(): BoardTask[];
     createTask(input: {
         title: string;
         column?: string;
         agent?: string;
+        blockedBy?: string[];
+        priority?: string | null;
+        due?: string | null;
     }): BoardTask;
+    /** Only blockers that exist. A link to a deleted card blocks nothing forever. */
+    private validBlockers;
+    /**
+     * A card is blocked while any of its blockers is not yet `ready`.
+     *
+     * `ready` is the board's own definition of done — the last column. Deleted
+     * blockers don't count (validBlockers keeps them out, and a stale link that
+     * survived a race reads as done rather than blocking forever).
+     */
+    taskBlockers(id: string): Array<{
+        id: string;
+        title: string;
+        column: string;
+    }>;
+    /** task/<id>-<slug>: stable id first so a retitle doesn't orphan the branch. */
+    /**
+     * What opening a PR for this card would push, and what it would run.
+     *
+     * Asked before anything happens, because pushing publishes: the person sees
+     * the branch, the commits and the exact command, and only then decides.
+     */
+    taskPrPlan(id: string): Promise<{
+        branch: string;
+        base: string;
+        commits: string[];
+        files: string[];
+        command: string;
+        ready: boolean;
+        why?: string;
+    }>;
+    /** Push the branch and open the PR — only ever from an explicit click. */
+    openTaskPr(id: string): Promise<{
+        url: string;
+        branch: string;
+    }>;
+    private taskBranchName;
     /** Move or retitle a card. Yours, so this is the real state — not a hint. */
     updateTask(id: string, patch: {
         title?: string;
         column?: string;
         agent?: string;
+        blockedBy?: string[];
+        priority?: string | null;
+        due?: string | null;
+        crew?: string;
+        goal?: string;
+        stage?: string;
+        claimedBy?: string;
     }): BoardTask | null;
+    /** Would `id` depending on `blockers` create a loop back to `id`? */
+    private wouldCycle;
     deleteTask(id: string): boolean;
     /** Any adapter mid-turn? (Hot reloads are deferred while work is in flight.) */
     anyBusy(): boolean;
     agent(id: string): AnyAgent;
     private ensureStarted;
-    /** Pre-turn porcelain snapshots, for per-prompt diff attribution. */
-    private preTurnTree;
-    /** After a turn: log which files that prompt changed (turn_diff), then learn. */
+    checkpoints(): Promise<checkpoints.Checkpoint[]>;
+    rewind(id: string): Promise<checkpoints.RestoreResult>;
+    /** Put one file back as a checkpoint had it (see checkpoints.restoreFile). */
+    rewindFile(id: string, file: string): Promise<Awaited<ReturnType<typeof checkpoints.restoreFile>>>;
+    turnFacts(agentId: string): Promise<TurnFacts>;
     private captureTurnDiff;
-    /**
-     * Phase 2: read a finished turn for durable memory.
-     *
-     * Fire-and-forget on purpose. A slow or missing extractor must never delay
-     * anything — extractFromTurn already swallows engine failures, and this is
-     * void-ed so even an unexpected throw can't escape into the event pipeline.
-     * Off entirely when config says so; a no-op when Claude isn't available.
-     */
+    private commitTurn;
     private extractMemory;
-    /**
-     * The transcript of the most recent turn in a chat: from the last human
-     * message to now — the user's ask and what the agent did in reply.
-     */
-    private gatherTurnText;
     workingTree(): Promise<WorkingTree>;
-    /** Freshly read every connected ADE's native memory from disk. */
-    private importedMemory;
-    /** The merged brain: decisions + imported ADE memories + shared context. */
     unifiedMemory(): UnifiedMemory;
-    /**
-     * Phase 3: the brain brief for a handoff — the memories relevant to the work
-     * in flight, compiled. Query is the recent conversation plus the files recent
-     * turns touched; scoped to the incoming agent; low-confidence memories are
-     * held back from injection (they stay visible in the Brain tab). Empty string
-     * when there's nothing relevant, so callers append it unconditionally.
-     */
-    private retrieveBrief;
-    /**
-     * Pull each ADE's native memory into the shared log. Idempotent — a source
-     * whose content hasn't changed since its last import is skipped, so this is
-     * safe to call on connect, on demand, or on a timer.
-     */
+    private brainBrief;
+    private memoryUse;
+    private memoryUseTimer;
+    private memoryUseFile;
+    memoryUsage(): Record<string, {
+        n: number;
+        at: number;
+    }>;
+    private noteMemoriesUsed;
+    private brainBriefFor;
+    searchBrain(opts: RetrieveOpts): Promise<Hit[]>;
     importMemories(): {
         imported: number;
         sources: string[];
@@ -219,6 +623,22 @@ export declare class ProjectRuntime {
      * memory automatically — it survives every future handoff projection.
      */
     private captureDecisions;
+    private decisionsFile;
+    /** An agent's declared role from config (planner/builder/reviewer/…), else its kind. */
+    agentRole(agentId: string): string;
+    /** How many turns this agent has completed (for the decision's turnIndex). */
+    private turnCountFor;
+    /**
+     * All captured decisions for this project, newest first, in today's shape —
+     * see normalizeStoredDecision for what that does to records written before
+     * a decision had to say where its confidence came from.
+     */
+    getDecisions(): AgentDecision[];
+    decisionStats(): DecisionStats;
+    /** Append decisions to the persisted store (kept oldest→newest on disk). */
+    storeDecisions(decisions: AgentDecision[]): void;
+    /** Mine decisions from a completed turn, persist them, surface on the Timeline. */
+    private captureAgentDecisions;
     /**
      * The persisted holder, unless it refers to an agent that has since been
      * removed from the config — ghost holders are cleared, not fatal.
@@ -254,28 +674,210 @@ export declare class ProjectRuntime {
         agentId: string;
         reply: string;
     }>;
-    sendMessage(text: string, agentId?: string, opts?: {
-        source?: "user" | "route";
+    /**
+     * A proxy in front of one server, so its page can talk to the app.
+     *
+     * One per server, reused while it points at the same place — restarting a
+     * dev server on the same port keeps the preview URL stable, which matters
+     * because the iframe is pointed at it.
+     */
+    previewProxy(name: string, target: string): Promise<PreviewProxy>;
+    /** Live server state and output, for the socket. Returns unsubscribe. */
+    /** Replies as they're written, for the socket. Returns unsubscribe. */
+    onStream(cb: (f: LiveText) => void): () => void;
+    /** The replies being typed right now in one thread (or all of them). */
+    liveNow(chat?: string): {
+        agentId: string;
+        chat: string;
+        text: string;
+        think: string;
+    }[];
+    private liveSoFar;
+    private liveText;
+    /** Streamed text and tool progress as a turn produces them; what finishes lands in the log. */
+    onLiveDelta(cb: (d: LiveFrame) => void): () => void;
+    /**
+     * Answer a structured question an agent is waiting on (a needs_input event
+     * with a requestId). The turn carries on with the answer.
+     */
+    answerQuestion(agentId: string, chat: string, requestId: string, answers: Record<string, unknown>): Promise<void>;
+    /** Structured questions agents are blocked on, by agent. */
+    private openQuestions;
+    /** Compact an agent's native context for a chat now, instead of waiting for the harness to. */
+    compactAgent(agentId: string, chat?: string): Promise<void>;
+    /**
+     * A plan turn on a provider agent runs in the agent's own plan mode, which
+     * changes nothing; Loom keeps the plan it proposes under plans/, as its plan
+     * mode always has.
+     */
+    private saveProposedPlan;
+    onServerEvent(cb: (f: ServerFrame) => void): () => void;
+    onQueueChange(cb: (q: QueueState) => void): () => void;
+    enqueue(input: QueueInput): QueueItem;
+    editQueued(itemId: string, patch: {
+        text?: string;
+        target?: QueueTarget;
+        plan?: boolean;
+        when?: QueueCondition | null;
+    }): QueueItem;
+    queueBlocker(item: QueueItem): string | null;
+    private watchClockConditions;
+    private holdQueueFor;
+    private releaseQuestionHold;
+    private kickQueue;
+    drainPromptQueue(): Promise<void>;
+    sendMessage(text: string, agentId?: string, opts?: TurnOptions): Promise<TurnResult>;
+    /**
+     * An agent is re-running the same failing command (or the same call over and
+     * over). Say so in its chat — a card with Stop / Nudge / Hand off — and push;
+     * with watchdog.auto "nudge", also stop the turn and tell it to step back.
+     */
+    private onLoop;
+    /**
+     * Blast-Radius Shield (core/shield.ts): a command an agent ran that can't be
+     * taken back — a force-push, a reset --hard, a recursive delete outside the
+     * project, a dropped table. Said at once, in its chat and as a push; with
+     * shield.auto "stop" (the default on a night shift) the turn is stopped too.
+     */
+    private shield;
+    /** The loop card's buttons: stop the turn, nudge the agent, or hand the task to another agent. */
+    actOnLoop(chat: string, agentId: string, action: "stop" | "nudge" | "handoff", to?: string, loop?: Loop): Promise<{
+        done: string;
+        to?: string;
+    }>;
+    private lastLoop;
+    /**
+     * Define or replace a named route.
+     *
+     * Routes were config you hand-edited: `ship` was built at init and everything
+     * else meant opening .loom/config.json. Validated against the CURRENT roster
+     * before saving — a route that names an agent this project doesn't have would
+     * sit in the file looking runnable and fail at its first step. Saving through
+     * here puts the team's pipeline in a version-controllable file instead of one
+     * person's shell history.
+     */
+    saveRoute(name: string, steps: RouteStepSpec[]): Record<string, RouteStepSpec[]>;
+    deleteRoute(name: string): Record<string, RouteStepSpec[]>;
+    /**
+     * Checkpoint the project's Loom-owned state: brain, board, config.
+     *
+     * For the moment before letting a fleet loose on something — a restorable
+     * "before". Deliberately NOT the working tree (git owns files and does it
+     * better) and NOT the event log (history is what happened; a restore that
+     * rewrote history would be a lie with a timestamp). Restoring brings back
+     * what the project knew, what was on the board, and how it was configured.
+     */
+    snapshot(): {
+        format: "loom-snapshot";
+        version: 1;
+        project: string;
+        takenAt: number;
+        brain: ReturnType<Brain["export"]>;
+        tasks: BoardTask[];
+        config: ProjectConfig;
+    };
+    /**
+     * Restore a snapshot. Config and board are replaced (that is what "restore"
+     * means for state you own); the brain is MERGED through the same dedupe as
+     * import, because memory is an append-only fold — a restore that silently
+     * forgot what was learned since the snapshot would be data loss wearing a
+     * seatbelt. What it knew then comes back; what it learned since stays.
+     */
+    restore(snap: ReturnType<ProjectRuntime["snapshot"]>): {
+        brain: {
+            added: number;
+            known: number;
+        };
+        tasks: number;
+    };
+    /** Turns older than this are presumed hung. Generous: real turns run long. */
+    static readonly STALE_TURN_MS: number;
+    staleSessions(now?: number): Array<{
+        agentId: string;
+        busyMs: number;
+    }>;
+    /**
+     * Put a hung session out of its misery and bring up a fresh one.
+     *
+     * Interrupt first — a process that responds to that wasn't hung, and gets to
+     * finish dying cleanly — then stop, drop, and respawn from config, exactly as
+     * a cold start would. The baton is released if the corpse held it, because a
+     * lock owned by a session that no longer exists refuses everyone forever.
+     */
+    reapSession(agentId: string): Promise<{
+        respawned: boolean;
+    }>;
+    /**
+     * How many subtasks may run at once in this project.
+     *
+     * A fan-out is the point of the feature and also the way to melt the machine:
+     * each child is a real CLI process with its own model calls. The cap is per
+     * project rather than global so one busy project can't starve the others.
+     */
+    private static readonly MAX_CONCURRENT_SUBTASKS;
+    /** In-flight subtasks, by the id minted when they started. */
+    private subtasks;
+    /** Subtasks currently running, for the status payload and the cap. */
+    liveSubtasks(): Array<{
+        id: string;
+        parent: string;
+        agentId: string;
+        task: string;
+    }>;
+    /**
+     * Run a subtask on a child agent, alongside the parent's turn.
+     *
+     * A turn used to be all-or-nothing: one agent, one prompt, one result. "Audit
+     * these twelve files" wanted twelve cheap readers, and the only way to get
+     * them was twelve sequential turns, each one taking the baton off the last.
+     *
+     * What makes a child a child rather than another turn:
+     *
+     *  - **It never touches the baton.** The parent still holds it, so a fan-out
+     *    cannot steal the conversation from the agent that started it, and the
+     *    human's next message still lands where they expect.
+     *  - **Its briefing is narrowed.** It gets the task and the project's shape,
+     *    not the parent's whole thread. Handing a child the full history is how
+     *    you pay twice for context the parent already read.
+     *  - **Its result is attributed and parented**, so the thread can indent it
+     *    under the turn that asked rather than interleaving it as a peer.
+     *
+     * Everything it learns still lands in the one project brain — a child that
+     * discovered something and took it to the grave would be worse than no child.
+     */
+    spawnSubAgent(parentAgentId: string, opts: {
+        agentId: string;
+        task: string;
         chat?: string;
     }): Promise<{
+        id: string;
         agentId: string;
     }>;
+    private subtaskBriefing;
     private defaultAdapterId;
-    /** Briefings are injected with the first turn after a handoff. */
-    private pendingBriefings;
     private consumePendingBriefing;
+    retryTurn(toAgentId: string): Promise<{
+        agentId: string;
+        retried: string;
+    }>;
     /**
-     * Explicit baton pass: interrupt the current holder if mid-turn, project
-     * the log into the target's namespaced memory, arm the one-shot briefing.
-     * A *manual* handoff cancels any active route — the human outranks it.
+     * Carry the outgoing agent's branch into the incoming agent's worktree.
+     *
+     * Only with both `worktreePerAgent` and `mergeOnHandoff` on, only when the
+     * two really are separate checkouts, and never when it would have to guess:
+     * see core/worktree-merge.ts for what it refuses. The outcome is a value so
+     * the handoff event and the briefing can both say what happened.
      */
+    private mergeForHandoff;
     handoff(to: string, opts?: {
         source?: "user" | "route";
     }): Promise<{
         from: string | null;
+        merge?: MergeOutcome;
     }>;
     interrupt(opts?: {
         source?: "user" | "route";
+        chat?: string;
     }): Promise<{
         interrupted: string | null;
     }>;
@@ -285,6 +887,17 @@ export declare class ProjectRuntime {
      * list of agent ids/roles. Undefined → the "ship" route if defined, else
      * every adapter in config order.
      */
+    /**
+     * Opt-in: checkpoint before a route starts.
+     *
+     * A route is exactly the moment you let a fleet loose — several agents,
+     * several turns, no human between hops. With safety.snapshotBeforeRoutes on,
+     * the brain+board+config land in .loom/snapshots/pre-route-<ts>.json first,
+     * so `loom restore` has a "before" without anyone having remembered to take
+     * one. Bounded: the newest five are kept, older ones pruned — a safety net,
+     * not an archive.
+     */
+    private snapshotBeforeRoute;
     startRoute(opts: {
         task: string;
         spec?: string | RouteStepSpec[];
@@ -294,6 +907,62 @@ export declare class ProjectRuntime {
     abortRoute(): Promise<RouteState>;
     routeState(): RouteState | null;
     status(): Promise<ProjectStatus>;
+    /**
+     * What every agent in this project is doing right now — for the fleet view.
+     *
+     * One row per roster agent (its thread, whether it's mid-turn, its last
+     * step) and one per orchestra task (worker sessions don't live in the
+     * roster). "Last step" is the newest event from that agent in that thread,
+     * summarised to a line: the tool it ran, the file it touched, what it said.
+     */
+    activity(): Record<string, unknown>;
+    /** The team member running this daemon (set by Team Link), for commit trailers. */
+    memberLogin: string | null;
+    /** Loom Teams, Phase 2: this project's team coordinator (set by Team Link). */
+    coordinator: OrchestraCoordinator | null;
+    /** Loom Teams, Phase 3: this project's share of the team brain (set by Team Link). */
+    teamBrain: TeamBrainHook | null;
+    /** The effective loom.team.json while shared with a team (D37); null when solo. */
+    teamPolicy: TeamPolicy | null;
+    private crewSpendLedger;
+    private crewSpendToday;
+    /**
+     * An agent's options under the team policy (D38): its permission mode capped
+     * at the ceiling. Plan mode can't be known when an agent is built, so
+     * `bypassRequiresPlan` treats it as off — the stricter reading.
+     */
+    private policyOptions;
+    /** Phase 5: this project is a runner's workspace for one goal (D70). */
+    runnerMode: boolean;
+    /** Adapter kinds usable on this machine: the roster's plus installed CLIs. */
+    usableKinds(): string[];
+    /**
+     * One question to one agent, outside any thread: the Phase 4 review (D60).
+     * Runs in `dir` (a throwaway directory, so a reviewer that forgets it's
+     * read-only can't touch the project), returns everything it said, and
+     * counts its cost like any turn.
+     */
+    askAgent(kind: string, dir: string, text: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<string>;
+    /** Share this project with a team, or record an explicit opt-out (null). */
+    setTeam(share: {
+        teamId: string;
+        repo: string;
+    } | null): void;
+    chatOf(agentId: string): string | undefined;
+    /** The live (or latest) orchestra run, compact — for status payloads. */
+    orchestraSummary(): Record<string, unknown> | null;
     close(): Promise<void>;
+    private closed;
+    /**
+     * Append unless the runtime has been closed.
+     *
+     * The async tails need this: a subtask completion or a turn error can resolve
+     * after close() — stopping an agent does not cancel a promise already in
+     * flight — and appending then throws into an unhandled rejection against a
+     * sqlite handle that no longer exists. The record is not lost so much as
+     * meaningless: the project this event belonged to is gone from memory.
+     */
+    private appendIfOpen;
 }
-export declare function relativeToProject(projectDir: string, p: string): string;