agent-dealer 0.1.2 → 0.1.4

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

@@ -0,0 +1,108 @@
+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-send-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, transitionRun, updateRunFields, } = await import("../repository/runs.js");
+const { approveRunWithDeliver } = await import("./approve-deliver.js");
+const { rejectPendingOutboundDrafts, pendingSendCount } = await import("../repository/outbound-drafts.js");
+const { getSnapshot } = await import("./dispatcher.js");
+const TOOL_CALL = {
+    serviceName: "34eb6c24-f151-4da2-8db8-d6996aa296be",
+    toolName: "chat_postMessage",
+    arguments: { channel: "C1", text: "Hello gate test" },
+};
+const DRAFT_CONTENT = {
+    draft: {
+        actionType: "slack_message",
+        summary: { target: "#test", body: "Hello gate test" },
+        toolCall: TOOL_CALL,
+    },
+    status: "pending",
+};
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function seedReviewRun(withDraft = true) {
+    const run = createRun({
+        title: "Send gate test",
+        taskCategory: "communication",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    updateRunFields(run.id, { deck_id: "6e825b59-13de-4ddd-ab7e-55ab5a1c279a" });
+    transitionRun(run.id, "plan_approved");
+    transitionRun(run.id, "running");
+    transitionRun(run.id, "review");
+    if (withDraft) {
+        addArtifact(run.id, "slack_draft", DRAFT_CONTENT, "agent");
+    }
+    return getRun(run.id);
+}
+test("pendingSendCount is 1 when draft pending", () => {
+    const run = seedReviewRun(true);
+    assert.equal(pendingSendCount(run.id), 1);
+});
+test("approve without draft transitions to done", async () => {
+    const run = seedReviewRun(false);
+    const res = await approveRunWithDeliver(run.id);
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.delivered, false);
+    assert.equal(getRun(run.id).status, "done");
+});
+test("approve with mock deliver sends byte-identical payload and creates receipt", async () => {
+    const run = seedReviewRun(true);
+    let captured = null;
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async (_deckId, toolCall) => {
+            captured = toolCall;
+            return { toolResult: { ok: true }, permalink: "https://slack.example/msg/1" };
+        },
+    });
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.delivered, true);
+    assert.deepEqual(captured, TOOL_CALL);
+    assert.equal(getRun(run.id).status, "done");
+    assert.ok(getLatestArtifact(run.id, "send_receipt"));
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /"status":"sent"/);
+});
+test("deliver failure keeps run in review with pending draft", async () => {
+    const run = seedReviewRun(true);
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => {
+            throw new Error("deck down");
+        },
+    });
+    assert.equal(res.ok, false);
+    assert.equal(!res.ok && res.code, 502);
+    assert.equal(getRun(run.id).status, "review");
+    assert.equal(pendingSendCount(run.id), 1);
+});
+test("proxy success:false from deck is treated as deliver failure", async () => {
+    const run = seedReviewRun(true);
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => {
+            throw new Error("Service not found");
+        },
+    });
+    assert.equal(res.ok, false);
+    assert.equal(getRun(run.id).status, "review");
+});
+test("retry rejects pending draft", () => {
+    const run = seedReviewRun(true);
+    rejectPendingOutboundDrafts(run.id);
+    assert.equal(pendingSendCount(run.id), 0);
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /"status":"rejected"/);
+});
+test("snapshot exposes pendingSendCounts", () => {
+    const snap = getSnapshot();
+    assert.equal(typeof snap.pendingSendCounts, "object");
+});

package/bundle/server/dist/repository/outbound-drafts.js

@@ -0,0 +1,62 @@
+import { isOutboundDraftKind } from "@agent-dealer/shared";
+import { getDb } from "../db/index.js";
+import { listArtifacts } from "./runs.js";
+export function getPendingOutboundDraft(runId) {
+    const arts = listArtifacts(runId).filter((a) => isOutboundDraftKind(a.kind) && a.contentJson);
+    for (let i = arts.length - 1; i >= 0; i--) {
+        const art = arts[i];
+        try {
+            const content = JSON.parse(art.contentJson);
+            if (content.status === "pending") {
+                return { artifact: art, content };
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return null;
+}
+export function pendingSendCount(runId) {
+    return getPendingOutboundDraft(runId) ? 1 : 0;
+}
+export function rejectPendingOutboundDrafts(runId) {
+    const now = new Date().toISOString();
+    const db = getDb();
+    for (const art of listArtifacts(runId)) {
+        if (!isOutboundDraftKind(art.kind) || !art.contentJson)
+            continue;
+        try {
+            const content = JSON.parse(art.contentJson);
+            if (content.status !== "pending")
+                continue;
+            const next = { ...content, status: "rejected", rejectedAt: now };
+            db.prepare("UPDATE artifacts SET content_json = ? WHERE id = ?").run(JSON.stringify(next), art.id);
+        }
+        catch {
+            // skip
+        }
+    }
+}
+/** Atomic pending → sent transition. Returns false if not pending. */
+export function markOutboundDraftSent(artifactId) {
+    const db = getDb();
+    const row = db.prepare("SELECT content_json FROM artifacts WHERE id = ?").get(artifactId);
+    if (!row?.content_json)
+        return false;
+    let content;
+    try {
+        content = JSON.parse(row.content_json);
+    }
+    catch {
+        return false;
+    }
+    if (content.status !== "pending")
+        return false;
+    const next = { ...content, status: "sent", sentAt: new Date().toISOString() };
+    const result = db
+        .prepare("UPDATE artifacts SET content_json = ? WHERE id = ? AND content_json = ?")
+        .run(JSON.stringify(next), artifactId, row.content_json);
+    return result.changes === 1;
+}
+export const deliverInFlight = new Set();

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

@@ -168,7 +168,8 @@ export function updateRunBudget(id, patch) {
 export function patchRunPhaseBudget(id, phase, budget) {
     if (budget === undefined)
         return getRun(id);
-    return updateRunBudget(id, { [phase]: budget ?? undefined });
+    // 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;
@@ -387,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,10 +1,12 @@
 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 { 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, patchRunPhaseBudget, updateRunBudget, } from "../repository/runs.js";
+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 { approveRunWithDeliver } from "../queue/approve-deliver.js";
+import { rejectPendingOutboundDrafts } from "../repository/outbound-drafts.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";
@@ -53,11 +55,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),
         };
     });
@@ -272,8 +275,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;
@@ -301,16 +302,40 @@ export async function registerRoutes(app) {
             if (input.executeBudget !== undefined) {
                 patchRunPhaseBudget(id, "execute", input.executeBudget);
             }
-            const updated = transitionRun(id, "plan_approved");
+            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);
@@ -350,16 +375,11 @@ export async function registerRoutes(app) {
     });
     app.post("/api/runs/:id/approve", async (req, reply) => {
         const { id } = req.params;
-        const run = getRun(id);
-        if (!run)
-            return reply.status(404).send({ error: "Not found" });
-        if (run.status !== "review") {
-            return reply.status(400).send({ error: "Run must be in review" });
+        const result = await approveRunWithDeliver(id);
+        if (!result.ok) {
+            return reply.status(result.code).send({ error: result.error });
         }
-        const updated = transitionRun(id, "done");
-        syncLinearForRun(updated, "done").catch((e) => console.error("[linear-sync] done:", e));
-        scheduleReflect(updated, { trigger: "approve" });
-        return updated;
+        return result.run;
     });
     app.post("/api/runs/:id/retry", async (req, reply) => {
         const { id } = req.params;
@@ -375,6 +395,7 @@ export async function registerRoutes(app) {
         }
         const input = RetryRunInput.parse(req.body);
         addArtifact(id, "feedback", { markdown: input.feedback }, "human");
+        rejectPendingOutboundDrafts(id);
         const retry = createRun({
             title: run.title,
             description: run.description ?? undefined,
@@ -394,6 +415,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);
         }

package/bundle/server/dist/runners/claude-args.js

@@ -0,0 +1,24 @@
+import { getTemporalOutputDir } from "../paths.js";
+export const DENY_SEND_TOOL = "mcp__agent-deck__call_service_tool";
+const DECK_READ_TOOLS = "mcp__agent-deck__get_playbook,mcp__agent-deck__get_bound_deck,mcp__agent-deck__bind_workspace,mcp__agent-deck__list_service_tools";
+const PLAN_REFLECT_TOOLS = `Read,Glob,Grep,Skill,${DECK_READ_TOOLS}`;
+function executeToolsForCategory(category) {
+    const base = ["Read", "Write", "Edit", "Glob", "Grep", "Skill", DECK_READ_TOOLS];
+    if (category !== "communication" && category !== "email") {
+        base.splice(5, 0, "Bash");
+    }
+    return base.join(",");
+}
+/** Build claude -p CLI args for a phase (excluding prompt, model, resume, mcp-config, budget). */
+export function buildClaudePhaseArgs(run, mode) {
+    const args = ["--output-format", "stream-json", "--verbose"];
+    if (mode === "plan" || mode === "reflect") {
+        args.push("--allowedTools", PLAN_REFLECT_TOOLS);
+    }
+    else {
+        args.push("--add-dir", getTemporalOutputDir());
+        args.push("--allowedTools", executeToolsForCategory(run.taskCategory));
+    }
+    args.push("--disallowedTools", DENY_SEND_TOOL);
+    return args;
+}

package/bundle/server/dist/runners/claude.js

@@ -3,10 +3,11 @@ import fs from "node:fs";
 import path from "node:path";
 import { buildExecutionPrompt, buildExecutionContinuationPrompt, buildPlanPrompt, buildReflectPrompt, workspaceForRun } from "./prompts.js";
 import { humanFeedbackText, lineageParentExecuteSessionId } from "./run-context.js";
-import { getTemporalLogsDir, getTemporalOutputDir } from "../paths.js";
+import { getTemporalLogsDir } from "../paths.js";
 import { resolveClaudeBin, resolveCursorBin } from "../cli-env.js";
 import { resolveBudgetForPhase, resolveModelForPhase, getRun } from "../repository/runs.js";
 import { budgetCliArgs } from "@agent-dealer/shared";
+import { buildClaudePhaseArgs } from "./claude-args.js";
 async function spawnCli(cmd, args, cwd) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -25,14 +26,15 @@ function logPathFor(run, mode) {
     const logDir = getTemporalLogsDir();
     return path.join(logDir, `${run.id}-${mode}-${Date.now()}.ndjson`);
 }
-export async function runClaude(run, mode = "execute", model, promptOverride) {
+export async function runClaude(run, mode = "execute", model, opts) {
     const mcpConfig = process.env.CLAUDE_MCP_CONFIG ?? path.join(process.env.HOME ?? "", ".claude.json");
     if (!fs.existsSync(mcpConfig)) {
         throw new Error(`MCP config not found: ${mcpConfig}. Set CLAUDE_MCP_CONFIG.`);
     }
     const phaseBudget = resolveBudgetForPhase(run, mode);
-    const resumeSessionId = mode === "execute" && humanFeedbackText(run) ? lineageParentExecuteSessionId(run) : null;
-    const prompt = promptOverride ??
+    const resumeSessionId = opts?.resumeSessionId ??
+        (mode === "execute" && humanFeedbackText(run) ? lineageParentExecuteSessionId(run) : null);
+    const prompt = opts?.promptOverride ??
         (mode === "plan"
             ? buildPlanPrompt(run)
             : mode === "reflect"
@@ -49,19 +51,8 @@ export async function runClaude(run, mode = "execute", model, promptOverride) {
         "--mcp-config",
         mcpConfig,
         ...budgetCliArgs(phaseBudget),
-        "--output-format",
-        "stream-json",
-        "--verbose",
+        ...buildClaudePhaseArgs(run, mode),
     ];
-    if (mode === "plan") {
-        args.push("--allowedTools", "Read,Glob,Grep,mcp__agent-deck__get_playbook,mcp__agent-deck__get_bound_deck,mcp__agent-deck__bind_workspace");
-    }
-    else if (mode === "reflect") {
-        args.push("--allowedTools", "Read,Glob,Grep,mcp__agent-deck__get_playbook,mcp__agent-deck__get_bound_deck,mcp__agent-deck__bind_workspace");
-    }
-    else {
-        args.push("--add-dir", getTemporalOutputDir(), "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__agent-deck__get_playbook,mcp__agent-deck__get_bound_deck,mcp__agent-deck__bind_workspace");
-    }
     const { exitCode, transcript } = await spawnCli(resolveClaudeBin(), args, workspaceForRun(run));
     if (transcript)
         fs.writeFileSync(logPath, transcript);
@@ -85,12 +76,12 @@ export async function runCursor(run, mode = "execute", model) {
         fs.writeFileSync(logPath, transcript);
     return { exitCode, transcript, logPath };
 }
-export async function runAgent(run, mode = "execute") {
+export async function runAgent(run, mode = "execute", revise) {
     const fresh = getRun(run.id) ?? run;
     const model = resolveModelForPhase(fresh, mode);
     if (fresh.runtime === "cursor_local")
         return runCursor(fresh, mode, model);
-    return runClaude(fresh, mode, model);
+    return runClaude(fresh, mode, model, revise ? { promptOverride: revise.prompt, resumeSessionId: revise.resumeSessionId } : undefined);
 }
 /** @deprecated use stream-json extractPlanMarkdown via persistRunOutput */
 export function extractPlanFromTranscript(transcript) {

package/bundle/server/dist/runners/claude.test.js

@@ -0,0 +1,58 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { buildClaudePhaseArgs, DENY_SEND_TOOL } from "./claude-args.js";
+const baseRun = {
+    id: "00000000-0000-4000-a000-000000000099",
+    source: "manual",
+    externalId: null,
+    externalLabel: null,
+    title: "Test",
+    description: null,
+    repo: null,
+    artifactWorkspace: null,
+    agentId: null,
+    agentName: null,
+    deckId: null,
+    deckName: null,
+    playbookId: null,
+    runtime: "claude_code",
+    planModel: null,
+    executeModel: null,
+    status: "running",
+    lineageId: null,
+    acceptanceCriteria: null,
+    approvalGatesJson: null,
+    budgetJson: null,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+};
+function runWithCategory(taskCategory) {
+    return { ...baseRun, taskCategory };
+}
+function hasDisallowSend(args) {
+    const i = args.indexOf("--disallowedTools");
+    return i >= 0 && args[i + 1] === DENY_SEND_TOOL;
+}
+test("all phases deny call_service_tool", () => {
+    for (const mode of ["plan", "execute", "reflect"]) {
+        const args = buildClaudePhaseArgs(runWithCategory("code"), mode);
+        assert.equal(hasDisallowSend(args), true, mode);
+    }
+});
+test("execute allowlist includes list_service_tools", () => {
+    const args = buildClaudePhaseArgs(runWithCategory("code"), "execute");
+    const i = args.indexOf("--allowedTools");
+    assert.match(args[i + 1], /list_service_tools/);
+});
+test("communication and email execute omit Bash", () => {
+    for (const cat of ["communication", "email"]) {
+        const args = buildClaudePhaseArgs(runWithCategory(cat), "execute");
+        const i = args.indexOf("--allowedTools");
+        assert.doesNotMatch(args[i + 1], /\bBash\b/);
+    }
+});
+test("code execute retains Bash", () => {
+    const args = buildClaudePhaseArgs(runWithCategory("code"), "execute");
+    const i = args.indexOf("--allowedTools");
+    assert.match(args[i + 1], /\bBash\b/);
+});

package/bundle/server/dist/runners/persist.js

@@ -1,9 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { detectExecutionBlocker } from "@agent-dealer/shared";
-import { addArtifact, getLatestArtifact, getLineageParentRun } from "../repository/runs.js";
+import { detectExecutionBlocker, outboundDraftKind } from "@agent-dealer/shared";
+import { addArtifact, appendEvent, getLatestArtifact, getLineageParentRun, resolveBudgetForPhase } from "../repository/runs.js";
 import { getTemporalOutputDir } from "../paths.js";
-import { buildStreamTrace, extractPlanMarkdown, extractResultIsError, extractResultText, extractSessionId, extractUsage, parseNdjson, } from "./stream-json.js";
+import { buildStreamTrace, extractOutboundDraft, extractPlanMarkdown, extractPlanTriage, extractResultIsError, extractResultText, extractSessionId, extractUsage, parseNdjson, } from "./stream-json.js";
 import { humanFeedbackText } from "./run-context.js";
 export function seedDeliverableFromParent(run) {
     const parent = getLineageParentRun(run);
@@ -44,11 +44,20 @@ export function persistRunOutput(input) {
     const raw = input.rawTranscript ?? (fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "");
     const events = parseNdjson(raw);
     const sessionId = extractSessionId(events);
-    const resultText = extractResultText(events);
+    let resultText = extractResultText(events);
+    const outboundExtract = phase === "execute" ? extractOutboundDraft(resultText ?? "") : null;
+    if (outboundExtract) {
+        resultText = outboundExtract.markdown || resultText;
+    }
     const streamError = extractResultIsError(events);
     const blocker = detectExecutionBlocker(resultText);
     const isError = exitCode !== 0 || streamError || blocker.detected;
     const usage = extractUsage(events, phase, runtime);
+    const caps = resolveBudgetForPhase(run, phase);
+    if (caps?.maxTurns != null)
+        usage.maxTurns = caps.maxTurns;
+    if (caps?.maxBudgetUsd != null)
+        usage.maxBudgetUsd = caps.maxBudgetUsd;
     const trace = buildStreamTrace(events);
     if (sessionId) {
         addArtifact(run.id, "agent_session", { phase, runtime, sessionId }, "agent");
@@ -63,15 +72,45 @@ export function persistRunOutput(input) {
         blocker: blocker.detected ? { summary: blocker.summary } : undefined,
     }, "agent");
     addArtifact(run.id, "transcript", { phase, exitCode, excerpt: raw.slice(-20000), resultText: resultText?.slice(0, 8000) }, "agent", logPath);
-    if (phase === "execute") {
+    if (phase === "execute" && outboundExtract) {
         captureDocumentArtifact(run, resultText);
+        persistOutboundDraft(run, outboundExtract);
     }
     if (phase === "plan") {
-        const planMarkdown = extractPlanMarkdown(events);
-        return { planMarkdown, resultText, sessionId, blocked: blocker.detected, blockerSummary: blocker.summary };
+        const rawPlan = extractPlanMarkdown(events);
+        const planTriage = extractPlanTriage(rawPlan);
+        return {
+            planMarkdown: planTriage.markdown,
+            planTriage,
+            resultText,
+            sessionId,
+            blocked: blocker.detected,
+            blockerSummary: blocker.summary,
+        };
     }
     return { resultText, sessionId, blocked: blocker.detected, blockerSummary: blocker.summary };
 }
+function persistOutboundDraft(run, outbound) {
+    if (!outbound.hadJsonBlock)
+        return;
+    if (outbound.invalid) {
+        appendEvent(run.id, "outbound_draft_invalid", { reason: "malformed block" });
+        return;
+    }
+    if (!outbound.draft)
+        return;
+    if (outbound.mismatch) {
+        appendEvent(run.id, "outbound_draft_mismatch", {
+            summaryBody: outbound.draft.summary.body,
+            toolCall: outbound.draft.toolCall,
+        });
+    }
+    addArtifact(run.id, outboundDraftKind(outbound.draft.actionType), {
+        draft: outbound.draft,
+        status: "pending",
+        bodyMismatch: outbound.mismatch || undefined,
+    }, "agent");
+}
 function captureDocumentArtifact(run, resultText) {
     const docPath = expectedDocPath(run);
     if (fs.existsSync(docPath)) {