agent-dealer 0.1.3 → 0.1.5

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

@@ -0,0 +1,52 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { assertCallServiceToolSuccess, toCallServiceToolPayload } from "./agent-deck.js";
+test("toCallServiceToolPayload maps serviceName to serviceId verbatim args", () => {
+    const toolCall = {
+        serviceName: "34eb6c24-f151-4da2-8db8-d6996aa296be",
+        toolName: "chat_postMessage",
+        arguments: { channel: "C123", text: "Hello world" },
+    };
+    const payload = toCallServiceToolPayload(toolCall);
+    assert.equal(payload.serviceId, toolCall.serviceName);
+    assert.equal(payload.toolName, toolCall.toolName);
+    assert.deepEqual(payload.arguments, toolCall.arguments);
+});
+test("assertCallServiceToolSuccess throws on deck proxy failure JSON", () => {
+    assert.throws(() => assertCallServiceToolSuccess({
+        content: [{ type: "text", text: JSON.stringify({ success: false, error: "Service not found" }) }],
+    }), /Service not found/);
+});
+test("assertCallServiceToolSuccess throws on nested Slack channel_not_found", () => {
+    const receipt = {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    content: [{ type: "text", text: "channel_not_found\n\nThe channel could not be found." }],
+                    isError: true,
+                }),
+            },
+        ],
+    };
+    assert.throws(() => assertCallServiceToolSuccess(receipt), /channel_not_found/);
+});
+test("assertCallServiceToolSuccess throws on deck-wrapped Slack JSON (live MCP shape)", () => {
+    const receipt = {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    content: [
+                        {
+                            type: "text",
+                            text: "channel_not_found\n\nThe channel could not be found. It may not exist, may be in a different workspace than your app is installed on, or your app may lack permission to access it.",
+                        },
+                    ],
+                    isError: true,
+                }),
+            },
+        ],
+    };
+    assert.throws(() => assertCallServiceToolSuccess(receipt), /channel_not_found/);
+});

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

@@ -1,5 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { getAgentDeckConfig } from "../repository/intake-settings.js";
 export function getAgentDeckApiUrl() {
     if (process.env.AGENT_DECK_API_URL) {
@@ -134,3 +136,141 @@ export function isAgentDeckMcpRegistered() {
         return false;
     }
 }
+/** Map PRD toolCall to deck MCP call_service_tool args (serviceName → serviceId). */
+export function toCallServiceToolPayload(toolCall) {
+    return {
+        serviceId: toolCall.serviceName,
+        toolName: toolCall.toolName,
+        arguments: toolCall.arguments,
+    };
+}
+function extractPermalink(toolResult) {
+    if (!toolResult || typeof toolResult !== "object")
+        return undefined;
+    const content = toolResult.content;
+    if (!Array.isArray(content))
+        return undefined;
+    for (const block of content) {
+        if (block.type !== "text" || !block.text)
+            continue;
+        try {
+            const parsed = JSON.parse(block.text);
+            if (parsed.permalink)
+                return parsed.permalink;
+        }
+        catch {
+            const m = block.text.match(/https?:\/\/\S+/);
+            if (m)
+                return m[0];
+        }
+    }
+    return undefined;
+}
+/** Parse Agent Deck call_service_tool MCP result — throws on proxy- or Slack-reported failure. */
+export function assertCallServiceToolSuccess(toolResult) {
+    const err = findCallServiceToolError(toolResult);
+    if (err)
+        throw new Error(err);
+}
+function findCallServiceToolError(toolResult, depth = 0) {
+    if (!toolResult || typeof toolResult !== "object" || depth > 4)
+        return undefined;
+    const tr = toolResult;
+    if (tr.isError) {
+        const text = formatToolResultText(tr) ?? "call_service_tool failed";
+        const nested = parseNestedCallServiceToolError(text, depth);
+        if (nested)
+            return nested;
+        return summarizeToolErrorText(text) ?? text.slice(0, 500);
+    }
+    if (tr.success === false) {
+        return tr.error ?? "call_service_tool failed";
+    }
+    const text = formatToolResultText(tr);
+    if (text) {
+        const nested = parseNestedCallServiceToolError(text, depth);
+        if (nested)
+            return nested;
+        const plain = summarizeToolErrorText(text);
+        if (plain)
+            return plain;
+    }
+    return undefined;
+}
+function parseNestedCallServiceToolError(text, depth) {
+    try {
+        const parsed = JSON.parse(text);
+        return findCallServiceToolError(parsed, depth + 1);
+    }
+    catch {
+        return undefined;
+    }
+}
+const SLACK_ERROR_RE = /channel_not_found|not_in_channel|missing_scope|invalid_auth|user_not_found|cannot_dm|is_archived/i;
+function summarizeToolErrorText(text) {
+    const t = text.trim();
+    if (!t)
+        return undefined;
+    try {
+        const parsed = JSON.parse(t);
+        if (typeof parsed.error === "string" && parsed.error.trim())
+            return parsed.error.trim();
+        if (typeof parsed.message === "string" && parsed.message.trim())
+            return parsed.message.trim();
+    }
+    catch {
+        // not top-level JSON — fall through
+    }
+    if (SLACK_ERROR_RE.test(t)) {
+        const line = t.split("\n").find((l) => SLACK_ERROR_RE.test(l));
+        if (line?.trim())
+            return line.trim().slice(0, 500);
+        const match = t.match(SLACK_ERROR_RE);
+        if (match)
+            return match[0];
+    }
+    if (/"success"\s*:\s*false/i.test(t)) {
+        try {
+            const parsed = JSON.parse(t);
+            if (typeof parsed.error === "string" && parsed.error.trim())
+                return parsed.error.trim();
+        }
+        catch {
+            // ignore
+        }
+    }
+    return undefined;
+}
+function formatToolResultText(tr) {
+    if (!Array.isArray(tr.content))
+        return undefined;
+    return tr.content
+        .filter((b) => b.type === "text" && b.text)
+        .map((b) => b.text)
+        .join("\n")
+        .trim() || undefined;
+}
+export async function deliverOutboundDraft(deckId, toolCall, opts) {
+    const payload = toCallServiceToolPayload(toolCall);
+    const workspaceRoot = opts?.workspaceRoot ?? process.cwd();
+    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 toolResult = await callTool(payload);
+    assertCallServiceToolSuccess(toolResult);
+    return { toolResult, permalink: extractPermalink(toolResult) };
+}

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

@@ -0,0 +1,62 @@
+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 { scheduleReflect } from "./dispatcher.js";
+export async function approveRunWithDeliver(runId, deps) {
+    const run = getRun(runId);
+    if (!run)
+        return { ok: false, code: 404, error: "Not found" };
+    if (run.status !== "review") {
+        return { ok: false, code: 400, error: "Run must be in review" };
+    }
+    if (deliverInFlight.has(runId)) {
+        return { ok: false, code: 409, error: "Deliver already in progress" };
+    }
+    const pending = getPendingOutboundDraft(runId);
+    if (!pending) {
+        const updated = transitionRun(runId, "done");
+        syncLinearForRun(updated, "done").catch((e) => console.error("[linear-sync] done:", e));
+        scheduleReflect(updated, { trigger: "approve" });
+        return { ok: true, run: updated, delivered: false };
+    }
+    if (!run.deckId) {
+        return { ok: false, code: 502, error: "No deck bound — cannot deliver outbound draft" };
+    }
+    const deliver = deps?.deliver ?? deliverOutboundDraft;
+    deliverInFlight.add(runId);
+    try {
+        let toolResult;
+        let permalink;
+        try {
+            const result = await deliver(run.deckId, pending.content.draft.toolCall, {
+                workspaceRoot: workspaceForRun(run),
+            });
+            toolResult = result.toolResult;
+            permalink = result.permalink;
+        }
+        catch (err) {
+            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(),
+            toolResult: toolResult,
+            permalink,
+        }, "system");
+        const updated = transitionRun(runId, "done");
+        syncLinearForRun(updated, "done").catch((e) => console.error("[linear-sync] done:", e));
+        scheduleReflect(updated, { trigger: "approve" });
+        return { ok: true, run: updated, delivered: true };
+    }
+    finally {
+        deliverInFlight.delete(runId);
+    }
+}

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

@@ -6,6 +6,7 @@ import { persistRunOutput, seedDeliverableFromParent } from "../runners/persist.
 import { checkAgentDeckHealth } from "../adapters/agent-deck.js";
 import { pollLinearIssues } from "../adapters/external.js";
 import { syncLinearForRun } from "../adapters/linear-sync.js";
+import { pendingSendCount } from "../repository/outbound-drafts.js";
 import { listAgentsWithHealth } from "../adapters/agent-health.js";
 import { listAgents } from "../repository/agents.js";
 import { runReflect } from "../runners/reflect.js";
@@ -84,9 +85,18 @@ export function getSnapshot() {
             openQuestionCounts[run.id] = n;
     }
     const awaitingAnswerRuns = awaitingPlanReview.filter((r) => openQuestionCounts[r.id]);
+    const pendingSendCounts = {};
+    for (const run of resultReviewRuns) {
+        const n = pendingSendCount(run.id);
+        if (n > 0)
+            pendingSendCounts[run.id] = n;
+    }
     const autoApprovedRunIds = [...waitingExecution, ...runningRuns]
         .filter((r) => getLatestArtifact(r.id, "approved_plan")?.author === "system")
         .map((r) => r.id);
+    const sentRunIds = recentDone
+        .filter((r) => getLatestArtifact(r.id, "send_receipt"))
+        .map((r) => r.id);
     return {
         planReviewCount: awaitingPlanReview.length,
         resultReviewCount: resultReviewRuns.length,
@@ -100,6 +110,8 @@ export function getSnapshot() {
         awaitingPlanReview,
         awaitingAnswerRuns,
         openQuestionCounts,
+        pendingSendCounts,
+        sentRunIds,
         autoApprovedRunIds,
         runs: all,
         agentDeckOnline: false,

package/bundle/server/dist/queue/plan-delegation.js

@@ -0,0 +1,27 @@
+import { addArtifact, getLatestArtifact } from "../repository/runs.js";
+/**
+ * Human approved a plan whose triage questions are still open.
+ * Record the delegation so the executor sees the questions it must decide itself.
+ * Call BEFORE markPlanTriageConsumed — a consumed triage has nothing to delegate.
+ */
+export function recordPlanDelegation(runId) {
+    const triageArt = getLatestArtifact(runId, "plan_triage");
+    if (!triageArt?.contentJson)
+        return false;
+    let triage;
+    try {
+        triage = JSON.parse(triageArt.contentJson);
+    }
+    catch {
+        return false;
+    }
+    if (triage.consumed || triage.questions.length === 0)
+        return false;
+    // >= not >: createdAt has millisecond precision, and answers for this triage
+    // round can tie with it. Answers can never legitimately predate their triage.
+    const answers = getLatestArtifact(runId, "plan_answers");
+    if (answers && answers.createdAt >= triageArt.createdAt)
+        return false;
+    addArtifact(runId, "plan_answers", { answers: [], outcome: "delegated", answeredAt: new Date().toISOString() }, "human");
+    return true;
+}

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

@@ -0,0 +1,61 @@
+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-delegate-"));
+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, markPlanTriageConsumed } = await import("../repository/runs.js");
+const { recordPlanDelegation } = await import("./plan-delegation.js");
+const QUESTIONS = [{ id: "q1", question: "Which backend?", options: [{ label: "SQLite" }, { label: "Postgres" }] }];
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function seedRun(triage) {
+    const run = createRun({
+        title: "Delegate test",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    addArtifact(run.id, "draft_plan", { markdown: "# Plan" }, "agent");
+    if (triage)
+        addArtifact(run.id, "plan_triage", triage, "agent");
+    return run;
+}
+test("open questions produce a delegated plan_answers record", () => {
+    const run = seedRun({ verdict: "needs_review", rationale: "r", questions: QUESTIONS, parseFallback: false, consumed: false });
+    assert.equal(recordPlanDelegation(run.id), true);
+    const art = getLatestArtifact(run.id, "plan_answers");
+    const content = JSON.parse(art.contentJson);
+    assert.equal(content.outcome, "delegated");
+    assert.deepEqual(content.answers, []);
+    assert.equal(art.author, "human");
+});
+test("no triage means nothing to delegate", () => {
+    const run = seedRun();
+    assert.equal(recordPlanDelegation(run.id), false);
+    assert.equal(getLatestArtifact(run.id, "plan_answers"), null);
+});
+test("triage without questions means nothing to delegate", () => {
+    const run = seedRun({ verdict: "trivial", rationale: "r", questions: [], parseFallback: false, consumed: false });
+    assert.equal(recordPlanDelegation(run.id), false);
+});
+test("consumed triage means nothing to delegate", () => {
+    const run = seedRun({ verdict: "needs_review", rationale: "r", questions: QUESTIONS, parseFallback: false, consumed: false });
+    markPlanTriageConsumed(run.id);
+    assert.equal(recordPlanDelegation(run.id), false);
+});
+test("already-answered questions are not delegated", () => {
+    const run = seedRun({ verdict: "needs_review", rationale: "r", questions: QUESTIONS, parseFallback: false, consumed: false });
+    addArtifact(run.id, "plan_answers", {
+        answers: [{ questionId: "q1", selectedLabel: "SQLite" }],
+        outcome: "approved",
+        answeredAt: new Date().toISOString(),
+    }, "human");
+    assert.equal(recordPlanDelegation(run.id), false);
+});

package/bundle/server/dist/queue/result-qa.js

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { addArtifact, getRun } from "../repository/runs.js";
+import { hasPendingQaExchange, latestExecuteSessionId } from "../repository/result-qa.js";
+import { runQa } from "../runners/qa.js";
+const ASKABLE_STATUSES = new Set(["review", "done"]);
+const QA_RUNTIMES = new Set(["claude_code", "cursor_local"]);
+/** Ask the run's agent about its finished result. Read-only; never changes run status. */
+export function askResultQuestion(runId, question, opts) {
+    // An empty question would persist a result_qa artifact that ResultQaContent then
+    // refuses to parse — invisible in the thread, and hasPendingQaExchange would miss
+    // it, defeating the one-pending-question lock. Reject before spending anything.
+    const trimmed = question.trim();
+    if (!trimmed)
+        return { ok: false, code: 400, error: "Question cannot be empty" };
+    const run = getRun(runId);
+    if (!run)
+        return { ok: false, code: 404, error: "Not found" };
+    if (!ASKABLE_STATUSES.has(run.status)) {
+        return { ok: false, code: 409, error: `Can only ask about a finished result — run is ${run.status}` };
+    }
+    const runtime = run.runtime ?? "claude_code";
+    if (!QA_RUNTIMES.has(runtime)) {
+        return { ok: false, code: 409, error: `Q&A is unsupported for runtime ${runtime}` };
+    }
+    // The pending check and the insert below must stay in one synchronous block: every
+    // call here is sync (better-sqlite3), so no other request can interleave between them.
+    // Do not introduce an `await` before addArtifact — that would open a double-ask window.
+    if (hasPendingQaExchange(runId)) {
+        return { ok: false, code: 409, error: "A question is already being answered" };
+    }
+    const resumeSessionId = latestExecuteSessionId(runId);
+    const exchange = {
+        exchangeId: randomUUID(),
+        question: trimmed,
+        status: "pending",
+        sessionResumed: Boolean(resumeSessionId),
+        askedAt: new Date().toISOString(),
+    };
+    addArtifact(runId, "result_qa", exchange, "human");
+    void answerExchange(run, exchange, resumeSessionId, opts?.runner ?? runQa);
+    return { ok: true, exchange };
+}
+async function answerExchange(run, exchange, resumeSessionId, runner) {
+    let result;
+    try {
+        result = await runner(run, exchange.question, resumeSessionId);
+    }
+    catch (e) {
+        appendExchange(run.id, { ...exchange, status: "failed", error: String(e) });
+        return;
+    }
+    addArtifact(run.id, "usage", result.usage, "agent");
+    if (!result.ok) {
+        appendExchange(run.id, { ...exchange, status: "failed", error: result.error ?? "Q&A failed" });
+        return;
+    }
+    appendExchange(run.id, {
+        ...exchange,
+        status: "answered",
+        answer: result.answer,
+        answeredAt: new Date().toISOString(),
+    });
+}
+function appendExchange(runId, exchange) {
+    addArtifact(runId, "result_qa", exchange, "agent");
+}

package/bundle/server/dist/queue/result-qa.test.js

@@ -0,0 +1,146 @@
+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-qa-"));
+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 { listQaExchanges, hasPendingQaExchange } = await import("../repository/result-qa.js");
+const { askResultQuestion } = await import("./result-qa.js");
+const USAGE = { phase: "qa", runtime: "claude_code", totalCostUsd: 0.02 };
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function seedReviewRun(opts) {
+    const run = createRun({
+        title: "QA test",
+        taskCategory: "other",
+        status: "plan_approved",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    if (opts?.session) {
+        addArtifact(run.id, "agent_session", { phase: "execute", runtime: "claude_code", sessionId: opts.session }, "agent");
+    }
+    transitionRun(run.id, "running");
+    transitionRun(run.id, "review");
+    return getRun(run.id);
+}
+/** Resolves the async answer job before asserting. */
+async function settle() {
+    await new Promise((r) => setTimeout(r, 10));
+}
+test("asking persists a pending exchange, then an answered one with the same exchangeId", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    let sawSession = "unset";
+    const res = askResultQuestion(run.id, "Why SQLite?", {
+        runner: async (_run, _q, resumeSessionId) => {
+            sawSession = resumeSessionId;
+            return { ok: true, answer: "Single-process.", usage: USAGE };
+        },
+    });
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.exchange.status, "pending");
+    assert.equal(listQaExchanges(run.id)[0].status, "pending");
+    await settle();
+    assert.equal(sawSession, "sess-exec");
+    const thread = listQaExchanges(run.id);
+    assert.equal(thread.length, 1, "append-only exchanges collapse by exchangeId");
+    assert.equal(thread[0].status, "answered");
+    assert.equal(thread[0].answer, "Single-process.");
+    assert.equal(thread[0].sessionResumed, true);
+    assert.ok(thread[0].answeredAt);
+    assert.equal(getLatestArtifact(run.id, "usage").contentJson.includes('"phase":"qa"'), true);
+});
+test("missing execute session answers ungrounded and flags sessionResumed false", async () => {
+    const run = seedReviewRun();
+    askResultQuestion(run.id, "What did you check?", {
+        runner: async () => ({ ok: true, answer: "The tests.", usage: USAGE }),
+    });
+    await settle();
+    const thread = listQaExchanges(run.id);
+    assert.equal(thread[0].sessionResumed, false);
+    assert.equal(thread[0].status, "answered");
+});
+test("runner failure records a failed exchange and never changes run status", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    askResultQuestion(run.id, "Why?", {
+        runner: async () => ({ ok: false, answer: "", error: "qa exited 1", usage: USAGE }),
+    });
+    await settle();
+    const thread = listQaExchanges(run.id);
+    assert.equal(thread[0].status, "failed");
+    assert.equal(thread[0].error, "qa exited 1");
+    assert.equal(getRun(run.id).status, "review");
+});
+test("runner throwing records a failed exchange", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    askResultQuestion(run.id, "Why?", {
+        runner: async () => { throw new Error("spawn ENOENT"); },
+    });
+    await settle();
+    assert.match(listQaExchanges(run.id)[0].error, /spawn ENOENT/);
+});
+test("a second question while one is pending returns 409", () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    askResultQuestion(run.id, "First?", { runner: () => new Promise(() => { }) });
+    const second = askResultQuestion(run.id, "Second?", { runner: async () => ({ ok: true, answer: "x", usage: USAGE }) });
+    assert.equal(!second.ok && second.code, 409);
+});
+test("asking a done run is allowed", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    transitionRun(run.id, "done");
+    const res = askResultQuestion(run.id, "Post-hoc?", {
+        runner: async () => ({ ok: true, answer: "Sure.", usage: USAGE }),
+    });
+    assert.equal(res.ok, true);
+    await settle();
+    assert.equal(listQaExchanges(run.id)[0].status, "answered");
+});
+test("asking a running run returns 409", () => {
+    const run = createRun({
+        title: "Still running",
+        taskCategory: "other",
+        status: "plan_approved",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    transitionRun(run.id, "running");
+    const res = askResultQuestion(run.id, "Why?", { runner: async () => ({ ok: true, answer: "x", usage: USAGE }) });
+    assert.equal(!res.ok && res.code, 409);
+});
+test("whitespace-only question is rejected before spending anything", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    let runnerCalled = false;
+    const res = askResultQuestion(run.id, "   ", {
+        runner: async () => { runnerCalled = true; return { ok: true, answer: "x", usage: USAGE }; },
+    });
+    assert.equal(!res.ok && res.code, 400);
+    await settle();
+    assert.equal(runnerCalled, false, "no paid agent call");
+    assert.equal(listQaExchanges(run.id).length, 0, "no artifact persisted");
+    assert.equal(hasPendingQaExchange(run.id), false, "pending lock not corrupted");
+});
+test("a persisted exchange always round-trips through the content schema", async () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    askResultQuestion(run.id, "  Why SQLite?  ", {
+        runner: async () => ({ ok: true, answer: "Single-process.", usage: USAGE }),
+    });
+    await settle();
+    const thread = listQaExchanges(run.id);
+    assert.equal(thread.length, 1, "exchange is visible, i.e. it parsed");
+    assert.equal(thread[0].question, "Why SQLite?", "stored trimmed");
+});
+test("unknown run returns 404", () => {
+    const res = askResultQuestion("00000000-0000-4000-a000-0000000000ff", "Why?");
+    assert.equal(!res.ok && res.code, 404);
+});
+test("cursor runtime is allowed", () => {
+    const run = seedReviewRun({ session: "sess-exec" });
+    updateRunFields(run.id, { runtime: "cursor_local" });
+    const res = askResultQuestion(run.id, "Why?", { runner: async () => ({ ok: true, answer: "x", usage: USAGE }) });
+    assert.equal(res.ok, true);
+});