agent-dealer 0.1.1 → 0.1.3

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

@@ -45,6 +45,11 @@ export function migrate() {
         db.exec("ALTER TABLE agents ADD COLUMN default_plan_model TEXT");
         db.exec("ALTER TABLE agents ADD COLUMN default_execute_model TEXT");
     }
+    const agentCols3 = db.prepare("PRAGMA table_info(agents)").all();
+    if (!agentCols3.some((c) => c.name === "default_plan_budget_json")) {
+        db.exec("ALTER TABLE agents ADD COLUMN default_plan_budget_json TEXT");
+        db.exec("ALTER TABLE agents ADD COLUMN default_execute_budget_json 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");

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

@@ -8,6 +8,8 @@ CREATE TABLE IF NOT EXISTS agents (
   workspace_root TEXT,
   default_plan_model TEXT,
   default_execute_model TEXT,
+  default_plan_budget_json TEXT,
+  default_execute_budget_json TEXT,
   is_builtin INTEGER NOT NULL DEFAULT 0,
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL

package/bundle/server/dist/queue/answers.test.js

@@ -0,0 +1,117 @@
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-answers-"));
+process.env.MAX_CONCURRENT_RUNS = "0";
+const { migrate } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID } = await import("@agent-dealer/shared");
+const { updateAgent } = await import("../repository/agents.js");
+const { addArtifact, createRun, getLatestArtifact, getRun, markPlanTriageConsumed, updateRunFields } = await import("../repository/runs.js");
+const { submitPlanAnswers } = await import("./dispatcher.js");
+const QUESTIONS = [
+    { id: "q1", question: "Which approach?", options: [{ label: "A" }, { label: "B" }] },
+    { id: "q2", question: "Ship docs too?", options: [{ label: "Yes" }, { label: "No" }] },
+];
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function seedQuestionRun() {
+    const run = createRun({
+        title: "Answers test",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    addArtifact(run.id, "draft_plan", { markdown: "# Plan", sessionId: "sess-1" }, "agent");
+    addArtifact(run.id, "plan_triage", { verdict: "needs_review", rationale: "r", questions: QUESTIONS, sessionId: "sess-1", parseFallback: false, consumed: false }, "agent");
+    return getRun(run.id);
+}
+test("all-structured answers approve and mark plan_answers approved", () => {
+    const run = seedQuestionRun();
+    const res = submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", selectedLabel: "A" },
+            { questionId: "q2", selectedLabel: "No" },
+        ],
+    });
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.outcome, "approved");
+    assert.equal(getRun(run.id).status, "plan_approved");
+    const ans = getLatestArtifact(run.id, "plan_answers");
+    assert.match(ans.contentJson, /"outcome":"approved"/);
+    assert.equal(getLatestArtifact(run.id, "approved_plan").author, "human");
+    const triage = getLatestArtifact(run.id, "plan_triage");
+    assert.match(triage.contentJson, /"consumed":true/);
+});
+test("executeModel null does not wipe seeded execute_model", () => {
+    const run = seedQuestionRun();
+    updateRunFields(run.id, { execute_model: "claude-sonnet-4" });
+    const res = submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", selectedLabel: "A" },
+            { questionId: "q2", selectedLabel: "No" },
+        ],
+        executeModel: null,
+    });
+    assert.equal(res.ok, true);
+    assert.equal(getRun(run.id).executeModel, "claude-sonnet-4");
+});
+test("free-form answer schedules a redraft instead of approving", () => {
+    const run = seedQuestionRun();
+    let redrafted = false;
+    const res = submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", freeText: "Do it a third way" },
+            { questionId: "q2", selectedLabel: "Yes" },
+        ],
+    }, { onRedraft: () => { redrafted = true; } });
+    assert.equal(res.ok && res.outcome, "redraft");
+    assert.equal(redrafted, true);
+    assert.equal(getRun(run.id).status, "plan_pending");
+});
+test("answers must cover every open question exactly once", () => {
+    const run = seedQuestionRun();
+    const res = submitPlanAnswers(run.id, { answers: [{ questionId: "q1", selectedLabel: "A" }] });
+    assert.equal(res.ok, false);
+    assert.equal(!res.ok && res.code, 400);
+});
+test("double submit returns 409", () => {
+    const run = seedQuestionRun();
+    submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", selectedLabel: "A" },
+            { questionId: "q2", selectedLabel: "Yes" },
+        ],
+    });
+    const again = submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", selectedLabel: "B" },
+            { questionId: "q2", selectedLabel: "No" },
+        ],
+    });
+    assert.equal(!again.ok && again.code, 409);
+});
+test("run without open questions returns 409", () => {
+    const run = createRun({
+        title: "No questions",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    const res = submitPlanAnswers(run.id, { answers: [{ questionId: "q1", selectedLabel: "A" }] });
+    assert.equal(!res.ok && res.code, 409);
+});
+test("consumed triage rejects answers", () => {
+    const run = seedQuestionRun();
+    markPlanTriageConsumed(run.id);
+    const res = submitPlanAnswers(run.id, {
+        answers: [
+            { questionId: "q1", selectedLabel: "A" },
+            { questionId: "q2", selectedLabel: "Yes" },
+        ],
+    });
+    assert.equal(!res.ok && res.code, 409);
+});

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

@@ -1,4 +1,6 @@
-import { addArtifact, countByStatus, getLatestArtifact, getRun, listRuns, transitionRun, } from "../repository/runs.js";
+import { planGateDecision } from "@agent-dealer/shared";
+import { buildPlanRevisePrompt } from "../runners/prompts.js";
+import { addArtifact, countByStatus, getLatestArtifact, getRun, listArtifacts, listRuns, markPlanTriageConsumed, patchRunPhaseBudget, transitionRun, updateRunFields, } from "../repository/runs.js";
 import { runAgent } from "../runners/claude.js";
 import { persistRunOutput, seedDeliverableFromParent } from "../runners/persist.js";
 import { checkAgentDeckHealth } from "../adapters/agent-deck.js";
@@ -42,6 +44,24 @@ function isReadyForPlanReview(run) {
         !!getLatestArtifact(run.id, "draft_plan") &&
         !activePlanDrafts.has(run.id));
 }
+/** Open (unanswered, unconsumed) question count for a plan_pending run. */
+function openQuestionCount(runId) {
+    const tri = getLatestArtifact(runId, "plan_triage");
+    if (!tri?.contentJson)
+        return 0;
+    try {
+        const c = JSON.parse(tri.contentJson);
+        if (c.consumed || !c.questions?.length)
+            return 0;
+        const ans = getLatestArtifact(runId, "plan_answers");
+        if (ans && ans.createdAt > tri.createdAt)
+            return 0;
+        return c.questions.length;
+    }
+    catch {
+        return 0;
+    }
+}
 export function getSnapshot() {
     const all = listRuns();
     const runningRuns = all.filter((r) => r.status === "running");
@@ -57,6 +77,16 @@ export function getSnapshot() {
     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));
+    const openQuestionCounts = {};
+    for (const run of awaitingPlanReview) {
+        const n = openQuestionCount(run.id);
+        if (n > 0)
+            openQuestionCounts[run.id] = n;
+    }
+    const awaitingAnswerRuns = awaitingPlanReview.filter((r) => openQuestionCounts[r.id]);
+    const autoApprovedRunIds = [...waitingExecution, ...runningRuns]
+        .filter((r) => getLatestArtifact(r.id, "approved_plan")?.author === "system")
+        .map((r) => r.id);
     return {
         planReviewCount: awaitingPlanReview.length,
         resultReviewCount: resultReviewRuns.length,
@@ -68,6 +98,9 @@ export function getSnapshot() {
         resultReviewRuns,
         recentDone,
         awaitingPlanReview,
+        awaitingAnswerRuns,
+        openQuestionCounts,
+        autoApprovedRunIds,
         runs: all,
         agentDeckOnline: false,
         agents: [],
@@ -195,6 +228,49 @@ export async function kickRun(run) {
     }
     await dispatch();
 }
+function priorQuestionRounds(runId, currentTriageArtifactId) {
+    return listArtifacts(runId).filter((a) => {
+        if (a.kind !== "plan_triage" || a.id === currentTriageArtifactId || !a.contentJson)
+            return false;
+        try {
+            const c = JSON.parse(a.contentJson);
+            return (c.questions?.length ?? 0) > 0;
+        }
+        catch {
+            return false;
+        }
+    }).length;
+}
+/** Self-triage gate after a plan draft persists (PRD F2). Exported for tests. */
+export function applyPlanGate(run) {
+    const art = getLatestArtifact(run.id, "plan_triage");
+    if (!art?.contentJson)
+        return "await_review";
+    let triage;
+    try {
+        triage = JSON.parse(art.contentJson);
+    }
+    catch {
+        return "await_review";
+    }
+    const decision = planGateDecision({
+        triage,
+        priorQuestionRounds: priorQuestionRounds(run.id, art.id),
+    });
+    if (decision !== "auto_approve")
+        return decision;
+    const fresh = getRun(run.id);
+    if (!fresh || fresh.status !== "plan_pending")
+        return "await_review";
+    const draft = getLatestArtifact(run.id, "draft_plan");
+    if (!draft?.contentJson)
+        return "await_review";
+    const plan = JSON.parse(draft.contentJson);
+    addArtifact(run.id, "approved_plan", { ...plan, autoApproved: true, rationale: triage.rationale }, "system");
+    transitionRun(run.id, "plan_approved");
+    void forceDispatch();
+    return "auto_approve";
+}
 export async function draftPlan(run, opts) {
     if (run.status === "queued") {
         transitionRun(run.id, "plan_pending");
@@ -208,7 +284,7 @@ export async function draftPlan(run, opts) {
     }
     const rt = runtimeFor(updated);
     try {
-        const result = await runAgent(updated, "plan");
+        const result = await runAgent(updated, "plan", opts?.revise);
         const persisted = persistRunOutput({
             run: updated,
             phase: "plan",
@@ -225,6 +301,18 @@ export async function draftPlan(run, opts) {
         }
         if (persisted.planMarkdown) {
             addArtifact(updated.id, "draft_plan", { markdown: persisted.planMarkdown, sessionId: persisted.sessionId }, "agent", result.logPath);
+            const triage = persisted.planTriage;
+            if (triage) {
+                addArtifact(updated.id, "plan_triage", {
+                    verdict: triage.verdict,
+                    rationale: triage.rationale,
+                    questions: triage.questions,
+                    sessionId: persisted.sessionId,
+                    parseFallback: triage.parseFallback,
+                    consumed: false,
+                }, "agent");
+                applyPlanGate(getRun(run.id));
+            }
         }
         else if (!opts?.replace) {
             addArtifact(updated.id, "feedback", { error: "Agent did not return a plan" }, "system");
@@ -245,6 +333,80 @@ export async function draftPlan(run, opts) {
     await notify();
     return getRun(run.id);
 }
+/** Answer open plan questions (PRD F3). Structured answers approve + dispatch; free-form revises the plan. */
+export function submitPlanAnswers(runId, input, opts) {
+    const run = getRun(runId);
+    if (!run)
+        return { ok: false, code: 404, error: "Not found" };
+    if (run.status !== "plan_pending") {
+        return { ok: false, code: 409, error: `No open questions — run is ${run.status}` };
+    }
+    const triageArt = getLatestArtifact(runId, "plan_triage");
+    if (!triageArt?.contentJson)
+        return { ok: false, code: 409, error: "No open questions" };
+    let triage;
+    try {
+        triage = JSON.parse(triageArt.contentJson);
+    }
+    catch {
+        return { ok: false, code: 409, error: "No open questions" };
+    }
+    if (triage.consumed || triage.questions.length === 0) {
+        return { ok: false, code: 409, error: "No open questions" };
+    }
+    const priorAnswers = getLatestArtifact(runId, "plan_answers");
+    if (priorAnswers && priorAnswers.createdAt > triageArt.createdAt) {
+        return { ok: false, code: 409, error: "Questions already answered" };
+    }
+    const expected = triage.questions.map((q) => q.id).sort().join(",");
+    const got = input.answers.map((a) => a.questionId).sort().join(",");
+    if (expected !== got) {
+        return { ok: false, code: 400, error: "Answers must cover every open question exactly once" };
+    }
+    const freeForm = input.answers.some((a) => a.freeText);
+    const outcome = freeForm ? "redraft" : "approved";
+    addArtifact(runId, "plan_answers", { answers: input.answers, outcome, answeredAt: new Date().toISOString() }, "human");
+    if (!freeForm) {
+        // null/empty = "Default" — do not wipe a seeded execute_model; only set explicit picks
+        if (input.executeModel?.trim()) {
+            updateRunFields(runId, { execute_model: input.executeModel.trim() });
+        }
+        if (input.executeBudget !== undefined) {
+            patchRunPhaseBudget(runId, "execute", input.executeBudget);
+        }
+        markPlanTriageConsumed(runId);
+        try {
+            transitionRun(runId, "plan_approved");
+        }
+        catch (e) {
+            return { ok: false, code: 409, error: String(e) };
+        }
+        const draft = getLatestArtifact(runId, "draft_plan");
+        const plan = draft?.contentJson ? JSON.parse(draft.contentJson) : { markdown: "" };
+        addArtifact(runId, "approved_plan", plan, "human");
+        void forceDispatch();
+        return { ok: true, outcome, run: getRun(runId) };
+    }
+    (opts?.onRedraft ?? scheduleRevisePlan)(getRun(runId), triage, input.answers);
+    return { ok: true, outcome, run: getRun(runId) };
+}
+function scheduleRevisePlan(run, triage, answers) {
+    if (activePlanDrafts.has(run.id))
+        return;
+    activePlanDrafts.add(run.id);
+    void draftPlan(run, {
+        replace: true,
+        revise: {
+            resumeSessionId: triage.sessionId,
+            prompt: buildPlanRevisePrompt(run, triage.questions, answers),
+        },
+    })
+        .catch((e) => console.error("[plan-revise]", run.id, e))
+        .finally(() => {
+        activePlanDrafts.delete(run.id);
+        notify().catch(console.error);
+    });
+}
 /** Fire-and-forget: human requested a new agent plan (replaces draft). */
 export function scheduleRedraft(run) {
     if (activePlanDrafts.has(run.id))

package/bundle/server/dist/queue/plan-gate.test.js

@@ -0,0 +1,55 @@
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-gate-"));
+process.env.MAX_CONCURRENT_RUNS = "0";
+const { migrate } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID } = await import("@agent-dealer/shared");
+const { updateAgent } = await import("../repository/agents.js");
+const { addArtifact, createRun, getLatestArtifact, getRun } = await import("../repository/runs.js");
+const { applyPlanGate, getSnapshot } = await import("./dispatcher.js");
+const QUESTIONS = [
+    { id: "q1", question: "Which approach?", options: [{ label: "A" }, { label: "B" }] },
+];
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function seedRun(triage) {
+    const run = createRun({
+        title: "Gate test",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    addArtifact(run.id, "draft_plan", { markdown: "# Plan" }, "agent");
+    addArtifact(run.id, "plan_triage", triage, "agent");
+    return getRun(run.id);
+}
+test("trivial triage auto-approves: system approved_plan + plan_approved status", () => {
+    const run = seedRun({ verdict: "trivial", rationale: "tiny", questions: [], parseFallback: false, consumed: false });
+    assert.equal(applyPlanGate(run), "auto_approve");
+    assert.equal(getRun(run.id).status, "plan_approved");
+    const approved = getLatestArtifact(run.id, "approved_plan");
+    assert.equal(approved.author, "system");
+    assert.match(approved.contentJson, /tiny/);
+});
+test("questions await answers and leave status untouched", () => {
+    const run = seedRun({ verdict: "needs_review", rationale: "r", questions: QUESTIONS, parseFallback: false, consumed: false });
+    assert.equal(applyPlanGate(run), "await_answers");
+    assert.equal(getRun(run.id).status, "plan_pending");
+});
+test("third question round goes to manual review", () => {
+    const run = seedRun({ verdict: "needs_review", rationale: "r1", questions: QUESTIONS, parseFallback: false, consumed: false });
+    addArtifact(run.id, "plan_triage", { verdict: "needs_review", rationale: "r2", questions: QUESTIONS, parseFallback: false, consumed: false }, "agent");
+    addArtifact(run.id, "plan_triage", { verdict: "needs_review", rationale: "r3", questions: QUESTIONS, parseFallback: false, consumed: false }, "agent");
+    assert.equal(applyPlanGate(getRun(run.id)), "await_review");
+});
+test("snapshot exposes awaitingAnswerRuns, openQuestionCounts, autoApprovedRunIds", () => {
+    const snap = getSnapshot();
+    assert.equal(Array.isArray(snap.awaitingAnswerRuns), true);
+    assert.equal(typeof snap.openQuestionCounts, "object");
+    assert.equal(Array.isArray(snap.autoApprovedRunIds), true);
+});

package/bundle/server/dist/repository/agents.js

@@ -1,3 +1,4 @@
+import { serializePhaseBudget } from "@agent-dealer/shared";
 import { v4 as uuid } from "uuid";
 import { getDb } from "../db/index.js";
 function rowToAgent(row) {
@@ -11,6 +12,8 @@ function rowToAgent(row) {
         playbookId: row.playbook_id,
         defaultPlanModel: row.default_plan_model,
         defaultExecuteModel: row.default_execute_model,
+        defaultPlanBudgetJson: row.default_plan_budget_json,
+        defaultExecuteBudgetJson: row.default_execute_budget_json,
         isBuiltin: row.is_builtin === 1,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
@@ -31,9 +34,9 @@ export function createAgent(input, deckName) {
     const now = new Date().toISOString();
     const id = uuid();
     db.prepare(`
-    INSERT INTO agents (id, name, runtime, deck_id, deck_name, playbook_id, workspace_root, default_plan_model, default_execute_model, is_builtin, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
-  `).run(id, input.name.trim(), input.runtime, input.deckId ?? null, deckName ?? null, input.playbookId ?? null, input.workspaceRoot.trim(), input.defaultPlanModel ?? null, input.defaultExecuteModel ?? null, now, now);
+    INSERT INTO agents (id, name, runtime, deck_id, deck_name, playbook_id, workspace_root, default_plan_model, default_execute_model, default_plan_budget_json, default_execute_budget_json, is_builtin, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+  `).run(id, input.name.trim(), input.runtime, input.deckId ?? null, deckName ?? null, input.playbookId ?? null, input.workspaceRoot.trim(), input.defaultPlanModel ?? null, input.defaultExecuteModel ?? null, serializePhaseBudget(input.defaultPlanBudget), serializePhaseBudget(input.defaultExecuteBudget), now, now);
     return getAgent(id);
 }
 export function updateAgent(id, input, deckName) {
@@ -48,14 +51,20 @@ export function updateAgent(id, input, deckName) {
     const playbookId = input.playbookId !== undefined ? input.playbookId : existing.playbookId;
     const defaultPlanModel = input.defaultPlanModel !== undefined ? input.defaultPlanModel : existing.defaultPlanModel;
     const defaultExecuteModel = input.defaultExecuteModel !== undefined ? input.defaultExecuteModel : existing.defaultExecuteModel;
+    const defaultPlanBudgetJson = input.defaultPlanBudget !== undefined
+        ? serializePhaseBudget(input.defaultPlanBudget)
+        : existing.defaultPlanBudgetJson;
+    const defaultExecuteBudgetJson = input.defaultExecuteBudget !== undefined
+        ? serializePhaseBudget(input.defaultExecuteBudget)
+        : existing.defaultExecuteBudgetJson;
     const resolvedDeckName = input.deckId !== undefined ? (input.deckId ? (deckName ?? null) : null) : existing.deckName;
     getDb()
         .prepare(`
       UPDATE agents SET name = ?, runtime = ?, deck_id = ?, deck_name = ?, playbook_id = ?, workspace_root = ?,
-        default_plan_model = ?, default_execute_model = ?, updated_at = ?
+        default_plan_model = ?, default_execute_model = ?, default_plan_budget_json = ?, default_execute_budget_json = ?, updated_at = ?
       WHERE id = ?
     `)
-        .run(name, runtime, deckId, resolvedDeckName, playbookId, workspaceRoot, defaultPlanModel, defaultExecuteModel, now, id);
+        .run(name, runtime, deckId, resolvedDeckName, playbookId, workspaceRoot, defaultPlanModel, defaultExecuteModel, defaultPlanBudgetJson, defaultExecuteBudgetJson, now, id);
     return getAgent(id);
 }
 export function deleteAgent(id) {

package/bundle/server/dist/repository/runs.js

@@ -1,4 +1,5 @@
 import { CURSOR_DEFAULT_MODEL } from "@agent-dealer/shared";
+import { mergeRunBudget, parsePhaseBudget, parseRunBudget, resolvePhaseBudget, serializeRunBudget, } from "@agent-dealer/shared";
 import { canTransition } from "@agent-dealer/shared";
 import { v4 as uuid } from "uuid";
 import { getDb } from "../db/index.js";
@@ -74,7 +75,7 @@ export function createRun(input, opts) {
             update_ticket_status: "require_approval",
             publish_external: "require_approval",
         }),
-        budget_json: JSON.stringify({ maxTurns: 30, maxBudgetUsd: 5 }),
+        budget_json: serializeRunBudget(input.budget ?? {}),
         created_at: now,
         updated_at: now,
     };
@@ -141,6 +142,35 @@ export function listRunsReadyForPlanReview() {
         .all();
     return rows.map(rowToRun);
 }
+export function resolveBudgetForPhase(run, phase) {
+    const agent = run.agentId ? getAgent(run.agentId) : null;
+    return resolvePhaseBudget({
+        phase,
+        runBudget: parseRunBudget(run.budgetJson),
+        agentPlanBudget: parsePhaseBudget(agent?.defaultPlanBudgetJson),
+        agentExecuteBudget: parsePhaseBudget(agent?.defaultExecuteBudgetJson),
+        testMode: process.env.AGENT_DEALER_TEST_BUDGET === "1",
+    });
+}
+export function updateRunBudget(id, patch) {
+    const run = getRun(id);
+    if (!run)
+        throw new Error(`Run not found: ${id}`);
+    const merged = mergeRunBudget(parseRunBudget(run.budgetJson), patch);
+    const budgetJson = serializeRunBudget(merged);
+    const now = new Date().toISOString();
+    getDb().prepare("UPDATE runs SET budget_json = ?, updated_at = ? WHERE id = ?").run(budgetJson, now, id);
+    const updated = getRun(id);
+    if (!updated)
+        throw new Error(`Run vanished: ${id}`);
+    return updated;
+}
+export function patchRunPhaseBudget(id, phase, budget) {
+    if (budget === undefined)
+        return getRun(id);
+    // null = clear run-level override for this phase (revert to agent defaults)
+    return updateRunBudget(id, { [phase]: budget });
+}
 export function resolveModelForPhase(run, phase) {
     const agent = run.agentId ? getAgent(run.agentId) : null;
     const isCursor = run.runtime === "cursor_local";
@@ -358,6 +388,21 @@ export function getLatestArtifact(runId, kind) {
         createdAt: row.created_at,
     };
 }
+/** Latest plan_triage stops auto-approving / accepting answers once a human takes over the plan. */
+export function markPlanTriageConsumed(runId) {
+    const art = getLatestArtifact(runId, "plan_triage");
+    if (!art?.contentJson)
+        return;
+    try {
+        const content = JSON.parse(art.contentJson);
+        if (content.consumed === true)
+            return;
+        updateArtifactContent(art.id, { ...content, consumed: true });
+    }
+    catch {
+        /* leave malformed triage untouched */
+    }
+}
 const OPS_BOARD_STATUSES = [
     "queued",
     "plan_pending",

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

@@ -1,9 +1,10 @@
 import fs from "node:fs";
-import { CreateRunInput, AgentConfigInput, AgentDeckConfigPatch, CreateAgentInput, UpdateAgentInput, DraftPlanInput, KickRunInput, LinearIntakeConfigPatch, PromoteLinearInput, RetryRunInput, Runtime, UpdatePlanInput, PlaybookPatchContent, BUILTIN_AGENT_CLAUDE_ID, } from "@agent-dealer/shared";
-import { addArtifact, createRun, findActiveByExternalId, getRun, listArtifacts, listEvents, listRuns, updateRunFields, updateArtifactContent, transitionRun, getLatestArtifact, } from "../repository/runs.js";
+import { CreateRunInput, AgentConfigInput, AgentDeckConfigPatch, CreateAgentInput, UpdateAgentInput, DraftPlanInput, KickRunInput, PlanAnswersInput, LinearIntakeConfigPatch, PromoteLinearInput, RetryRunInput, Runtime, UpdatePlanInput, PlaybookPatchContent, BUILTIN_AGENT_CLAUDE_ID, } from "@agent-dealer/shared";
+import { parseRunBudget } from "@agent-dealer/shared";
+import { addArtifact, createRun, findActiveByExternalId, getRun, listArtifacts, listEvents, listRuns, updateRunFields, updateArtifactContent, transitionRun, getLatestArtifact, markPlanTriageConsumed, patchRunPhaseBudget, updateRunBudget, } from "../repository/runs.js";
 import { createAgent, deleteAgent, getAgent, listAgents, updateAgent, } from "../repository/agents.js";
 import { listAgentsWithHealth } from "../adapters/agent-health.js";
-import { forceDispatch, getSnapshotAsync, kickRun, schedulePlanDraft, scheduleRedraft, scheduleReflect, subscribe, } from "../queue/dispatcher.js";
+import { forceDispatch, getSnapshotAsync, kickRun, schedulePlanDraft, scheduleRedraft, scheduleReflect, submitPlanAnswers, subscribe, } from "../queue/dispatcher.js";
 import { fetchAgentDeckDecks, updatePlaybookBody } from "../adapters/agent-deck.js";
 import { testAgentDeckConnection } from "../adapters/agent-deck.js";
 import { getLinearIssue, listLinearCandidates, testLinearConnection, } from "../adapters/linear-inbox.js";
@@ -52,11 +53,12 @@ export async function registerRoutes(app) {
         const run = getRun(id);
         if (!run)
             return reply.status(404).send({ error: "Not found" });
+        const artifacts = listArtifacts(id);
         return {
             run,
-            artifacts: listArtifacts(id),
+            artifacts,
             events: listEvents(id),
-            usageSummary: buildLineageUsageSummary(run),
+            usageSummary: buildLineageUsageSummary(run, { artifactsByRunId: { [id]: artifacts } }),
             traceSummary: buildLineageTraceSummary(run),
         };
     });
@@ -233,6 +235,9 @@ export async function registerRoutes(app) {
             plan_model: input.planModel !== undefined ? input.planModel : undefined,
             execute_model: input.executeModel !== undefined ? input.executeModel : undefined,
         });
+        if (input.budget !== undefined) {
+            return updateRunBudget(id, input.budget);
+        }
         return updated;
     });
     app.post("/api/runs/:id/draft-plan", async (req, reply) => {
@@ -247,6 +252,9 @@ export async function registerRoutes(app) {
         if (input.planModel !== undefined) {
             updateRunFields(id, { plan_model: input.planModel });
         }
+        if (input.planBudget !== undefined) {
+            patchRunPhaseBudget(id, "plan", input.planBudget);
+        }
         try {
             assertAgentConfigured(getRun(id));
             const scheduled = scheduleRedraft(getRun(id));
@@ -265,8 +273,6 @@ export async function registerRoutes(app) {
         if (!run)
             return reply.status(404).send({ error: "Not found" });
         const input = UpdatePlanInput.parse(req.body);
-        const kind = input.approve ? "approved_plan" : "draft_plan";
-        addArtifact(id, kind, { markdown: input.planMarkdown }, "human");
         if (input.approve) {
             const hasPlan = listArtifacts(id).some((a) => a.kind === "draft_plan") ||
                 input.planMarkdown.trim().length > 0;
@@ -288,16 +294,46 @@ export async function registerRoutes(app) {
             if (Object.keys(patch).length > 0) {
                 updateRunFields(id, patch);
             }
-            const updated = transitionRun(id, "plan_approved");
+            if (input.planBudget !== undefined) {
+                patchRunPhaseBudget(id, "plan", input.planBudget);
+            }
+            if (input.executeBudget !== undefined) {
+                patchRunPhaseBudget(id, "execute", input.executeBudget);
+            }
+            markPlanTriageConsumed(id);
+            try {
+                transitionRun(id, "plan_approved");
+            }
+            catch (e) {
+                return reply.status(409).send({ error: String(e) });
+            }
+            addArtifact(id, "approved_plan", { markdown: input.planMarkdown }, "human");
+            const updated = getRun(id);
             syncLinearForRun(updated, "plan_approved").catch((e) => console.error("[linear-sync] plan_approved:", e));
             await forceDispatch();
             return updated;
         }
+        addArtifact(id, "draft_plan", { markdown: input.planMarkdown }, "human");
+        markPlanTriageConsumed(id);
         if (run.status === "queued") {
             return transitionRun(id, "plan_pending");
         }
         return getRun(id);
     });
+    app.post("/api/runs/:id/plan/answers", async (req, reply) => {
+        const { id } = req.params;
+        let input;
+        try {
+            input = PlanAnswersInput.parse(req.body);
+        }
+        catch (e) {
+            return reply.status(400).send({ error: String(e) });
+        }
+        const result = submitPlanAnswers(id, input);
+        if (!result.ok)
+            return reply.status(result.code).send({ error: result.error });
+        return { run: result.run, outcome: result.outcome };
+    });
     app.post("/api/runs/:id/kick", async (req, reply) => {
         const { id } = req.params;
         const run = getRun(id);
@@ -327,6 +363,9 @@ export async function registerRoutes(app) {
             return reply.status(400).send({ error: `Cannot kick from status ${run.status}` });
         }
         updateRunFields(id, patch);
+        if (input.executeBudget !== undefined) {
+            patchRunPhaseBudget(id, "execute", input.executeBudget);
+        }
         const updated = getRun(id);
         await kickRun(updated);
         await forceDispatch();
@@ -369,6 +408,7 @@ export async function registerRoutes(app) {
             status: "plan_approved",
             agentId: run.agentId ?? BUILTIN_AGENT_CLAUDE_ID,
             planModel: run.planModel ?? undefined,
+            budget: parseRunBudget(run.budgetJson),
         }, { source: run.source, externalId: run.externalId ?? undefined, externalLabel: run.externalLabel ?? undefined, lineageId: run.lineageId ?? run.id });
         updateRunFields(retry.id, {
             deck_id: run.deckId,
@@ -377,6 +417,9 @@ export async function registerRoutes(app) {
             runtime: run.runtime,
             execute_model: input.executeModel ?? input.planModel ?? run.executeModel,
         });
+        if (input.executeBudget !== undefined) {
+            patchRunPhaseBudget(retry.id, "execute", input.executeBudget);
+        }
         try {
             addArtifact(retry.id, "approved_plan", JSON.parse(approvedPlan.contentJson), approvedPlan.author);
         }