agent-dealer 0.1.2 → 0.1.4

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

@@ -30,6 +30,21 @@ function artifactMarkdown(kind, runId) {
         return "";
     }
 }
+function outboundDraftContractSection() {
+    return [
+        "## Outbound actions (required when sending Slack or email)",
+        "Do NOT send Slack messages, post to chat, or send email during execution — call_service_tool is blocked.",
+        "If the task requires an outward-facing message, end your reply with exactly one fenced ```json block shaped like:",
+        '{"actionType":"slack_message"|"email","summary":{"target":"#channel or recipient","body":"exact message text"},"toolCall":{"serviceName":"<deck service UUID>","toolName":"<tool from list_service_tools>","arguments":{...}}}',
+        "Rules:",
+        "- At most one outbound draft block per run.",
+        "- Call bind_workspace, then get_bound_deck and list_service_tools — never invent a service UUID or tool name.",
+        "- toolCall.serviceName must be the exact Slack/email service id from the bound deck (not a display name).",
+        "- Slack: toolName is slack_send_message; arguments.channel_id is the user or channel id from slack_search_users (never guess IDs from meeting notes); arguments.message must byte-match summary.body.",
+        "- Email: use the real tool name and message field from list_service_tools; message body must byte-match summary.body.",
+        "- Do not perform the send — the human approves and the server delivers verbatim.",
+    ].join("\n");
+}
 export function buildExecutionContinuationPrompt(run) {
     const ctx = retryContext(run);
     const parts = [
@@ -55,6 +70,7 @@ export function buildExecutionContinuationPrompt(run) {
             parts.push(`Then get_playbook("${run.playbookId}") and follow it.`);
         }
     }
+    parts.push(outboundDraftContractSection());
     return parts.join("\n");
 }
 export function buildExecutionPrompt(run) {
@@ -87,6 +103,7 @@ export function buildExecutionPrompt(run) {
             parts.push(`## Human feedback`, feedback, ``);
         }
     }
+    parts.push(...planAnswersSections(run));
     if (run.taskCategory === "content" || run.taskCategory === "research") {
         parts.push(`## Deliverable`, documentOutputHint(run), `You MUST write the file using your Write/edit tool — do not only print markdown in chat.`, ``);
     }
@@ -96,6 +113,7 @@ export function buildExecutionPrompt(run) {
             parts.push(`Then get_playbook("${run.playbookId}") and follow it.`);
         }
     }
+    parts.push(outboundDraftContractSection());
     return parts.join("\n");
 }
 export function buildReflectPrompt(run, opts) {
@@ -137,6 +155,68 @@ export function buildReflectPrompt(run, opts) {
     }
     return parts.join("\n");
 }
+function hasOutboundSendGate(category) {
+    return category === "communication" || category === "email";
+}
+function planTriageContractSection(taskCategory = "other") {
+    const sendGate = hasOutboundSendGate(taskCategory);
+    const rules = [
+        "## Required final JSON block",
+        "After the plan markdown, end your reply with exactly one fenced ```json block shaped like:",
+        '{"verdict":"trivial"|"needs_review","rationale":"one sentence","questions":[{"id":"q1","question":"...","options":[{"label":"...","description":"..."}]}]}',
+        "Rules:",
+        sendGate
+            ? '- "trivial" means safe to execute without human plan review; it requires an empty questions array. Use "trivial" when the task names recipient and message (or execution steps are obvious). The send gate reviews the exact payload before anything is sent.'
+            : '- "trivial" means this plan is safe to execute without human review; it requires an empty questions array. When in doubt, use "needs_review".',
+    ];
+    if (sendGate) {
+        rules.push("- Do not ask plan questions about recipient, channel, or message wording — those are confirmed when the human approves the outbound draft.", "- Ask at most 3 questions, and only when a missing decision would change how you execute (not send approval). Never ask permission to proceed.");
+    }
+    else {
+        rules.push("- Ask at most 3 questions, and only when the answer changes how you would execute. Never ask permission to proceed.");
+    }
+    rules.push("- Each question needs 2-4 concrete options; give each option a short description.");
+    return rules.join("\n");
+}
+function planAnswersSections(run) {
+    const ansArt = getLatestArtifact(run.id, "plan_answers");
+    if (!ansArt?.contentJson)
+        return [];
+    try {
+        const ans = JSON.parse(ansArt.contentJson);
+        if (ans.outcome !== "approved" || ans.answers.length === 0)
+            return [];
+        const triArt = getLatestArtifact(run.id, "plan_triage");
+        const questions = triArt?.contentJson
+            ? JSON.parse(triArt.contentJson).questions
+            : [];
+        const lines = ans.answers.map((a) => {
+            const q = questions.find((x) => x.id === a.questionId);
+            return `- ${q?.question ?? a.questionId}: **${a.selectedLabel ?? a.freeText ?? ""}**`;
+        });
+        return ["## Human answers to plan questions", ...lines, ""];
+    }
+    catch {
+        return [];
+    }
+}
+export function buildPlanRevisePrompt(run, questions, answers) {
+    const qa = answers.map((a) => {
+        const q = questions.find((x) => x.id === a.questionId);
+        return `- Q: ${q?.question ?? a.questionId}\n  A: ${a.selectedLabel ?? a.freeText ?? ""}`;
+    });
+    return [
+        "The human answered your plan questions. Revise the plan accordingly — do not execute anything.",
+        "",
+        "## Task",
+        taskText(run),
+        "",
+        "## Answers",
+        ...qa,
+        "",
+        planTriageContractSection(run.taskCategory),
+    ].join("\n");
+}
 export function buildPlanPrompt(run) {
     const parts = [
         `Draft a concise execution plan (markdown) for this task.`,
@@ -159,6 +239,12 @@ export function buildPlanPrompt(run) {
     if (run.taskCategory === "content" || run.taskCategory === "research") {
         parts.push(`## Deliverable (execution phase only)`, `After approval, execution will produce a markdown document. Plan the steps; do not create the file now.`, ``);
     }
-    parts.push(`Output a step-by-step plan with risks. End with the plan markdown only.`);
+    if (hasOutboundSendGate(run.taskCategory)) {
+        parts.push(`## Outbound send gate`, `Execution drafts the Slack/email payload; the human approves the exact message before send.`, `If the task text names who to message and what to say (or the intent is obvious), plan for verdict "trivial" with no questions.`, ``);
+        parts.push(`Output a brief bullet plan (3–5 steps). Skip a risks section unless execution is blocked.`, ``, planTriageContractSection(run.taskCategory));
+    }
+    else {
+        parts.push(`Output a step-by-step plan with risks.`, ``, planTriageContractSection(run.taskCategory));
+    }
     return parts.join("\n");
 }

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

@@ -0,0 +1,92 @@
+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-prompts-"));
+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 } = await import("../repository/runs.js");
+const { buildExecutionPrompt, buildPlanPrompt, buildPlanRevisePrompt } = await import("./prompts.js");
+const QUESTIONS = [
+    {
+        id: "q1",
+        question: "Which storage backend?",
+        options: [{ label: "SQLite" }, { label: "Postgres" }],
+    },
+];
+before(() => {
+    migrate();
+    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
+});
+function makeRun() {
+    return createRun({
+        title: "Prompt test task",
+        taskCategory: "other",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+}
+test("plan prompt includes the triage contract", () => {
+    const prompt = buildPlanPrompt(makeRun());
+    assert.match(prompt, /"verdict"/);
+    assert.match(prompt, /needs_review/);
+    assert.match(prompt, /at most 3 questions/i);
+});
+test("communication plan prompt favors trivial triage and defers send details to send gate", () => {
+    const run = createRun({
+        title: "Send a test message to Yusuke",
+        description: "Say hello from agent-dealer",
+        taskCategory: "communication",
+        status: "plan_pending",
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+    });
+    const prompt = buildPlanPrompt(run);
+    assert.match(prompt, /Outbound send gate/);
+    assert.match(prompt, /send gate reviews the exact payload/i);
+    assert.match(prompt, /Do not ask plan questions about recipient/i);
+    assert.doesNotMatch(prompt, /When in doubt, use "needs_review"/);
+    assert.match(prompt, /brief bullet plan/i);
+    assert.doesNotMatch(prompt, /step-by-step plan with risks/);
+});
+test("other category plan prompt keeps conservative when-in-doubt rule", () => {
+    const prompt = buildPlanPrompt(makeRun());
+    assert.match(prompt, /When in doubt, use "needs_review"/);
+    assert.match(prompt, /step-by-step plan with risks/);
+});
+test("execution prompt renders human answers as Q→A pairs", () => {
+    const run = makeRun();
+    addArtifact(run.id, "draft_plan", { markdown: "# Plan" }, "agent");
+    addArtifact(run.id, "plan_triage", { verdict: "needs_review", rationale: "r", questions: QUESTIONS, parseFallback: false, consumed: false }, "agent");
+    addArtifact(run.id, "approved_plan", { markdown: "# Plan" }, "human");
+    addArtifact(run.id, "plan_answers", {
+        answers: [{ questionId: "q1", selectedLabel: "SQLite" }],
+        outcome: "approved",
+        answeredAt: new Date().toISOString(),
+    }, "human");
+    const prompt = buildExecutionPrompt(run);
+    assert.match(prompt, /## Human answers to plan questions/);
+    assert.match(prompt, /Which storage backend\?.*SQLite/s);
+});
+test("execution prompt omits answers section when none exist", () => {
+    const run = makeRun();
+    addArtifact(run.id, "approved_plan", { markdown: "# Plan" }, "human");
+    assert.doesNotMatch(buildExecutionPrompt(run), /Human answers to plan questions/);
+});
+test("revise prompt pairs each answer with its question and re-states the contract", () => {
+    const run = makeRun();
+    const prompt = buildPlanRevisePrompt(run, QUESTIONS, [{ questionId: "q1", freeText: "Use flat files instead" }]);
+    assert.match(prompt, /Which storage backend\?/);
+    assert.match(prompt, /Use flat files instead/);
+    assert.match(prompt, /"verdict"/);
+});
+test("execution prompt includes outbound draft contract", () => {
+    const run = makeRun();
+    addArtifact(run.id, "approved_plan", { markdown: "# Plan" }, "human");
+    const prompt = buildExecutionPrompt(run);
+    assert.match(prompt, /Outbound actions/);
+    assert.match(prompt, /call_service_tool is blocked/);
+    assert.match(prompt, /"actionType"/);
+});

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

@@ -31,7 +31,7 @@ export async function runReflect(run, opts) {
     try {
         const playbook = await fetchPlaybook(run.playbookId);
         const previousBody = playbook.body ?? "";
-        const result = await runClaude(run, "reflect", undefined, buildReflectPrompt(run, opts));
+        const result = await runClaude(run, "reflect", undefined, { promptOverride: buildReflectPrompt(run, opts) });
         const events = parseNdjson(result.transcript);
         const resultText = extractResultText(events) ?? result.transcript;
         const proposal = parseReflectProposal(resultText);

package/bundle/server/dist/runners/stream-json.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { OutboundDraftBlock, outboundMessageMatchesSummary, PlanTriageBlock } from "@agent-dealer/shared";
 export function parseNdjson(raw) {
     const events = [];
     for (const line of raw.split("\n")) {
@@ -62,6 +63,56 @@ export function extractPlanMarkdown(events) {
     const raw = extractResultText(events) ?? "";
     return stripMarkdownFences(raw);
 }
+const TRIAGE_FALLBACK = {
+    verdict: "needs_review",
+    rationale: "Agent did not return a valid triage block",
+    questions: [],
+    parseFallback: true,
+};
+/** Parse the trailing fenced json triage block from plan markdown (PRD F1.2). */
+export function extractPlanTriage(planMarkdown) {
+    const blocks = [...planMarkdown.matchAll(/```json\s*\n([\s\S]*?)\n```/g)];
+    const last = blocks[blocks.length - 1];
+    if (!last)
+        return { markdown: planMarkdown.trim(), ...TRIAGE_FALLBACK };
+    const strippedMarkdown = (planMarkdown.slice(0, last.index) + planMarkdown.slice(last.index + last[0].length)).trim();
+    try {
+        const parsed = PlanTriageBlock.parse(JSON.parse(last[1]));
+        return {
+            markdown: strippedMarkdown,
+            verdict: parsed.verdict,
+            rationale: parsed.rationale,
+            questions: parsed.questions,
+            parseFallback: false,
+        };
+    }
+    catch {
+        return { markdown: strippedMarkdown, ...TRIAGE_FALLBACK };
+    }
+}
+/** Parse the trailing fenced json outbound draft block from execute result (PRD F2.2). */
+export function extractOutboundDraft(resultMarkdown) {
+    const blocks = [...resultMarkdown.matchAll(/```json\s*\n([\s\S]*?)\n```/g)];
+    const last = blocks[blocks.length - 1];
+    if (!last) {
+        return { markdown: resultMarkdown.trim(), hadJsonBlock: false, invalid: false, mismatch: false };
+    }
+    const strippedMarkdown = (resultMarkdown.slice(0, last.index) + resultMarkdown.slice(last.index + last[0].length)).trim();
+    try {
+        const parsed = OutboundDraftBlock.parse(JSON.parse(last[1]));
+        const mismatch = !outboundMessageMatchesSummary(parsed.toolCall, parsed.summary.body);
+        return {
+            markdown: strippedMarkdown,
+            draft: parsed,
+            hadJsonBlock: true,
+            invalid: false,
+            mismatch,
+        };
+    }
+    catch {
+        return { markdown: strippedMarkdown, hadJsonBlock: true, invalid: true, mismatch: false };
+    }
+}
 export function extractUsage(events, phase, runtime) {
     const result = events.find((e) => e.type === "result");
     const init = events.find((e) => e.type === "system");

package/bundle/server/dist/runners/stream-json.test.js

@@ -0,0 +1,95 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { extractPlanTriage, extractOutboundDraft } from "./stream-json.js";
+const PLAN = "# Plan\n1. Do the thing\n2. Verify";
+const VALID_BLOCK = [
+    "```json",
+    JSON.stringify({
+        verdict: "needs_review",
+        rationale: "Two viable approaches",
+        questions: [
+            {
+                id: "q1",
+                question: "Which approach?",
+                options: [{ label: "A" }, { label: "B", description: "slower but safer" }],
+            },
+        ],
+    }),
+    "```",
+].join("\n");
+test("parses trailing triage block and strips it from the markdown", () => {
+    const r = extractPlanTriage(`${PLAN}\n\n${VALID_BLOCK}`);
+    assert.equal(r.parseFallback, false);
+    assert.equal(r.verdict, "needs_review");
+    assert.equal(r.questions.length, 1);
+    assert.equal(r.markdown, PLAN);
+});
+test("trivial block with no questions parses", () => {
+    const block = '```json\n{"verdict":"trivial","rationale":"one-line change"}\n```';
+    const r = extractPlanTriage(`${PLAN}\n\n${block}`);
+    assert.equal(r.verdict, "trivial");
+    assert.equal(r.parseFallback, false);
+    assert.deepEqual(r.questions, []);
+});
+test("missing block falls back to needs_review with full markdown kept", () => {
+    const r = extractPlanTriage(PLAN);
+    assert.equal(r.parseFallback, true);
+    assert.equal(r.verdict, "needs_review");
+    assert.equal(r.markdown, PLAN);
+});
+test("malformed JSON falls back and strips the fence", () => {
+    const r = extractPlanTriage(`${PLAN}\n\n\`\`\`json\n{not json}\n\`\`\``);
+    assert.equal(r.parseFallback, true);
+    assert.equal(r.markdown, PLAN);
+    assert.equal(r.markdown.includes("```json"), false);
+});
+test("last json block wins; earlier json-in-prose is ignored", () => {
+    const early = '```json\n{"some":"config"}\n```';
+    const r = extractPlanTriage(`${PLAN}\n\n${early}\n\nMore prose\n\n${VALID_BLOCK}`);
+    assert.equal(r.parseFallback, false);
+    assert.equal(r.markdown.includes('{"some":"config"}'), true);
+    assert.equal(r.markdown.includes('"verdict"'), false);
+});
+test("valid json block that is not a triage shape falls back and strips the fence", () => {
+    const r = extractPlanTriage(`${PLAN}\n\n\`\`\`json\n{"foo":"bar"}\n\`\`\``);
+    assert.equal(r.parseFallback, true);
+    assert.equal(r.markdown, PLAN);
+});
+const VALID_DRAFT = {
+    actionType: "slack_message",
+    summary: { target: "#test", body: "Hello" },
+    toolCall: {
+        serviceName: "svc-1",
+        toolName: "chat_postMessage",
+        arguments: { channel: "C1", text: "Hello" },
+    },
+};
+const DRAFT_BLOCK = [
+    "```json",
+    JSON.stringify(VALID_DRAFT),
+    "```",
+].join("\n");
+test("extractOutboundDraft parses valid block and strips markdown", () => {
+    const r = extractOutboundDraft(`Done.\n\n${DRAFT_BLOCK}`);
+    assert.equal(r.invalid, false);
+    assert.equal(r.draft?.actionType, "slack_message");
+    assert.equal(r.markdown, "Done.");
+});
+test("extractOutboundDraft absent block leaves markdown", () => {
+    const r = extractOutboundDraft("plain result");
+    assert.equal(r.hadJsonBlock, false);
+    assert.equal(r.markdown, "plain result");
+});
+test("extractOutboundDraft malformed json marks invalid", () => {
+    const r = extractOutboundDraft(`x\n\n\`\`\`json\n{bad}\n\`\`\``);
+    assert.equal(r.invalid, true);
+});
+test("extractOutboundDraft detects body mismatch", () => {
+    const bad = {
+        ...VALID_DRAFT,
+        toolCall: { ...VALID_DRAFT.toolCall, arguments: { channel: "C1", text: "Other" } },
+    };
+    const r = extractOutboundDraft(`\`\`\`json\n${JSON.stringify(bad)}\n\`\`\``);
+    assert.equal(r.mismatch, true);
+    assert.ok(r.draft);
+});

package/bundle/server/dist/usage-summary.js

@@ -1,5 +1,5 @@
 import { UsageContent as UsageContentSchema } from "@agent-dealer/shared";
-import { listArtifacts, listLineageRuns } from "./repository/runs.js";
+import { listArtifacts, listLineageRuns, resolveBudgetForPhase } from "./repository/runs.js";
 function parseUsage(contentJson) {
     try {
         return UsageContentSchema.parse(JSON.parse(contentJson));
@@ -17,13 +17,14 @@ function labelUsage(lineageIdx, phase, planCount, execCount) {
     }
     return lineageIdx === 1 ? "retry" : `retry ${lineageIdx}`;
 }
-export function buildLineageUsageSummary(run) {
+export function buildLineageUsageSummary(run, opts) {
     const lineageRuns = listLineageRuns(run);
     const lines = [];
     lineageRuns.forEach((lr, lineageIdx) => {
         let planCount = 0;
         let execCount = 0;
-        for (const art of listArtifacts(lr.id)) {
+        const arts = opts?.artifactsByRunId?.[lr.id] ?? listArtifacts(lr.id);
+        for (const art of arts) {
             if (art.kind !== "usage" || !art.contentJson)
                 continue;
             const usage = parseUsage(art.contentJson);
@@ -33,9 +34,12 @@ export function buildLineageUsageSummary(run) {
                 planCount++;
             else
                 execCount++;
+            const resolved = resolveBudgetForPhase(lr, usage.phase);
             lines.push({
                 label: labelUsage(lineageIdx, usage.phase, planCount, execCount),
                 usage,
+                maxTurns: usage.maxTurns ?? resolved?.maxTurns,
+                maxBudgetUsd: usage.maxBudgetUsd ?? resolved?.maxBudgetUsd,
             });
         }
     });
@@ -44,6 +48,7 @@ export function buildLineageUsageSummary(run) {
         inputTokens: acc.inputTokens + (usage.inputTokens ?? 0),
         outputTokens: acc.outputTokens + (usage.outputTokens ?? 0),
         durationMs: acc.durationMs + (usage.durationMs ?? 0),
-    }), { totalCostUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0 });
+        numTurns: acc.numTurns + (usage.numTurns ?? 0),
+    }), { totalCostUsd: 0, inputTokens: 0, outputTokens: 0, durationMs: 0, numTurns: 0 });
     return { lines, total };
 }

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -24,7 +24,8 @@
     "@agent-dealer/shared": "*",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
-    "better-sqlite3": "^11.9.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "better-sqlite3": "^12.11.1",
     "dotenv": "^16.5.0",
     "fastify": "^5.3.3",
     "uuid": "^11.1.0"