agent-dealer 0.1.2 → 0.1.4

package/bundle/shared/dist/index.js

@@ -6,6 +6,8 @@ export * from "./runtime.js";
 export * from "./agents.js";
 export * from "./budget.js";
 export * from "./execution.js";
+export * from "./plan-triage.js";
+export * from "./outbound-draft.js";
 export const RunStatus = z.enum([
     "queued",
     "plan_pending",
@@ -28,6 +30,8 @@ export const ArtifactKind = z.enum([
     "task_snapshot",
     "draft_plan",
     "approved_plan",
+    "plan_triage",
+    "plan_answers",
     "acceptance_criteria",
     "transcript",
     "stream_trace",
@@ -45,6 +49,7 @@ export const ArtifactKind = z.enum([
     "playbook_patch",
     "reflect_status",
     "linear_sync",
+    "send_receipt",
 ]);
 export const RunPhase = z.enum(["plan", "execute", "reflect"]);
 export const PlaybookPatchStatus = z.enum(["proposed", "applied", "dismissed"]);
@@ -86,10 +91,17 @@ export const UsageContent = z.object({
     durationMs: z.number().optional(),
     model: z.string().optional(),
     numTurns: z.number().optional(),
+    /** Resolved --max-turns cap enforced when this phase ran (snapshot at persist time). */
+    maxTurns: z.number().optional(),
+    /** Resolved --max-budget-usd cap enforced when this phase ran (snapshot at persist time). */
+    maxBudgetUsd: z.number().optional(),
 });
 export const UsageLineItem = z.object({
     label: z.string(),
     usage: UsageContent,
+    /** From usage artifact snapshot; falls back to current resolve for legacy rows. */
+    maxTurns: z.number().optional(),
+    maxBudgetUsd: z.number().optional(),
 });
 export const UsageSummary = z.object({
     lines: z.array(UsageLineItem),
@@ -98,6 +110,7 @@ export const UsageSummary = z.object({
         inputTokens: z.number(),
         outputTokens: z.number(),
         durationMs: z.number(),
+        numTurns: z.number(),
     }),
 });
 export const AgentSessionContent = z.object({
@@ -216,6 +229,7 @@ export const RetryRunInput = z.object({
     /** @deprecated execution retry uses executeModel */
     planModel: z.string().nullable().optional(),
     executeModel: z.string().nullable().optional(),
+    executeBudget: PhaseBudget.nullable().optional(),
 });
 export const LinearCandidate = z.object({
     id: z.string(),
@@ -313,6 +327,11 @@ export const QueueSnapshot = z.object({
     resultReviewRuns: z.array(Run),
     recentDone: z.array(Run),
     awaitingPlanReview: z.array(Run),
+    awaitingAnswerRuns: z.array(Run),
+    openQuestionCounts: z.record(z.string(), z.number()),
+    pendingSendCounts: z.record(z.string(), z.number()),
+    sentRunIds: z.array(z.string()).optional(),
+    autoApprovedRunIds: z.array(z.string()),
     runs: z.array(Run),
     agentDeckOnline: z.boolean(),
     agents: z.array(AgentWithHealth),

package/bundle/shared/dist/outbound-draft.d.ts

@@ -0,0 +1,192 @@
+import { z } from "zod";
+export declare const OutboundActionType: z.ZodEnum<["slack_message", "email"]>;
+export type OutboundActionType = z.infer<typeof OutboundActionType>;
+export declare const OutboundDraftSummary: z.ZodObject<{
+    target: z.ZodString;
+    body: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    body: string;
+}, {
+    target: string;
+    body: string;
+}>;
+export type OutboundDraftSummary = z.infer<typeof OutboundDraftSummary>;
+export declare const OutboundToolCall: z.ZodObject<{
+    serviceName: z.ZodString;
+    toolName: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    serviceName: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+}, {
+    serviceName: string;
+    toolName: string;
+    arguments: Record<string, unknown>;
+}>;
+export type OutboundToolCall = z.infer<typeof OutboundToolCall>;
+/** Agent output contract — final fenced json block of an execute reply (PRD §7.1). */
+export declare const OutboundDraftBlock: z.ZodObject<{
+    actionType: z.ZodEnum<["slack_message", "email"]>;
+    summary: z.ZodObject<{
+        target: z.ZodString;
+        body: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        target: string;
+        body: string;
+    }, {
+        target: string;
+        body: string;
+    }>;
+    toolCall: z.ZodObject<{
+        serviceName: z.ZodString;
+        toolName: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        serviceName: string;
+        toolName: string;
+        arguments: Record<string, unknown>;
+    }, {
+        serviceName: string;
+        toolName: string;
+        arguments: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    summary: {
+        target: string;
+        body: string;
+    };
+    actionType: "slack_message" | "email";
+    toolCall: {
+        serviceName: string;
+        toolName: string;
+        arguments: Record<string, unknown>;
+    };
+}, {
+    summary: {
+        target: string;
+        body: string;
+    };
+    actionType: "slack_message" | "email";
+    toolCall: {
+        serviceName: string;
+        toolName: string;
+        arguments: Record<string, unknown>;
+    };
+}>;
+export type OutboundDraftBlock = z.infer<typeof OutboundDraftBlock>;
+export declare const OutboundDraftStatus: z.ZodEnum<["pending", "sent", "rejected"]>;
+export type OutboundDraftStatus = z.infer<typeof OutboundDraftStatus>;
+/** slack_draft / email_draft artifact contentJson (PRD §7.2). */
+export declare const OutboundDraftContent: z.ZodObject<{
+    draft: z.ZodObject<{
+        actionType: z.ZodEnum<["slack_message", "email"]>;
+        summary: z.ZodObject<{
+            target: z.ZodString;
+            body: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            target: string;
+            body: string;
+        }, {
+            target: string;
+            body: string;
+        }>;
+        toolCall: z.ZodObject<{
+            serviceName: z.ZodString;
+            toolName: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        }, {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        summary: {
+            target: string;
+            body: string;
+        };
+        actionType: "slack_message" | "email";
+        toolCall: {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        };
+    }, {
+        summary: {
+            target: string;
+            body: string;
+        };
+        actionType: "slack_message" | "email";
+        toolCall: {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        };
+    }>;
+    status: z.ZodEnum<["pending", "sent", "rejected"]>;
+    sentAt: z.ZodOptional<z.ZodString>;
+    rejectedAt: z.ZodOptional<z.ZodString>;
+    bodyMismatch: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "sent" | "rejected";
+    draft: {
+        summary: {
+            target: string;
+            body: string;
+        };
+        actionType: "slack_message" | "email";
+        toolCall: {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        };
+    };
+    sentAt?: string | undefined;
+    rejectedAt?: string | undefined;
+    bodyMismatch?: boolean | undefined;
+}, {
+    status: "pending" | "sent" | "rejected";
+    draft: {
+        summary: {
+            target: string;
+            body: string;
+        };
+        actionType: "slack_message" | "email";
+        toolCall: {
+            serviceName: string;
+            toolName: string;
+            arguments: Record<string, unknown>;
+        };
+    };
+    sentAt?: string | undefined;
+    rejectedAt?: string | undefined;
+    bodyMismatch?: boolean | undefined;
+}>;
+export type OutboundDraftContent = z.infer<typeof OutboundDraftContent>;
+/** send_receipt artifact contentJson (PRD §7.3). */
+export declare const SendReceiptContent: z.ZodObject<{
+    draftArtifactId: z.ZodString;
+    sentAt: z.ZodString;
+    toolResult: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    permalink: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sentAt: string;
+    draftArtifactId: string;
+    toolResult: Record<string, unknown>;
+    permalink?: string | undefined;
+}, {
+    sentAt: string;
+    draftArtifactId: string;
+    toolResult: Record<string, unknown>;
+    permalink?: string | undefined;
+}>;
+export type SendReceiptContent = z.infer<typeof SendReceiptContent>;
+export declare function outboundDraftKind(actionType: OutboundActionType): "slack_draft" | "email_draft";
+export declare function isOutboundDraftKind(kind: string): kind is "slack_draft" | "email_draft";
+/** Compare summary.body to the message field in toolCall.arguments (Slack: text, email: body). */
+export declare function outboundMessageMatchesSummary(toolCall: OutboundToolCall, body: string): boolean;

package/bundle/shared/dist/outbound-draft.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+export const OutboundActionType = z.enum(["slack_message", "email"]);
+export const OutboundDraftSummary = z.object({
+    target: z.string().min(1).max(120),
+    body: z.string().min(1).max(4000),
+});
+export const OutboundToolCall = z.object({
+    serviceName: z.string().min(1).max(120),
+    toolName: z.string().min(1).max(120),
+    arguments: z.record(z.unknown()),
+});
+/** Agent output contract — final fenced json block of an execute reply (PRD §7.1). */
+export const OutboundDraftBlock = z.object({
+    actionType: OutboundActionType,
+    summary: OutboundDraftSummary,
+    toolCall: OutboundToolCall,
+});
+export const OutboundDraftStatus = z.enum(["pending", "sent", "rejected"]);
+/** slack_draft / email_draft artifact contentJson (PRD §7.2). */
+export const OutboundDraftContent = z.object({
+    draft: OutboundDraftBlock,
+    status: OutboundDraftStatus,
+    sentAt: z.string().optional(),
+    rejectedAt: z.string().optional(),
+    bodyMismatch: z.boolean().optional(),
+});
+/** send_receipt artifact contentJson (PRD §7.3). */
+export const SendReceiptContent = z.object({
+    draftArtifactId: z.string().uuid(),
+    sentAt: z.string(),
+    toolResult: z.record(z.unknown()),
+    permalink: z.string().url().optional(),
+});
+export function outboundDraftKind(actionType) {
+    return actionType === "slack_message" ? "slack_draft" : "email_draft";
+}
+const OUTBOUND_DRAFT_KINDS = new Set(["slack_draft", "email_draft"]);
+export function isOutboundDraftKind(kind) {
+    return OUTBOUND_DRAFT_KINDS.has(kind);
+}
+/** Compare summary.body to the message field in toolCall.arguments (Slack: text, email: body). */
+export function outboundMessageMatchesSummary(toolCall, body) {
+    const args = toolCall.arguments;
+    const candidates = [args.text, args.body, args.message].filter((v) => typeof v === "string");
+    return candidates.some((v) => v === body);
+}

package/bundle/shared/dist/outbound-draft.test.d.ts

@@ -0,0 +1 @@
+export {};

package/bundle/shared/dist/outbound-draft.test.js

@@ -0,0 +1,34 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { OutboundDraftBlock, outboundDraftKind, outboundMessageMatchesSummary, SendReceiptContent, } from "./outbound-draft.js";
+const VALID_DRAFT = {
+    actionType: "slack_message",
+    summary: { target: "#test-channel", body: "Hello from agent-dealer" },
+    toolCall: {
+        serviceName: "34eb6c24-f151-4da2-8db8-d6996aa296be",
+        toolName: "chat_postMessage",
+        arguments: { channel: "C123", text: "Hello from agent-dealer" },
+    },
+};
+test("OutboundDraftBlock parses valid slack draft", () => {
+    const parsed = OutboundDraftBlock.parse(VALID_DRAFT);
+    assert.equal(parsed.actionType, "slack_message");
+});
+test("outboundDraftKind maps action types", () => {
+    assert.equal(outboundDraftKind("slack_message"), "slack_draft");
+    assert.equal(outboundDraftKind("email"), "email_draft");
+});
+test("outboundMessageMatchesSummary matches text field", () => {
+    assert.equal(outboundMessageMatchesSummary(VALID_DRAFT.toolCall, VALID_DRAFT.summary.body), true);
+});
+test("outboundMessageMatchesSummary detects mismatch", () => {
+    assert.equal(outboundMessageMatchesSummary(VALID_DRAFT.toolCall, "different body"), false);
+});
+test("SendReceiptContent requires draftArtifactId and toolResult", () => {
+    const receipt = SendReceiptContent.parse({
+        draftArtifactId: "00000000-0000-4000-a000-000000000001",
+        sentAt: new Date().toISOString(),
+        toolResult: { ok: true },
+    });
+    assert.equal(receipt.toolResult.ok, true);
+});

package/bundle/shared/dist/plan-triage.d.ts

@@ -0,0 +1,317 @@
+import { z } from "zod";
+export declare const PlanQuestionOption: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    description?: string | undefined;
+}, {
+    label: string;
+    description?: string | undefined;
+}>;
+export type PlanQuestionOption = z.infer<typeof PlanQuestionOption>;
+export declare const PlanQuestion: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        description?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        label: string;
+        description?: string | undefined;
+    }[];
+    id: string;
+    question: string;
+}, {
+    options: {
+        label: string;
+        description?: string | undefined;
+    }[];
+    id: string;
+    question: string;
+}>;
+export type PlanQuestion = z.infer<typeof PlanQuestion>;
+export declare const PlanTriageVerdict: z.ZodEnum<["trivial", "needs_review"]>;
+export type PlanTriageVerdict = z.infer<typeof PlanTriageVerdict>;
+/** Agent output contract — final fenced json block of a plan reply (PRD §7.1). */
+export declare const PlanTriageBlock: z.ZodEffects<z.ZodObject<{
+    verdict: z.ZodEnum<["trivial", "needs_review"]>;
+    rationale: z.ZodString;
+    questions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description?: string | undefined;
+        }, {
+            label: string;
+            description?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }, {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[];
+}, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions?: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[] | undefined;
+}>, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[];
+}, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions?: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[] | undefined;
+}>;
+export type PlanTriageBlock = z.infer<typeof PlanTriageBlock>;
+/** plan_triage artifact contentJson (PRD §7.3). */
+export declare const PlanTriageContent: z.ZodObject<{
+    verdict: z.ZodEnum<["trivial", "needs_review"]>;
+    rationale: z.ZodString;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            description?: string | undefined;
+        }, {
+            label: string;
+            description?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }, {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }>, "many">;
+    sessionId: z.ZodOptional<z.ZodString>;
+    parseFallback: z.ZodBoolean;
+    consumed: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[];
+    parseFallback: boolean;
+    consumed: boolean;
+    sessionId?: string | undefined;
+}, {
+    verdict: "trivial" | "needs_review";
+    rationale: string;
+    questions: {
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        id: string;
+        question: string;
+    }[];
+    parseFallback: boolean;
+    sessionId?: string | undefined;
+    consumed?: boolean | undefined;
+}>;
+export type PlanTriageContent = z.infer<typeof PlanTriageContent>;
+export declare const PlanAnswer: z.ZodEffects<z.ZodObject<{
+    questionId: z.ZodString;
+    selectedLabel: z.ZodOptional<z.ZodString>;
+    freeText: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    questionId: string;
+    selectedLabel?: string | undefined;
+    freeText?: string | undefined;
+}, {
+    questionId: string;
+    selectedLabel?: string | undefined;
+    freeText?: string | undefined;
+}>, {
+    questionId: string;
+    selectedLabel?: string | undefined;
+    freeText?: string | undefined;
+}, {
+    questionId: string;
+    selectedLabel?: string | undefined;
+    freeText?: string | undefined;
+}>;
+export type PlanAnswer = z.infer<typeof PlanAnswer>;
+/** POST /api/runs/:id/plan/answers body (PRD §7.2). */
+export declare const PlanAnswersInput: z.ZodObject<{
+    answers: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        questionId: z.ZodString;
+        selectedLabel: z.ZodOptional<z.ZodString>;
+        freeText: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }>, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }>, "many">;
+    executeModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    executeBudget: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        maxTurns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxBudgetUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        maxTurns?: number | null | undefined;
+        maxBudgetUsd?: number | null | undefined;
+    }, {
+        maxTurns?: number | null | undefined;
+        maxBudgetUsd?: number | null | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    answers: {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }[];
+    executeModel?: string | null | undefined;
+    executeBudget?: {
+        maxTurns?: number | null | undefined;
+        maxBudgetUsd?: number | null | undefined;
+    } | null | undefined;
+}, {
+    answers: {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }[];
+    executeModel?: string | null | undefined;
+    executeBudget?: {
+        maxTurns?: number | null | undefined;
+        maxBudgetUsd?: number | null | undefined;
+    } | null | undefined;
+}>;
+export type PlanAnswersInput = z.infer<typeof PlanAnswersInput>;
+/** plan_answers artifact contentJson (PRD §7.4). */
+export declare const PlanAnswersContent: z.ZodObject<{
+    answers: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        questionId: z.ZodString;
+        selectedLabel: z.ZodOptional<z.ZodString>;
+        freeText: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }>, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }, {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }>, "many">;
+    outcome: z.ZodEnum<["approved", "redraft"]>;
+    answeredAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    answers: {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }[];
+    outcome: "approved" | "redraft";
+    answeredAt: string;
+}, {
+    answers: {
+        questionId: string;
+        selectedLabel?: string | undefined;
+        freeText?: string | undefined;
+    }[];
+    outcome: "approved" | "redraft";
+    answeredAt: string;
+}>;
+export type PlanAnswersContent = z.infer<typeof PlanAnswersContent>;
+export type PlanGateDecision = "auto_approve" | "await_answers" | "await_review";
+/** After this many question rounds, drafts always go to manual review (PRD F3.5). */
+export declare const MAX_QUESTION_ROUNDS = 2;
+export declare function planGateDecision(input: {
+    triage: Pick<PlanTriageContent, "verdict" | "questions" | "consumed" | "parseFallback">;
+    /** Count of PRIOR plan_triage artifacts on this run that carried questions. */
+    priorQuestionRounds: number;
+}): PlanGateDecision;