agent-dealer 0.1.8 → 0.1.10

package/bundle/server/dist/adapters/agent-deck.js

@@ -282,22 +282,29 @@ function formatToolResultText(tr) {
 export async function deliverOutboundDraft(deckId, toolCall, opts) {
     const payload = toCallServiceToolPayload(toolCall);
     const workspaceRoot = opts?.workspaceRoot ?? process.cwd();
+    const timeoutMs = opts?.timeoutMs ?? Number(process.env.DELIVER_TIMEOUT_MS ?? 60_000);
     const callTool = opts?.callTool ??
         (async (p) => {
             const mcpBase = getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "");
             const transport = new StreamableHTTPClientTransport(new URL(`${mcpBase}/mcp`));
             const client = new Client({ name: "agent-dealer-deliver", version: "0.0.1" });
-            await client.connect(transport);
-            try {
-                await client.callTool({
-                    name: "bind_workspace",
-                    arguments: { deckId, workspaceRoot },
-                });
-                return await client.callTool({ name: "call_service_tool", arguments: p });
-            }
-            finally {
-                await client.close();
-            }
+            const connectAndCall = async () => {
+                await client.connect(transport);
+                try {
+                    await client.callTool({
+                        name: "bind_workspace",
+                        arguments: { deckId, workspaceRoot },
+                    });
+                    return await client.callTool({ name: "call_service_tool", arguments: p });
+                }
+                finally {
+                    await client.close();
+                }
+            };
+            return await Promise.race([
+                connectAndCall(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Outbound deliver timed out after ${timeoutMs}ms`)), timeoutMs)),
+            ]);
         });
     const toolResult = await callTool(payload);
     assertCallServiceToolSuccess(toolResult);

package/bundle/server/dist/index.js

@@ -4,7 +4,7 @@ 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 { startQueue, recoverOrphanedRuns } from "./queue/dispatcher.js";
 import { registerStaticUi } from "./static-ui.js";
 const { mode, envFile } = loadAgentDealerEnv();
 console.log(formatEnvStartupLine(mode, envFile));
@@ -16,8 +16,12 @@ async function main() {
     await app.register(cors, { origin: true });
     await registerRoutes(app);
     const uiDist = await registerStaticUi(app);
+    const orphans = recoverOrphanedRuns();
+    if (orphans > 0) {
+        console.warn(`[startup] recovered ${orphans} orphaned running run(s) → failed`);
+    }
     startQueue();
-    await app.listen({ port, host: "0.0.0.0" });
+    await app.listen({ port, host: "127.0.0.1" });
     const base = `http://127.0.0.1:${port}`;
     console.log(`agent-dealer API ${base}`);
     if (uiDist) {

package/bundle/server/dist/queue/approve-deliver.js

@@ -2,7 +2,7 @@ import { deliverOutboundDraft } from "../adapters/agent-deck.js";
 import { syncLinearForRun } from "../adapters/linear-sync.js";
 import { workspaceForRun } from "../runners/prompts.js";
 import { addArtifact, appendEvent, getRun, transitionRun, } from "../repository/runs.js";
-import { deliverInFlight, getPendingOutboundDraft, markOutboundDraftSent, } from "../repository/outbound-drafts.js";
+import { deliverInFlight, getPendingOutboundDraft, markOutboundDraftSent, patchPendingOutboundBody, revertOutboundDraftToPending, } from "../repository/outbound-drafts.js";
 import { scheduleReflect } from "./dispatcher.js";
 export async function approveRunWithDeliver(runId, deps) {
     const run = getRun(runId);
@@ -14,7 +14,20 @@ export async function approveRunWithDeliver(runId, deps) {
     if (deliverInFlight.has(runId)) {
         return { ok: false, code: 409, error: "Deliver already in progress" };
     }
-    const pending = getPendingOutboundDraft(runId);
+    let pending = getPendingOutboundDraft(runId);
+    if (pending && deps?.outboundBody !== undefined) {
+        const trimmed = deps.outboundBody.trim();
+        if (!trimmed) {
+            return { ok: false, code: 400, error: "Outbound message body cannot be empty" };
+        }
+        if (trimmed !== pending.content.draft.summary.body) {
+            const patched = patchPendingOutboundBody(pending.artifact.id, trimmed);
+            if (!patched) {
+                return { ok: false, code: 409, error: "Draft already sent or rejected" };
+            }
+            pending = getPendingOutboundDraft(runId);
+        }
+    }
     if (!pending) {
         const updated = transitionRun(runId, "done");
         syncLinearForRun(updated, "done").catch((e) => console.error("[linear-sync] done:", e));
@@ -27,6 +40,10 @@ export async function approveRunWithDeliver(runId, deps) {
     const deliver = deps?.deliver ?? deliverOutboundDraft;
     deliverInFlight.add(runId);
     try {
+        const claimed = markOutboundDraftSent(pending.artifact.id);
+        if (!claimed) {
+            return { ok: false, code: 409, error: "Draft already sent or rejected" };
+        }
         let toolResult;
         let permalink;
         try {
@@ -37,14 +54,11 @@ export async function approveRunWithDeliver(runId, deps) {
             permalink = result.permalink;
         }
         catch (err) {
+            revertOutboundDraftToPending(pending.artifact.id);
             const message = err instanceof Error ? err.message : String(err);
             appendEvent(runId, "deliver_failed", { error: message });
             return { ok: false, code: 502, error: message };
         }
-        const sent = markOutboundDraftSent(pending.artifact.id);
-        if (!sent) {
-            return { ok: false, code: 409, error: "Draft already sent or rejected" };
-        }
         addArtifact(runId, "send_receipt", {
             draftArtifactId: pending.artifact.id,
             sentAt: new Date().toISOString(),

package/bundle/server/dist/queue/dispatcher-recovery.test.js

@@ -0,0 +1,37 @@
+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-recovery-"));
+process.env.MAX_CONCURRENT_RUNS = "2";
+process.env.MAX_PLAN_ATTEMPTS = "3";
+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, getRun, transitionRun, } = await import("../repository/runs.js");
+const { recoverOrphanedRuns, cancelActiveRun, } = await import("./dispatcher.js");
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+test("recoverOrphanedRuns fails stuck running rows", () => {
+    const run = createRun({
+        title: "Orphan",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    transitionRun(run.id, "plan_approved");
+    transitionRun(run.id, "running");
+    assert.equal(getRun(run.id).status, "running");
+    const n = recoverOrphanedRuns();
+    assert.equal(n, 1);
+    assert.equal(getRun(run.id).status, "failed");
+});
+test("recoverOrphanedRuns is a no-op when queue is clean", () => {
+    assert.equal(recoverOrphanedRuns(), 0);
+});
+test("cancelActiveRun delegates to process registry without throwing", () => {
+    assert.doesNotThrow(() => cancelActiveRun("missing-run-id"));
+});

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

@@ -1,7 +1,7 @@
-import { planGateDecision } from "@agent-dealer/shared";
+import { canTransition, planGateDecision } from "@agent-dealer/shared";
 import { buildPlanEditedReplanPrompt, buildPlanFeedbackPrompt, 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 { runAgent, killRunProcess } from "../runners/claude.js";
 import { persistRunOutput, seedDeliverableFromParent } from "../runners/persist.js";
 import { checkAgentDeckHealth } from "../adapters/agent-deck.js";
 import { pollLinearIssues } from "../adapters/external.js";
@@ -16,6 +16,10 @@ const activeReflects = new Set();
 let listeners = [];
 let pollTimer = null;
 let dispatchTimer = null;
+let healthCache = null;
+const HEALTH_CACHE_MS = 15_000;
+const MAX_PLAN_ATTEMPTS = Number(process.env.MAX_PLAN_ATTEMPTS ?? 3);
+const EMPTY_PLAN_ERROR = "Agent did not return a plan";
 function maxConcurrent() {
     return Number(process.env.MAX_CONCURRENT_RUNS ?? 2);
 }
@@ -121,11 +125,53 @@ export function getSnapshot() {
 }
 export async function getSnapshotAsync() {
     const snap = getSnapshot();
-    snap.agentDeckOnline = await checkAgentDeckHealth();
-    snap.agents = await listAgentsWithHealth(listAgents());
+    const now = Date.now();
+    if (!healthCache || now - healthCache.at > HEALTH_CACHE_MS) {
+        healthCache = {
+            at: now,
+            agentDeckOnline: await checkAgentDeckHealth(),
+            agents: await listAgentsWithHealth(listAgents()),
+        };
+    }
+    snap.agentDeckOnline = healthCache.agentDeckOnline;
+    snap.agents = healthCache.agents;
     snap.agentIssueCount = snap.agents.filter((a) => !a.healthy).length;
     return snap;
 }
+/** Fail runs left in `running` after a server restart or crash. */
+export function recoverOrphanedRuns() {
+    let count = 0;
+    for (const run of listRuns("running")) {
+        transitionRun(run.id, "failed");
+        addArtifact(run.id, "feedback", { error: "Server restarted mid-run — retry from failed", recoverable: true }, "system");
+        count++;
+    }
+    return count;
+}
+function reconcileOrphanedRunning() {
+    for (const run of listRuns("running")) {
+        if (activeRuns.has(run.id))
+            continue;
+        transitionRun(run.id, "failed");
+        addArtifact(run.id, "feedback", { error: "Run lost active worker — marked failed", recoverable: true }, "system");
+    }
+}
+function priorEmptyPlanAttempts(runId) {
+    return listArtifacts(runId).filter((a) => {
+        if (a.kind !== "feedback" || !a.contentJson)
+            return false;
+        try {
+            const c = JSON.parse(a.contentJson);
+            return c.error === EMPTY_PLAN_ERROR;
+        }
+        catch {
+            return false;
+        }
+    }).length;
+}
+export function cancelActiveRun(runId) {
+    killRunProcess(runId);
+}
 export function subscribe(listener) {
     listeners.push(listener);
     return () => {
@@ -217,6 +263,7 @@ async function dispatchPlanDrafts() {
     }
 }
 async function dispatch() {
+    reconcileOrphanedRunning();
     await dispatchPlanDrafts();
     const running = countByStatus("running");
     const slots = maxConcurrent() - running;
@@ -226,7 +273,9 @@ async function dispatch() {
     for (const run of approved.slice(0, slots)) {
         if (activeRuns.has(run.id))
             continue;
-        const job = executeRun(run).finally(() => {
+        const job = executeRun(run)
+            .catch((e) => console.error("[execute]", run.id, e))
+            .finally(() => {
             activeRuns.delete(run.id);
             notify().catch(console.error);
         });
@@ -277,7 +326,13 @@ export function applyPlanGate(run) {
     const draft = getLatestArtifact(run.id, "draft_plan");
     if (!draft?.contentJson)
         return "await_review";
-    const plan = JSON.parse(draft.contentJson);
+    let plan;
+    try {
+        plan = JSON.parse(draft.contentJson);
+    }
+    catch {
+        return "await_review";
+    }
     addArtifact(run.id, "approved_plan", { ...plan, autoApproved: true, rationale: triage.rationale }, "system");
     transitionRun(run.id, "plan_approved");
     void forceDispatch();
@@ -327,12 +382,27 @@ export async function draftPlan(run, opts) {
             }
         }
         else if (!opts?.replace) {
-            addArtifact(updated.id, "feedback", { error: "Agent did not return a plan" }, "system");
+            addArtifact(updated.id, "feedback", { error: EMPTY_PLAN_ERROR }, "system");
         }
-        const planFailed = !persisted.planMarkdown && result.exitCode !== 0;
+        const emptyPlanExhausted = !persisted.planMarkdown &&
+            !opts?.replace &&
+            priorEmptyPlanAttempts(updated.id) >= MAX_PLAN_ATTEMPTS;
+        const planFailed = result.timedOut ||
+            emptyPlanExhausted ||
+            (!persisted.planMarkdown && result.exitCode !== 0);
         if (planFailed) {
-            transitionRun(run.id, "failed");
-            addArtifact(run.id, "feedback", { error: "Planning failed", exitCode: result.exitCode }, "system");
+            const stillActive = getRun(run.id);
+            if (stillActive && (stillActive.status === "plan_pending" || stillActive.status === "queued")) {
+                transitionRun(run.id, "failed");
+                addArtifact(run.id, "feedback", {
+                    error: result.timedOut
+                        ? "Planning timed out"
+                        : emptyPlanExhausted
+                            ? `Planning failed after ${MAX_PLAN_ATTEMPTS} empty results`
+                            : "Planning failed",
+                    exitCode: result.exitCode,
+                }, "system");
+            }
         }
     }
     catch (err) {
@@ -394,7 +464,15 @@ export function submitPlanAnswers(runId, input, opts) {
             return { ok: false, code: 409, error: String(e) };
         }
         const draft = getLatestArtifact(runId, "draft_plan");
-        const plan = draft?.contentJson ? JSON.parse(draft.contentJson) : { markdown: "" };
+        let plan = { markdown: "" };
+        if (draft?.contentJson) {
+            try {
+                plan = JSON.parse(draft.contentJson);
+            }
+            catch {
+                return { ok: false, code: 409, error: "Draft plan is unreadable — request a re-draft" };
+            }
+        }
         addArtifact(runId, "approved_plan", plan, "human");
         void forceDispatch();
         return { ok: true, outcome, run: getRun(runId) };
@@ -470,6 +548,11 @@ async function executeRun(run) {
         transitionRun(run.id, "running");
         await notify();
         const result = await runAgent(run, "execute");
+        const after = getRun(run.id);
+        if (!after || after.status === "cancelled") {
+            await notify();
+            return;
+        }
         const persisted = persistRunOutput({
             run,
             phase: "execute",
@@ -478,11 +561,20 @@ async function executeRun(run) {
             logPath: result.logPath,
             rawTranscript: result.transcript,
         });
-        if (result.exitCode === 0 && !persisted.blocked) {
+        const current = getRun(run.id);
+        if (!current || current.status === "cancelled") {
+            await notify();
+            return;
+        }
+        if (result.timedOut) {
+            transitionRun(run.id, "failed");
+            addArtifact(run.id, "feedback", { error: "Execution timed out", exitCode: result.exitCode, logPath: result.logPath }, "system");
+        }
+        else if (result.exitCode === 0 && !persisted.blocked) {
             const updated = transitionRun(run.id, "review");
             syncLinearForRun(updated, "review").catch((e) => console.error("[linear-sync] review:", e));
         }
-        else {
+        else if (canTransition(current.status, "failed")) {
             transitionRun(run.id, "failed");
             addArtifact(run.id, "feedback", {
                 error: persisted.blocked ? "Execution blocked" : "Execution failed",
@@ -492,8 +584,11 @@ async function executeRun(run) {
         }
     }
     catch (err) {
-        transitionRun(run.id, "failed");
-        addArtifact(run.id, "feedback", { error: String(err) }, "system");
+        const after = getRun(run.id);
+        if (after && after.status !== "cancelled" && canTransition(after.status, "failed")) {
+            transitionRun(run.id, "failed");
+            addArtifact(run.id, "feedback", { error: String(err) }, "system");
+        }
     }
     await notify();
 }

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

@@ -73,6 +73,24 @@ test("approve with mock deliver sends byte-identical payload and creates receipt
     const draftArt = getLatestArtifact(run.id, "slack_draft");
     assert.match(draftArt.contentJson, /"status":"sent"/);
 });
+test("approve with human-edited body sends updated payload", async () => {
+    const run = seedReviewRun(true);
+    let captured = null;
+    const res = await approveRunWithDeliver(run.id, {
+        outboundBody: "Human tweak before send",
+        deliver: async (_deckId, toolCall) => {
+            captured = toolCall;
+            return { toolResult: { ok: true } };
+        },
+    });
+    assert.equal(res.ok, true);
+    assert.deepEqual(captured, {
+        ...TOOL_CALL,
+        arguments: { ...TOOL_CALL.arguments, text: "Human tweak before send" },
+    });
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /Human tweak before send/);
+});
 test("deliver failure keeps run in review with pending draft", async () => {
     const run = seedReviewRun(true);
     const res = await approveRunWithDeliver(run.id, {
@@ -84,6 +102,22 @@ test("deliver failure keeps run in review with pending draft", async () => {
     assert.equal(!res.ok && res.code, 502);
     assert.equal(getRun(run.id).status, "review");
     assert.equal(pendingSendCount(run.id), 1);
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /"status":"pending"/);
+});
+test("mark sent before deliver prevents double-send race", async () => {
+    const run = seedReviewRun(true);
+    let deliverCalls = 0;
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => {
+            deliverCalls++;
+            return { toolResult: { ok: true } };
+        },
+    });
+    assert.equal(res.ok, true);
+    assert.equal(deliverCalls, 1);
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /"status":"sent"/);
 });
 test("proxy success:false from deck is treated as deliver failure", async () => {
     const run = seedReviewRun(true);

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

@@ -1,4 +1,4 @@
-import { isOutboundDraftKind } from "@agent-dealer/shared";
+import { applyOutboundBodyEdit, isOutboundDraftKind, outboundMessageMatchesSummary, } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
 import { listArtifacts } from "./runs.js";
 export function getPendingOutboundDraft(runId) {
@@ -38,6 +38,53 @@ export function rejectPendingOutboundDrafts(runId) {
         }
     }
 }
+/** Apply human body edit to a pending draft artifact. Returns false if not pending. */
+export function patchPendingOutboundBody(artifactId, body) {
+    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 draft = applyOutboundBodyEdit(content.draft, body);
+    const next = {
+        ...content,
+        draft,
+        bodyMismatch: !outboundMessageMatchesSummary(draft.toolCall, draft.summary.body),
+    };
+    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;
+}
+/** Revert sent → pending after a failed deliver attempt. Returns false if not sent. */
+export function revertOutboundDraftToPending(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 !== "sent")
+        return false;
+    const next = { ...content, status: "pending", sentAt: undefined };
+    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;
+}
 /** Atomic pending → sent transition. Returns false if not pending. */
 export function markOutboundDraftSent(artifactId) {
     const db = getDb();

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

@@ -1,14 +1,15 @@
 import fs from "node:fs";
-import { CreateRunInput, AgentConfigInput, AgentDeckConfigPatch, CreateAgentInput, UpdateAgentInput, DraftPlanInput, KickRunInput, PlanAnswersInput, ResultQaInput, LinearIntakeConfigPatch, PromoteLinearInput, RetryRunInput, Runtime, UpdatePlanInput, BUILTIN_AGENT_CLAUDE_ID, } from "@agent-dealer/shared";
+import { ApproveRunInput, CreateRunInput, AgentConfigInput, AgentDeckConfigPatch, CreateAgentInput, UpdateAgentInput, DraftPlanInput, KickRunInput, PlanAnswersInput, ResultQaInput, LinearIntakeConfigPatch, PromoteLinearInput, RetryRunInput, Runtime, UpdatePlanInput, BUILTIN_AGENT_CLAUDE_ID, } from "@agent-dealer/shared";
 import { parseRunBudget } from "@agent-dealer/shared";
 import { addArtifact, createRun, findActiveByExternalId, getRun, listArtifacts, listEvents, listRuns, updateRunFields, 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, submitPlanAnswers, subscribe, } from "../queue/dispatcher.js";
+import { forceDispatch, getSnapshotAsync, kickRun, cancelActiveRun, schedulePlanDraft, scheduleRedraft, scheduleReflect, submitPlanAnswers, subscribe, } from "../queue/dispatcher.js";
 import { approveRunWithDeliver } from "../queue/approve-deliver.js";
 import { recordPlanDelegation } from "../queue/plan-delegation.js";
 import { askResultQuestion } from "../queue/result-qa.js";
-import { rejectPendingOutboundDrafts } from "../repository/outbound-drafts.js";
+import { rejectPendingOutboundDrafts, deliverInFlight } from "../repository/outbound-drafts.js";
+import { getActiveLogPath } from "../runners/claude.js";
 import { fetchAgentDeckDecks } from "../adapters/agent-deck.js";
 import { testAgentDeckConnection } from "../adapters/agent-deck.js";
 import { getLinearIssue, listLinearCandidates, testLinearConnection, } from "../adapters/linear-inbox.js";
@@ -77,14 +78,16 @@ export async function registerRoutes(app) {
         const artifact = artifacts.find((a) => a.kind === kind && a.blobPath) ??
             artifacts.find((a) => a.kind === "transcript" && a.blobPath) ??
             artifacts.find((a) => a.kind === "stream_trace" && a.blobPath);
-        if (!artifact?.blobPath)
+        const livePath = getActiveLogPath(id);
+        const blobPath = artifact?.blobPath ?? livePath;
+        if (!blobPath)
             return reply.status(404).send({ error: "No log artifact" });
-        if (!fs.existsSync(artifact.blobPath)) {
+        if (!fs.existsSync(blobPath)) {
             return reply.status(404).send({ error: "Log file missing on disk" });
         }
         const max = Math.min(Number(req.query.max ?? 50000), 200000);
-        const raw = fs.readFileSync(artifact.blobPath, "utf8");
-        return { content: raw.slice(-max), path: artifact.blobPath, kind: artifact.kind };
+        const raw = fs.readFileSync(blobPath, "utf8");
+        return { content: raw.slice(-max), path: blobPath, kind: artifact?.kind ?? kind, live: !!livePath };
     });
     app.get("/api/intake/linear/status", async () => testLinearConnection());
     app.get("/api/intake/linear/config", async () => getLinearIntakeConfigView());
@@ -395,7 +398,10 @@ export async function registerRoutes(app) {
     });
     app.post("/api/runs/:id/approve", async (req, reply) => {
         const { id } = req.params;
-        const result = await approveRunWithDeliver(id);
+        const input = ApproveRunInput.parse(req.body ?? {});
+        const result = await approveRunWithDeliver(id, {
+            outboundBody: input.outboundBody,
+        });
         if (!result.ok) {
             return reply.status(result.code).send({ error: result.error });
         }
@@ -409,6 +415,9 @@ export async function registerRoutes(app) {
         if (run.status !== "review" && run.status !== "failed") {
             return reply.status(400).send({ error: "Retry only from review or failed" });
         }
+        if (deliverInFlight.has(id)) {
+            return reply.status(409).send({ error: "Deliver in progress — wait before retrying" });
+        }
         const approvedPlan = getLatestArtifact(id, "approved_plan");
         if (!approvedPlan?.contentJson) {
             return reply.status(400).send({ error: "No approved plan — cannot retry execution" });
@@ -476,6 +485,7 @@ export async function registerRoutes(app) {
         const run = getRun(id);
         if (!run)
             return reply.status(404).send({ error: "Not found" });
+        cancelActiveRun(id);
         return transitionRun(id, "cancelled");
     });
     app.get("/api/snapshot", async () => getSnapshotAsync());

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

@@ -1,11 +1,12 @@
 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 DECK_EXECUTE_TOOLS = `${DECK_READ_TOOLS},mcp__agent-deck__call_service_tool`;
 const PLAN_REFLECT_TOOLS = `Read,Glob,Grep,Skill,${DECK_READ_TOOLS}`;
 /** Q&A about a finished result — read-only, no deck writes, no workspace mutation. */
 const QA_TOOLS = "Read,Glob,Grep,Skill";
 function executeToolsForCategory(category) {
-    const base = ["Read", "Write", "Edit", "Glob", "Grep", "Skill", DECK_READ_TOOLS];
+    const base = ["Read", "Write", "Edit", "Glob", "Grep", "Skill", DECK_EXECUTE_TOOLS];
     if (category !== "communication" && category !== "email") {
         base.splice(5, 0, "Bash");
     }
@@ -24,6 +25,9 @@ export function buildClaudePhaseArgs(run, mode) {
         args.push("--add-dir", getTemporalOutputDir());
         args.push("--allowedTools", executeToolsForCategory(run.taskCategory));
     }
-    args.push("--disallowedTools", DENY_SEND_TOOL);
+    // Soft gate: execute may call_service_tool; plan/reflect/qa stay denied.
+    if (mode !== "execute") {
+        args.push("--disallowedTools", DENY_SEND_TOOL);
+    }
     return args;
 }