agent-dealer 0.1.3 → 0.1.4

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, resolveBudgetForPhase } 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, extractPlanTriage, 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,7 +44,11 @@ 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;
@@ -68,8 +72,9 @@ 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 rawPlan = extractPlanMarkdown(events);
@@ -85,6 +90,27 @@ export function persistRunOutput(input) {
     }
     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)) {

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) {
@@ -97,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) {
@@ -138,16 +155,28 @@ export function buildReflectPrompt(run, opts) {
     }
     return parts.join("\n");
 }
-function planTriageContractSection() {
-    return [
+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:",
-        '- "trivial" means this plan is safe to execute without human review; it requires an empty questions array. When in doubt, use "needs_review".',
-        "- Ask at most 3 questions, and only when the answer changes how you would execute. Never ask permission to proceed.",
-        "- Each question needs 2-4 concrete options; give each option a short description.",
-    ].join("\n");
+        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");
@@ -185,7 +214,7 @@ export function buildPlanRevisePrompt(run, questions, answers) {
         "## Answers",
         ...qa,
         "",
-        planTriageContractSection(),
+        planTriageContractSection(run.taskCategory),
     ].join("\n");
 }
 export function buildPlanPrompt(run) {
@@ -210,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.`, ``, planTriageContractSection());
+    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

@@ -35,6 +35,27 @@ test("plan prompt includes the triage contract", () => {
     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");
@@ -61,3 +82,11 @@ test("revise prompt pairs each answer with its question and re-states the contra
     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/stream-json.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { PlanTriageBlock } from "@agent-dealer/shared";
+import { OutboundDraftBlock, outboundMessageMatchesSummary, PlanTriageBlock } from "@agent-dealer/shared";
 export function parseNdjson(raw) {
     const events = [];
     for (const line of raw.split("\n")) {
@@ -90,6 +90,29 @@ export function extractPlanTriage(planMarkdown) {
         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

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { extractPlanTriage } from "./stream-json.js";
+import { extractPlanTriage, extractOutboundDraft } from "./stream-json.js";
 const PLAN = "# Plan\n1. Do the thing\n2. Verify";
 const VALID_BLOCK = [
     "```json",
@@ -55,3 +55,41 @@ test("valid json block that is not a triage shape falls back and strips the fenc
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "0.1.3",
+  "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"