agent-dealer 0.1.2 → 0.1.3

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

@@ -87,6 +87,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.`, ``);
     }
@@ -137,6 +138,56 @@ export function buildReflectPrompt(run, opts) {
     }
     return parts.join("\n");
 }
+function planTriageContractSection() {
+    return [
+        "## 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");
+}
+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(),
+    ].join("\n");
+}
 export function buildPlanPrompt(run) {
     const parts = [
         `Draft a concise execution plan (markdown) for this task.`,
@@ -159,6 +210,6 @@ 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.`);
+    parts.push(`Output a step-by-step plan with risks.`, ``, planTriageContractSection());
     return parts.join("\n");
 }

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

@@ -0,0 +1,63 @@
+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("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"/);
+});

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 { PlanTriageBlock } from "@agent-dealer/shared";
 export function parseNdjson(raw) {
     const events = [];
     for (const line of raw.split("\n")) {
@@ -62,6 +63,33 @@ 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 };
+    }
+}
 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,57 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { extractPlanTriage } 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);
+});

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.3",
   "type": "module",
   "main": "dist/index.js",
   "files": [