agent-dealer 0.0.0 → 0.1.1

package/bundle/server/dist/config/load-env.js

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "../../../..");
+const DEFAULTS = {
+    development: {
+        home: path.join(os.homedir(), ".agent-dealer-dev"),
+        port: "3221",
+        webPort: "3222",
+        webUrl: "http://localhost:3222",
+        apiUrl: "http://127.0.0.1:3221",
+    },
+    production: {
+        home: path.join(os.homedir(), ".agent-dealer"),
+        port: "2221",
+        webPort: "2222",
+        webUrl: "http://localhost:2222",
+        apiUrl: "http://127.0.0.1:2221",
+    },
+};
+export function getRepoRoot() {
+    return repoRoot;
+}
+export function resolveAgentDealerEnv() {
+    const raw = process.env.AGENT_DEALER_ENV ?? process.env.NODE_ENV;
+    return raw === "production" ? "production" : "development";
+}
+function homeDirForMode(mode) {
+    return DEFAULTS[mode].home;
+}
+export function resolveEnvFilePath(mode) {
+    return path.join(homeDirForMode(mode), ".env");
+}
+function envFileForMode(mode) {
+    return resolveEnvFilePath(mode);
+}
+function setDefault(key, value) {
+    if (process.env[key] === undefined || process.env[key] === "") {
+        process.env[key] = value;
+    }
+}
+function applyDefaults(mode) {
+    const d = DEFAULTS[mode];
+    setDefault("AGENT_DEALER_HOME", d.home);
+    setDefault("PORT", d.port);
+    setDefault("WEB_PORT", d.webPort);
+    setDefault("AGENT_DEALER_WEB_URL", d.webUrl);
+    setDefault("AGENT_DEALER_API", d.apiUrl);
+}
+function shortenHome(p) {
+    const home = os.homedir();
+    return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+export function formatEnvStartupLine(mode, envFile) {
+    const home = process.env.AGENT_DEALER_HOME ?? DEFAULTS[mode].home;
+    const port = process.env.PORT ?? DEFAULTS[mode].port;
+    const envLabel = fs.existsSync(envFile) ? envFile : `${envFile} (missing)`;
+    return `agent-dealer [${mode}] env=${envLabel} home=${shortenHome(home)} port=${port}`;
+}
+export function loadAgentDealerEnv() {
+    const mode = resolveAgentDealerEnv();
+    const envFile = envFileForMode(mode);
+    if (fs.existsSync(envFile)) {
+        dotenv.config({ path: envFile });
+    }
+    else if (mode === "development") {
+        const legacy = path.resolve(repoRoot, ".env");
+        if (fs.existsSync(legacy)) {
+            dotenv.config({ path: legacy });
+            console.warn(`agent-dealer: loaded legacy ${legacy} — move to ${envFile} (see scripts/templates/dev.env.example)`);
+        }
+    }
+    applyDefaults(mode);
+    return { mode, envFile };
+}

package/bundle/server/dist/db/index.js

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID, CURSOR_DEFAULT_MODEL, } from "@agent-dealer/shared";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function getDataDir() {
+    const home = process.env.AGENT_DEALER_HOME ?? path.join(os.homedir(), ".agent-dealer");
+    fs.mkdirSync(home, { recursive: true });
+    return home;
+}
+export function getDbPath() {
+    return path.join(getDataDir(), "dealer.db");
+}
+let dbInstance = null;
+export function getDb() {
+    if (!dbInstance) {
+        dbInstance = new Database(getDbPath());
+        dbInstance.pragma("journal_mode = WAL");
+        dbInstance.pragma("foreign_keys = ON");
+    }
+    return dbInstance;
+}
+export function migrate() {
+    const db = getDb();
+    const schema = readFileSync(path.join(__dirname, "schema.sql"), "utf8");
+    db.exec(schema);
+    const runCols = db.prepare("PRAGMA table_info(runs)").all();
+    if (!runCols.some((c) => c.name === "agent_id")) {
+        db.exec("ALTER TABLE runs ADD COLUMN agent_id TEXT REFERENCES agents(id)");
+        db.exec("ALTER TABLE runs ADD COLUMN agent_name TEXT");
+    }
+    const agentCols = db.prepare("PRAGMA table_info(agents)").all();
+    if (!agentCols.some((c) => c.name === "workspace_root")) {
+        db.exec("ALTER TABLE agents ADD COLUMN workspace_root TEXT");
+    }
+    const runCols2 = db.prepare("PRAGMA table_info(runs)").all();
+    if (!runCols2.some((c) => c.name === "external_label")) {
+        db.exec("ALTER TABLE runs ADD COLUMN external_label TEXT");
+    }
+    const agentCols2 = db.prepare("PRAGMA table_info(agents)").all();
+    if (!agentCols2.some((c) => c.name === "default_plan_model")) {
+        db.exec("ALTER TABLE agents ADD COLUMN default_plan_model TEXT");
+        db.exec("ALTER TABLE agents ADD COLUMN default_execute_model TEXT");
+    }
+    const runCols3 = db.prepare("PRAGMA table_info(runs)").all();
+    if (!runCols3.some((c) => c.name === "plan_model")) {
+        db.exec("ALTER TABLE runs ADD COLUMN plan_model TEXT");
+        db.exec("ALTER TABLE runs ADD COLUMN execute_model TEXT");
+    }
+    seedBuiltinAgents(db);
+    seedIntakeSettings(db);
+    migrateLegacyAgentDeckPort(db);
+    // Default agents are normal rows — clear legacy built-in flag.
+    db.exec("UPDATE agents SET is_builtin = 0 WHERE is_builtin = 1");
+}
+function migrateLegacyAgentDeckPort(db) {
+    const row = db
+        .prepare("SELECT value_json FROM intake_settings WHERE key = ?")
+        .get("agentDeck.port");
+    if (!row)
+        return;
+    try {
+        const port = JSON.parse(row.value_json);
+        if (port === 11111) {
+            db.prepare("UPDATE intake_settings SET value_json = ? WHERE key = ?").run("1111", "agentDeck.port");
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+function seedIntakeSettings(db) {
+    const stateFilter = (process.env.LINEAR_STATE_FILTER ?? "Todo")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    const teamId = process.env.LINEAR_TEAM_ID ?? null;
+    const defaults = {
+        "linear.stateFilter": stateFilter.length > 0 ? stateFilter : ["Todo"],
+        "linear.teamId": teamId,
+        "linear.assigneeMe": true,
+        "linear.defaultAgentId": null,
+        "linear.syncEnabled": true,
+        "linear.routingRules": [],
+        "agentDeck.host": "127.0.0.1",
+        "agentDeck.port": 1111,
+    };
+    const deckFromEnv = process.env.AGENT_DECK_API_URL;
+    if (deckFromEnv) {
+        try {
+            const u = new URL(deckFromEnv);
+            defaults["agentDeck.host"] = u.hostname;
+            defaults["agentDeck.port"] = u.port ? Number(u.port) : 1111;
+        }
+        catch {
+            /* keep defaults */
+        }
+    }
+    const insert = db.prepare("INSERT OR IGNORE INTO intake_settings (key, value_json) VALUES (?, ?)");
+    for (const [key, value] of Object.entries(defaults)) {
+        insert.run(key, JSON.stringify(value));
+    }
+}
+function seedBuiltinAgents(db) {
+    const now = new Date().toISOString();
+    const insert = db.prepare(`
+    INSERT OR IGNORE INTO agents (id, name, runtime, deck_id, deck_name, playbook_id, is_builtin, created_at, updated_at)
+    VALUES (?, ?, ?, NULL, NULL, NULL, 0, ?, ?)
+  `);
+    insert.run(BUILTIN_AGENT_CLAUDE_ID, "Claude", "claude_code", now, now);
+    insert.run(BUILTIN_AGENT_CURSOR_ID, "Cursor", "cursor_local", now, now);
+    db.prepare(`UPDATE agents SET
+      default_plan_model = COALESCE(default_plan_model, ?),
+      default_execute_model = COALESCE(default_execute_model, ?),
+      updated_at = ?
+     WHERE id = ? AND runtime = 'cursor_local'`).run(CURSOR_DEFAULT_MODEL, CURSOR_DEFAULT_MODEL, now, BUILTIN_AGENT_CURSOR_ID);
+}

package/bundle/server/dist/db/migrate.js

@@ -0,0 +1,6 @@
+import { formatEnvStartupLine, loadAgentDealerEnv, } from "../config/load-env.js";
+import { migrate, getDbPath } from "./index.js";
+const { mode, envFile } = loadAgentDealerEnv();
+console.log(formatEnvStartupLine(mode, envFile));
+migrate();
+console.log("Database migrated:", getDbPath());

package/bundle/server/dist/db/schema.sql

@@ -0,0 +1,84 @@
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  runtime TEXT NOT NULL,
+  deck_id TEXT,
+  deck_name TEXT,
+  playbook_id TEXT,
+  workspace_root TEXT,
+  default_plan_model TEXT,
+  default_execute_model TEXT,
+  is_builtin INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_agents_name ON agents(name);
+
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  external_id TEXT,
+  external_label TEXT,
+  task_category TEXT NOT NULL,
+  title TEXT NOT NULL,
+  description TEXT,
+  repo TEXT,
+  artifact_workspace TEXT,
+  agent_id TEXT REFERENCES agents(id),
+  agent_name TEXT,
+  deck_id TEXT,
+  deck_name TEXT,
+  playbook_id TEXT,
+  runtime TEXT,
+  plan_model TEXT,
+  execute_model TEXT,
+  status TEXT NOT NULL,
+  lineage_id TEXT,
+  acceptance_criteria TEXT,
+  approval_gates_json TEXT,
+  budget_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+CREATE INDEX IF NOT EXISTS idx_runs_external ON runs(source, external_id);
+
+CREATE TABLE IF NOT EXISTS artifacts (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id),
+  kind TEXT NOT NULL,
+  content_json TEXT,
+  blob_path TEXT,
+  author TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_artifacts_run ON artifacts(run_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id),
+  type TEXT NOT NULL,
+  payload_json TEXT,
+  ts TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id);
+
+CREATE TABLE IF NOT EXISTS approval_gates (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id),
+  action_type TEXT NOT NULL,
+  status TEXT NOT NULL,
+  resolved_by TEXT,
+  resolved_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_gates_run ON approval_gates(run_id);
+
+CREATE TABLE IF NOT EXISTS intake_settings (
+  key TEXT PRIMARY KEY,
+  value_json TEXT NOT NULL
+);

package/bundle/server/dist/index.js

@@ -0,0 +1,30 @@
+import { formatEnvStartupLine, loadAgentDealerEnv, } from "./config/load-env.js";
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import { enrichPathForCliTools } from "./cli-env.js";
+import { migrate } from "./db/index.js";
+import { registerRoutes } from "./routes/index.js";
+import { startQueue } from "./queue/dispatcher.js";
+import { registerStaticUi } from "./static-ui.js";
+const { mode, envFile } = loadAgentDealerEnv();
+console.log(formatEnvStartupLine(mode, envFile));
+const port = Number(process.env.PORT ?? 2221);
+async function main() {
+    enrichPathForCliTools();
+    migrate();
+    const app = Fastify({ logger: true });
+    await app.register(cors, { origin: true });
+    await registerRoutes(app);
+    const uiDist = await registerStaticUi(app);
+    startQueue();
+    await app.listen({ port, host: "0.0.0.0" });
+    const base = `http://127.0.0.1:${port}`;
+    console.log(`agent-dealer API ${base}`);
+    if (uiDist) {
+        console.log(`agent-dealer dashboard ${base}`);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/bundle/server/dist/intake/agent-routing.js

@@ -0,0 +1,32 @@
+import { listAgentsWithHealth } from "../adapters/agent-health.js";
+import { listAgents } from "../repository/agents.js";
+export async function resolveAgentForIssue(issue, settings, explicitAgentId) {
+    if (explicitAgentId) {
+        return { agentId: explicitAgentId, reason: "explicit agentId on promote" };
+    }
+    const issueLabels = new Set((issue.labels ?? []).map((l) => l.toLowerCase()));
+    for (const rule of settings.routingRules) {
+        if (issueLabels.has(rule.label.toLowerCase())) {
+            return {
+                agentId: rule.agentId,
+                reason: `label:${rule.label} → configured agent`,
+            };
+        }
+    }
+    if (settings.defaultAgentId) {
+        return {
+            agentId: settings.defaultAgentId,
+            reason: "linear.defaultAgentId",
+        };
+    }
+    const agents = await listAgentsWithHealth(listAgents());
+    const healthyWithWorkspace = agents.filter((a) => a.healthy && a.workspaceRoot);
+    if (healthyWithWorkspace.length > 0) {
+        const pick = healthyWithWorkspace[0];
+        return {
+            agentId: pick.id,
+            reason: `first healthy agent with workspace (${pick.name})`,
+        };
+    }
+    throw new Error("No agent available — set defaultAgentId, routing rules, or configure a healthy agent with workspace");
+}

package/bundle/server/dist/paths.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDataDir } from "./db/index.js";
+export function getTemporalDir() {
+    return path.join(getDataDir(), ".temporal");
+}
+export function getTemporalOutputDir() {
+    const dir = path.join(getTemporalDir(), "output");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getTemporalLogsDir() {
+    const dir = path.join(getTemporalDir(), "logs");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}

package/bundle/server/dist/queue/dispatcher.js

@@ -0,0 +1,305 @@
+import { addArtifact, countByStatus, getLatestArtifact, getRun, listRuns, transitionRun, } from "../repository/runs.js";
+import { runAgent } from "../runners/claude.js";
+import { persistRunOutput, seedDeliverableFromParent } from "../runners/persist.js";
+import { checkAgentDeckHealth } from "../adapters/agent-deck.js";
+import { pollLinearIssues } from "../adapters/external.js";
+import { syncLinearForRun } from "../adapters/linear-sync.js";
+import { listAgentsWithHealth } from "../adapters/agent-health.js";
+import { listAgents } from "../repository/agents.js";
+import { runReflect } from "../runners/reflect.js";
+const activeRuns = new Map();
+const activePlanDrafts = new Set();
+const activeReflects = new Set();
+let listeners = [];
+let pollTimer = null;
+let dispatchTimer = null;
+function maxConcurrent() {
+    return Number(process.env.MAX_CONCURRENT_RUNS ?? 2);
+}
+function runtimeFor(run) {
+    return run.runtime ?? "claude_code";
+}
+function needsPlanDraft(run) {
+    if (run.status !== "plan_pending" && run.status !== "queued")
+        return false;
+    if (!run.runtime)
+        return false;
+    if (getLatestArtifact(run.id, "draft_plan"))
+        return false;
+    if (activePlanDrafts.has(run.id))
+        return false;
+    return true;
+}
+function sortQueueFifo(runs) {
+    return [...runs].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function listPlanningPhaseRuns() {
+    return sortQueueFifo(listRuns("queued").concat(listRuns("plan_pending")));
+}
+/** Plan written and idle — human review lane (excludes active re-draft). */
+function isReadyForPlanReview(run) {
+    return (run.status === "plan_pending" &&
+        !!getLatestArtifact(run.id, "draft_plan") &&
+        !activePlanDrafts.has(run.id));
+}
+export function getSnapshot() {
+    const all = listRuns();
+    const runningRuns = all.filter((r) => r.status === "running");
+    const waitingExecution = sortQueueFifo(all.filter((r) => r.status === "plan_approved"));
+    const resultReviewRuns = all
+        .filter((r) => r.status === "review" || r.status === "failed")
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    const recentDone = all
+        .filter((r) => r.status === "done")
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+        .slice(0, 10);
+    const planningPhase = listPlanningPhaseRuns();
+    const awaitingPlanReview = planningPhase.filter(isReadyForPlanReview);
+    const planningActiveRuns = planningPhase.filter((r) => activePlanDrafts.has(r.id));
+    const planningQueuedRuns = planningPhase.filter((r) => !activePlanDrafts.has(r.id) && !isReadyForPlanReview(r));
+    return {
+        planReviewCount: awaitingPlanReview.length,
+        resultReviewCount: resultReviewRuns.length,
+        maxConcurrent: maxConcurrent(),
+        planningActiveRuns,
+        planningQueuedRuns,
+        runningRuns,
+        waitingExecution,
+        resultReviewRuns,
+        recentDone,
+        awaitingPlanReview,
+        runs: all,
+        agentDeckOnline: false,
+        agents: [],
+        agentIssueCount: 0,
+    };
+}
+export async function getSnapshotAsync() {
+    const snap = getSnapshot();
+    snap.agentDeckOnline = await checkAgentDeckHealth();
+    snap.agents = await listAgentsWithHealth(listAgents());
+    snap.agentIssueCount = snap.agents.filter((a) => !a.healthy).length;
+    return snap;
+}
+export function subscribe(listener) {
+    listeners.push(listener);
+    return () => {
+        listeners = listeners.filter((l) => l !== listener);
+    };
+}
+async function notify() {
+    const snap = await getSnapshotAsync();
+    for (const l of listeners)
+        l(snap);
+}
+export function startQueue() {
+    const pollMs = Number(process.env.POLL_INTERVAL_MS ?? 30_000);
+    if (!pollTimer) {
+        pollTimer = setInterval(() => {
+            pollLinearIssues().catch((e) => console.error("[linear]", e));
+        }, pollMs);
+        pollLinearIssues().catch((e) => console.error("[linear]", e));
+    }
+    if (!dispatchTimer) {
+        dispatchTimer = setInterval(() => {
+            dispatch().catch((e) => console.error("[queue]", e));
+        }, 3000);
+        dispatch().catch((e) => console.error("[queue]", e));
+    }
+}
+export function stopQueue() {
+    if (pollTimer)
+        clearInterval(pollTimer);
+    if (dispatchTimer)
+        clearInterval(dispatchTimer);
+    pollTimer = null;
+    dispatchTimer = null;
+}
+/** Fire-and-forget: agent drafts plan after task intake. */
+export function schedulePlanDraft(run) {
+    if (!needsPlanDraft(run))
+        return;
+    if (activePlanDrafts.has(run.id))
+        return;
+    activePlanDrafts.add(run.id);
+    void draftPlan(run)
+        .catch((e) => console.error("[plan-draft]", run.id, e))
+        .finally(() => {
+        activePlanDrafts.delete(run.id);
+        notify().catch(console.error);
+    });
+}
+/** Fire-and-forget: post-review playbook reflect (D3 learning loop). */
+export function scheduleReflect(run, opts) {
+    if (!run.playbookId || !run.deckId)
+        return;
+    if (activeReflects.has(run.id))
+        return;
+    void (async () => {
+        const online = await checkAgentDeckHealth();
+        if (!online)
+            return;
+        activeReflects.add(run.id);
+        try {
+            await runReflect(run, opts);
+        }
+        catch (e) {
+            console.error("[reflect]", run.id, e);
+        }
+        finally {
+            activeReflects.delete(run.id);
+            notify().catch(console.error);
+        }
+    })();
+}
+async function dispatchPlanDrafts() {
+    const pending = listRuns("plan_pending").concat(listRuns("queued"));
+    const slots = maxConcurrent() - activePlanDrafts.size;
+    if (slots <= 0)
+        return;
+    for (const run of pending) {
+        if (!needsPlanDraft(run))
+            continue;
+        if (activePlanDrafts.size >= maxConcurrent())
+            break;
+        activePlanDrafts.add(run.id);
+        void draftPlan(run)
+            .catch((e) => console.error("[plan-draft]", run.id, e))
+            .finally(() => {
+            activePlanDrafts.delete(run.id);
+            notify().catch(console.error);
+        });
+    }
+}
+async function dispatch() {
+    await dispatchPlanDrafts();
+    const running = countByStatus("running");
+    const slots = maxConcurrent() - running;
+    if (slots <= 0)
+        return;
+    const approved = sortQueueFifo(listRuns("plan_approved"));
+    for (const run of approved.slice(0, slots)) {
+        if (activeRuns.has(run.id))
+            continue;
+        const job = executeRun(run).finally(() => {
+            activeRuns.delete(run.id);
+            notify().catch(console.error);
+        });
+        activeRuns.set(run.id, job);
+    }
+    await notify();
+}
+export async function kickRun(run) {
+    if (run.status !== "plan_approved") {
+        throw new Error(`Run must be plan_approved to kick, got ${run.status}`);
+    }
+    await dispatch();
+}
+export async function draftPlan(run, opts) {
+    if (run.status === "queued") {
+        transitionRun(run.id, "plan_pending");
+    }
+    const updated = getRun(run.id);
+    if (!updated.runtime) {
+        throw new Error("Select an agent runtime before planning");
+    }
+    if (!opts?.replace) {
+        syncLinearForRun(updated, "planning_started").catch((e) => console.error("[linear-sync] planning_started:", e));
+    }
+    const rt = runtimeFor(updated);
+    try {
+        const result = await runAgent(updated, "plan");
+        const persisted = persistRunOutput({
+            run: updated,
+            phase: "plan",
+            runtime: rt,
+            exitCode: result.exitCode,
+            logPath: result.logPath,
+            rawTranscript: result.transcript,
+        });
+        const after = getRun(run.id);
+        if (!after || (after.status !== "plan_pending" && after.status !== "queued")) {
+            // Human approved or run moved on while agent was still planning — ignore late result.
+            await notify();
+            return after ?? updated;
+        }
+        if (persisted.planMarkdown) {
+            addArtifact(updated.id, "draft_plan", { markdown: persisted.planMarkdown, sessionId: persisted.sessionId }, "agent", result.logPath);
+        }
+        else if (!opts?.replace) {
+            addArtifact(updated.id, "feedback", { error: "Agent did not return a plan" }, "system");
+        }
+        const planFailed = !persisted.planMarkdown && result.exitCode !== 0;
+        if (planFailed) {
+            transitionRun(run.id, "failed");
+            addArtifact(run.id, "feedback", { error: "Planning failed", exitCode: result.exitCode }, "system");
+        }
+    }
+    catch (err) {
+        const after = getRun(run.id);
+        if (after && (after.status === "plan_pending" || after.status === "queued")) {
+            transitionRun(run.id, "failed");
+            addArtifact(run.id, "feedback", { error: String(err) }, "system");
+        }
+    }
+    await notify();
+    return getRun(run.id);
+}
+/** Fire-and-forget: human requested a new agent plan (replaces draft). */
+export function scheduleRedraft(run) {
+    if (activePlanDrafts.has(run.id))
+        return false;
+    if (run.status !== "plan_pending" && run.status !== "queued")
+        return false;
+    if (!run.runtime)
+        return false;
+    activePlanDrafts.add(run.id);
+    void draftPlan(run, { replace: true })
+        .catch((e) => console.error("[plan-redraft]", run.id, e))
+        .finally(() => {
+        activePlanDrafts.delete(run.id);
+        notify().catch(console.error);
+    });
+    return true;
+}
+/** Human requested a new agent plan (replaces draft). @deprecated prefer scheduleRedraft */
+export async function redraftPlan(run) {
+    return draftPlan(run, { replace: true });
+}
+async function executeRun(run) {
+    const rt = runtimeFor(run);
+    try {
+        seedDeliverableFromParent(run);
+        transitionRun(run.id, "running");
+        await notify();
+        const result = await runAgent(run, "execute");
+        const persisted = persistRunOutput({
+            run,
+            phase: "execute",
+            runtime: rt,
+            exitCode: result.exitCode,
+            logPath: result.logPath,
+            rawTranscript: result.transcript,
+        });
+        if (result.exitCode === 0 && !persisted.blocked) {
+            const updated = transitionRun(run.id, "review");
+            syncLinearForRun(updated, "review").catch((e) => console.error("[linear-sync] review:", e));
+        }
+        else {
+            transitionRun(run.id, "failed");
+            addArtifact(run.id, "feedback", {
+                error: persisted.blocked ? "Execution blocked" : "Execution failed",
+                exitCode: result.exitCode,
+                blocker: persisted.blockerSummary,
+            }, "system");
+        }
+    }
+    catch (err) {
+        transitionRun(run.id, "failed");
+        addArtifact(run.id, "feedback", { error: String(err) }, "system");
+    }
+    await notify();
+}
+export async function forceDispatch() {
+    await dispatch();
+}