agent-dealer 0.2.0 → 1.0.0

package/bundle/server/dist/queue/send-gate.test.js

@@ -7,27 +7,26 @@ process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-se
 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 { approveRunWithDeliver } = await import("./approve-deliver.js");
-const { rejectPendingOutboundDrafts, pendingSendCount } = await import("../repository/outbound-drafts.js");
-const { getSnapshot } = await import("./dispatcher.js");
+const { addArtifact, createRun, getLatestArtifact, getRun, transitionRun, updateRunFields } = await import("../repository/runs.js");
+const { approveRunWithDeliver, resolveOutboundDeliveryAction, resolveOpenDeliveryParkForRun } = await import("./approve-deliver.js");
+const { rejectPendingOutboundDrafts, pendingSendCount, incrementOutboundDeliveryAttempt } = await import("../repository/outbound-drafts.js");
+const { findOpenHumanActionForRun, listHumanActionsForRun, getHumanAction } = await import("../repository/human-actions.js");
+const DECK = "6e825b59-13de-4ddd-ab7e-55ab5a1c279a";
 const TOOL_CALL = {
     serviceName: "34eb6c24-f151-4da2-8db8-d6996aa296be",
     toolName: "chat_postMessage",
-    arguments: { channel: "C1", text: "Hello gate test" },
+    arguments: { channel: "C1", text: "Hello gate test" }
 };
 const DRAFT_CONTENT = {
     draft: {
         actionType: "slack_message",
         summary: { target: "#test", body: "Hello gate test" },
-        toolCall: TOOL_CALL,
+        toolCall: TOOL_CALL
     },
-    status: "pending",
+    status: "pending"
 };
 before(() => {
     migrate();
-    updateAgent(BUILTIN_AGENT_CLAUDE_ID, { workspaceRoot: process.env.AGENT_DEALER_HOME });
 });
 function seedReviewRun(withDraft = true) {
     const run = createRun({
@@ -35,8 +34,9 @@ function seedReviewRun(withDraft = true) {
         taskCategory: "communication",
         status: "plan_pending",
         agentId: BUILTIN_AGENT_CLAUDE_ID,
+        repo: "acme/app"
     });
-    updateRunFields(run.id, { deck_id: "6e825b59-13de-4ddd-ab7e-55ab5a1c279a" });
+    updateRunFields(run.id, { deck_id: DECK });
     transitionRun(run.id, "plan_approved");
     transitionRun(run.id, "running");
     transitionRun(run.id, "review");
@@ -56,17 +56,20 @@ test("approve without draft transitions to done", async () => {
     assert.equal(res.ok && res.delivered, false);
     assert.equal(getRun(run.id).status, "done");
 });
-test("approve with mock deliver sends byte-identical payload and creates receipt", async () => {
+test("approve delivers under the run deckId and records a receipt", async () => {
     const run = seedReviewRun(true);
+    let capturedDeck = null;
     let captured = null;
     const res = await approveRunWithDeliver(run.id, {
-        deliver: async (_deckId, toolCall) => {
+        deliver: async (deckId, toolCall) => {
+            capturedDeck = deckId;
             captured = toolCall;
-            return { toolResult: { ok: true }, permalink: "https://slack.example/msg/1" };
-        },
+            return { ok: true, toolResult: { ok: true }, permalink: "https://slack.example/msg/1" };
+        }
     });
     assert.equal(res.ok, true);
     assert.equal(res.ok && res.delivered, true);
+    assert.equal(capturedDeck, DECK);
     assert.deepEqual(captured, TOOL_CALL);
     assert.equal(getRun(run.id).status, "done");
     assert.ok(getLatestArtifact(run.id, "send_receipt"));
@@ -80,54 +83,170 @@ test("approve with human-edited body sends updated payload", async () => {
         outboundBody: "Human tweak before send",
         deliver: async (_deckId, toolCall) => {
             captured = toolCall;
-            return { toolResult: { ok: true } };
-        },
+            return { ok: true, toolResult: { ok: true } };
+        }
     });
     assert.equal(res.ok, true);
     assert.deepEqual(captured, {
         ...TOOL_CALL,
-        arguments: { ...TOOL_CALL.arguments, text: "Human tweak before send" },
+        arguments: { ...TOOL_CALL.arguments, text: "Human tweak before send" }
     });
     const draftArt = getLatestArtifact(run.id, "slack_draft");
     assert.match(draftArt.contentJson, /Human tweak before send/);
 });
-test("deliver failure keeps run in review with pending draft", async () => {
+test("deliver infra failure keeps run in review with pending draft, no park", async () => {
     const run = seedReviewRun(true);
     const res = await approveRunWithDeliver(run.id, {
-        deliver: async () => {
-            throw new Error("deck down");
-        },
+        deliver: async () => ({ ok: false, kind: "infra_failure", reason: "deck down" })
     });
     assert.equal(res.ok, false);
     assert.equal(!res.ok && res.code, 502);
+    assert.equal(!res.ok && res.errorCode, "DELIVERY_FAILED");
     assert.equal(getRun(run.id).status, "review");
     assert.equal(pendingSendCount(run.id), 1);
+    assert.equal(findOpenHumanActionForRun(run.id, "outbound_delivery_interaction_required"), null);
     const draftArt = getLatestArtifact(run.id, "slack_draft");
     assert.match(draftArt.contentJson, /"status":"pending"/);
 });
-test("mark sent before deliver prevents double-send race", async () => {
+test("off-scope/provider denial surfaces as an ordinary delivery failure, not parked", async () => {
+    const run = seedReviewRun(true);
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => ({
+            ok: false,
+            kind: "infra_failure",
+            reason: "RESOURCE_OUT_OF_SCOPE: tool not in authority's allowed set"
+        })
+    });
+    assert.equal(res.ok, false);
+    assert.equal(getRun(run.id).status, "review");
+    assert.equal(findOpenHumanActionForRun(run.id, "outbound_delivery_interaction_required"), null);
+    assert.ok(!getLatestArtifact(run.id, "send_receipt"));
+});
+test("deliver returning ambiguous parks the run: draft pending, run in review, one open action", async () => {
     const run = seedReviewRun(true);
-    let deliverCalls = 0;
     const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => ({
+            ok: false,
+            kind: "ambiguous",
+            reason: "Outbound deliver timed out after 60000ms — whether the message was actually sent is unknown"
+        })
+    });
+    assert.equal(res.ok, false);
+    assert.equal(!res.ok && res.errorCode, "AMBIGUOUS_RESULT");
+    assert.equal(getRun(run.id).status, "review");
+    assert.equal(pendingSendCount(run.id), 1);
+    const action = findOpenHumanActionForRun(run.id, "outbound_delivery_interaction_required");
+    assert.ok(action);
+    assert.equal(action.runId, run.id);
+    assert.deepEqual(JSON.parse(action.responseOptionsJson), [
+        { choice: "retry_send", label: "Retry send" },
+        { choice: "reject", label: "Reject draft" },
+    ]);
+});
+test("a repeated ambiguous signal dedupes to one action", async () => {
+    const run = seedReviewRun(true);
+    const deps = {
+        deliver: async () => ({
+            ok: false,
+            kind: "ambiguous",
+            reason: "timeout — whether the message was actually sent is unknown"
+        })
+    };
+    await approveRunWithDeliver(run.id, deps);
+    await approveRunWithDeliver(run.id, deps);
+    const actions = listHumanActionsForRun(run.id).filter((a) => a.actionType === "outbound_delivery_interaction_required");
+    assert.equal(actions.length, 1);
+});
+async function seedParkedRunViaAmbiguous() {
+    const run = seedReviewRun(true);
+    await approveRunWithDeliver(run.id, {
+        deliver: async () => ({
+            ok: false,
+            kind: "ambiguous",
+            reason: "timeout — whether the message was actually sent is unknown"
+        })
+    });
+    const action = findOpenHumanActionForRun(run.id, "outbound_delivery_interaction_required");
+    assert.ok(action, "expected the original attempt to have parked the run");
+    return { run, actionId: action.id };
+}
+test("resolveOutboundDeliveryAction:retry_send re-delivers and closes the park on success", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    const res = await resolveOutboundDeliveryAction(actionId, "yusuke", "retry_send", {
+        deliver: async () => ({ ok: true, toolResult: { ok: true } })
+    });
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.delivered, true);
+    assert.equal(getRun(run.id).status, "done");
+    const resolved = getHumanAction(actionId);
+    assert.equal(resolved.status, "resolved");
+    assert.equal(resolved.resolvedBy, "yusuke");
+    assert.deepEqual(JSON.parse(resolved.resolutionJson), { choice: "retry_send" });
+});
+test("a plain re-approve (not via retry_send) closes an open delivery park too, with a generic system resolution", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    const res = await approveRunWithDeliver(run.id, {
+        deliver: async () => ({ ok: true, toolResult: { ok: true } })
+    });
+    assert.equal(res.ok, true);
+    assert.equal(res.ok && res.delivered, true);
+    assert.equal(getRun(run.id).status, "done");
+    const resolved = getHumanAction(actionId);
+    assert.equal(resolved.status, "resolved");
+    assert.equal(resolved.resolvedBy, "system");
+    assert.deepEqual(JSON.parse(resolved.resolutionJson), { choice: "resolved_via_approve" });
+});
+test("resolveOutboundDeliveryAction:retry_send that fails leaves the action open, not resolved", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    const res = await resolveOutboundDeliveryAction(actionId, "yusuke", "retry_send", {
+        deliver: async () => ({ ok: false, kind: "infra_failure", reason: "deck down again" })
+    });
+    assert.equal(res.ok, false);
+    assert.equal(getRun(run.id).status, "review");
+    assert.equal(pendingSendCount(run.id), 1);
+    assert.equal(getHumanAction(actionId).status, "open");
+});
+test("resolveOutboundDeliveryAction:retry_send that hits ambiguous again reuses the same open action, no duplicate", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    const res = await resolveOutboundDeliveryAction(actionId, "yusuke", "retry_send", {
+        deliver: async () => ({ ok: false, kind: "ambiguous", reason: "still ambiguous" })
+    });
+    assert.equal(res.ok, false);
+    assert.equal(getHumanAction(actionId).status, "open");
+    const actions = listHumanActionsForRun(run.id).filter((a) => a.actionType === "outbound_delivery_interaction_required");
+    assert.equal(actions.length, 1);
+    assert.equal(actions[0].id, actionId);
+});
+test("resolveOutboundDeliveryAction:reject makes no deliver call, draft ends rejected, run ends done", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    let called = false;
+    const res = await resolveOutboundDeliveryAction(actionId, "yusuke", "reject", {
         deliver: async () => {
-            deliverCalls++;
-            return { toolResult: { ok: true } };
-        },
+            called = true;
+            throw new Error("must not be called");
+        }
     });
     assert.equal(res.ok, true);
-    assert.equal(deliverCalls, 1);
+    assert.equal(res.ok && res.delivered, false);
+    assert.equal(called, false);
+    assert.equal(pendingSendCount(run.id), 0);
+    assert.equal(getRun(run.id).status, "done");
     const draftArt = getLatestArtifact(run.id, "slack_draft");
-    assert.match(draftArt.contentJson, /"status":"sent"/);
+    assert.match(draftArt.contentJson, /"status":"rejected"/);
 });
-test("proxy success:false from deck is treated as deliver failure", async () => {
+test("mark sent before deliver prevents double-send race", async () => {
     const run = seedReviewRun(true);
+    let deliverCalls = 0;
     const res = await approveRunWithDeliver(run.id, {
         deliver: async () => {
-            throw new Error("Service not found");
-        },
+            deliverCalls++;
+            return { ok: true, toolResult: { ok: true } };
+        }
     });
-    assert.equal(res.ok, false);
-    assert.equal(getRun(run.id).status, "review");
+    assert.equal(res.ok, true);
+    assert.equal(deliverCalls, 1);
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.match(draftArt.contentJson, /"status":"sent"/);
 });
 test("retry rejects pending draft", () => {
     const run = seedReviewRun(true);
@@ -136,7 +255,24 @@ test("retry rejects pending draft", () => {
     const draftArt = getLatestArtifact(run.id, "slack_draft");
     assert.match(draftArt.contentJson, /"status":"rejected"/);
 });
-test("snapshot exposes pendingSendCounts", () => {
-    const snap = getSnapshot();
-    assert.equal(typeof snap.pendingSendCounts, "object");
+test("resolveOpenDeliveryParkForRun closes an open park", async () => {
+    const { run, actionId } = await seedParkedRunViaAmbiguous();
+    resolveOpenDeliveryParkForRun(run.id, { resolvedBy: "system", choice: "superseded_by_retry" });
+    const resolved = getHumanAction(actionId);
+    assert.equal(resolved.status, "resolved");
+    assert.equal(resolved.resolvedBy, "system");
+    assert.deepEqual(JSON.parse(resolved.resolutionJson), { choice: "superseded_by_retry" });
+});
+test("resolveOpenDeliveryParkForRun is a no-op when nothing is parked", () => {
+    const run = seedReviewRun(true);
+    resolveOpenDeliveryParkForRun(run.id, { resolvedBy: "system", choice: "cancelled" });
+});
+test("incrementOutboundDeliveryAttempt counts up from 1 for a real draft", () => {
+    const run = seedReviewRun(true);
+    const draftArt = getLatestArtifact(run.id, "slack_draft");
+    assert.equal(incrementOutboundDeliveryAttempt(draftArt.id), 1);
+    assert.equal(incrementOutboundDeliveryAttempt(draftArt.id), 2);
+});
+test("incrementOutboundDeliveryAttempt returns null for a nonexistent artifact", () => {
+    assert.equal(incrementOutboundDeliveryAttempt("00000000-0000-0000-0000-000000000000"), null);
 });

package/bundle/server/dist/repository/agents.js

@@ -1,6 +1,12 @@
-import { serializePhaseBudget } from "@agent-dealer/shared";
+import { ReasoningEffort as ReasoningEffortSchema, resolveProfileBudgetJson, resolveProfileModel, serializePermissionPolicyOverride, serializePhaseBudget, } from "@agent-dealer/shared";
 import { v4 as uuid } from "uuid";
 import { getDb } from "../db/index.js";
+function parseStoredEffort(raw) {
+    if (!raw)
+        return null;
+    const parsed = ReasoningEffortSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
 function rowToAgent(row) {
     return {
         id: row.id,
@@ -10,10 +16,21 @@ function rowToAgent(row) {
         deckId: row.deck_id,
         deckName: row.deck_name,
         playbookId: row.playbook_id,
+        // Read-only legacy compatibility (NOT-71): no write path sets these any more, but
+        // profile-snapshot.ts falls back to them for profiles saved before default_model /
+        // default_budget_json existed, so dropping them here would silently change the model
+        // and caps those sessions run under.
         defaultPlanModel: row.default_plan_model,
         defaultExecuteModel: row.default_execute_model,
         defaultPlanBudgetJson: row.default_plan_budget_json,
         defaultExecuteBudgetJson: row.default_execute_budget_json,
+        defaultModel: row.default_model,
+        defaultEffort: parseStoredEffort(row.default_effort),
+        defaultBudgetJson: row.default_budget_json,
+        purpose: row.purpose,
+        playbookIdsJson: row.playbook_ids_json,
+        externalMemoryRefsJson: row.external_memory_refs_json,
+        permissionPolicyJson: row.permission_policy_json,
         isBuiltin: row.is_builtin === 1,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
@@ -34,9 +51,17 @@ export function createAgent(input, deckName) {
     const now = new Date().toISOString();
     const id = uuid();
     db.prepare(`
-    INSERT INTO agents (id, name, runtime, deck_id, deck_name, playbook_id, workspace_root, default_plan_model, default_execute_model, default_plan_budget_json, default_execute_budget_json, is_builtin, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
-  `).run(id, input.name.trim(), input.runtime, input.deckId ?? null, deckName ?? null, input.playbookId ?? null, input.workspaceRoot.trim(), input.defaultPlanModel ?? null, input.defaultExecuteModel ?? null, serializePhaseBudget(input.defaultPlanBudget), serializePhaseBudget(input.defaultExecuteBudget), now, now);
+    INSERT INTO agents (
+      id, name, runtime, deck_id, deck_name, playbook_id, workspace_root,
+      default_model, default_effort, default_budget_json, purpose, playbook_ids_json, external_memory_refs_json, permission_policy_json,
+      is_builtin, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+  `).run(id, input.name.trim(), input.runtime, input.deckId, deckName ?? null, null, // playbook_id — dead legacy (NOT-149)
+    null, // workspace_root — dead legacy (NOT-149)
+    input.defaultModel ?? null, input.defaultEffort ?? null, serializePhaseBudget(input.defaultBudget), input.purpose?.trim() || null, null, // playbook_ids_json — dead legacy
+    null, // external_memory_refs_json — dead legacy
+    serializePermissionPolicyOverride(input.permissionPolicy), now, now);
     return getAgent(id);
 }
 export function updateAgent(id, input, deckName) {
@@ -46,25 +71,39 @@ export function updateAgent(id, input, deckName) {
     const now = new Date().toISOString();
     const name = input.name?.trim() ?? existing.name;
     const runtime = input.runtime ?? existing.runtime;
-    const workspaceRoot = input.workspaceRoot !== undefined ? input.workspaceRoot?.trim() || null : existing.workspaceRoot;
+    // workspace / playbook / external-memory columns are dead legacy (NOT-149) — leave
+    // whatever was stored so in-flight migration stays recoverable; never rewrite from API.
+    const workspaceRoot = existing.workspaceRoot;
     const deckId = input.deckId !== undefined ? input.deckId : existing.deckId;
-    const playbookId = input.playbookId !== undefined ? input.playbookId : existing.playbookId;
-    const defaultPlanModel = input.defaultPlanModel !== undefined ? input.defaultPlanModel : existing.defaultPlanModel;
-    const defaultExecuteModel = input.defaultExecuteModel !== undefined ? input.defaultExecuteModel : existing.defaultExecuteModel;
-    const defaultPlanBudgetJson = input.defaultPlanBudget !== undefined
-        ? serializePhaseBudget(input.defaultPlanBudget)
-        : existing.defaultPlanBudgetJson;
-    const defaultExecuteBudgetJson = input.defaultExecuteBudget !== undefined
-        ? serializePhaseBudget(input.defaultExecuteBudget)
-        : existing.defaultExecuteBudgetJson;
+    const playbookId = existing.playbookId;
+    // Collapse the pre-NOT-71 plan/execute columns into the role-neutral one on every write,
+    // and clear them below. Reading them back (resolveProfile*) is deliberate compatibility for
+    // rows written before the migration; continuing to *keep* them is not. Without this, editing
+    // a legacy profile saved a null role-neutral model while the legacy column kept winning the
+    // fallback — so the form showed blank while the session still ran the hidden value, and
+    // switching runtime carried the old runtime's model into the new one's snapshot.
+    const defaultModel = input.defaultModel !== undefined ? input.defaultModel : resolveProfileModel(existing);
+    const defaultEffort = input.defaultEffort !== undefined ? input.defaultEffort : existing.defaultEffort;
+    const defaultBudgetJson = input.defaultBudget !== undefined
+        ? serializePhaseBudget(input.defaultBudget)
+        : resolveProfileBudgetJson(existing);
+    const purpose = input.purpose !== undefined ? input.purpose?.trim() || null : existing.purpose;
+    const playbookIdsJson = existing.playbookIdsJson;
+    const externalMemoryRefsJson = existing.externalMemoryRefsJson;
+    const permissionPolicyJson = input.permissionPolicy !== undefined
+        ? serializePermissionPolicyOverride(input.permissionPolicy)
+        : existing.permissionPolicyJson;
     const resolvedDeckName = input.deckId !== undefined ? (input.deckId ? (deckName ?? null) : null) : existing.deckName;
     getDb()
         .prepare(`
       UPDATE agents SET name = ?, runtime = ?, deck_id = ?, deck_name = ?, playbook_id = ?, workspace_root = ?,
-        default_plan_model = ?, default_execute_model = ?, default_plan_budget_json = ?, default_execute_budget_json = ?, updated_at = ?
+        default_model = ?, default_effort = ?, default_budget_json = ?, purpose = ?, playbook_ids_json = ?, external_memory_refs_json = ?, permission_policy_json = ?,
+        default_plan_model = NULL, default_execute_model = NULL,
+        default_plan_budget_json = NULL, default_execute_budget_json = NULL,
+        updated_at = ?
       WHERE id = ?
     `)
-        .run(name, runtime, deckId, resolvedDeckName, playbookId, workspaceRoot, defaultPlanModel, defaultExecuteModel, defaultPlanBudgetJson, defaultExecuteBudgetJson, now, id);
+        .run(name, runtime, deckId, resolvedDeckName, playbookId, workspaceRoot, defaultModel, defaultEffort, defaultBudgetJson, purpose, playbookIdsJson, externalMemoryRefsJson, permissionPolicyJson, now, id);
     return getAgent(id);
 }
 export function deleteAgent(id) {
@@ -82,9 +121,7 @@ export function resolveAgent(agentId) {
         agentId: agent.id,
         agentName: agent.name,
         runtime: agent.runtime,
-        workspaceRoot: agent.workspaceRoot ?? undefined,
         deckId: agent.deckId ?? undefined,
         deckName: agent.deckName,
-        playbookId: agent.playbookId ?? undefined,
     };
 }

package/bundle/server/dist/repository/artifacts-for-issue.js

@@ -0,0 +1,42 @@
+import { getDb } from "../db/index.js";
+function rowToArtifact(row) {
+    return {
+        id: row.id,
+        issueId: row.issue_id,
+        workerSessionId: row.worker_session_id,
+        kind: row.kind,
+        contentJson: row.content_json,
+        blobPath: row.blob_path,
+        author: row.author,
+        createdAt: row.created_at,
+    };
+}
+/** Scoped to the issue so a caller can't fetch an artifact belonging to a different
+ * issue by guessing/incrementing an id — used by the raw-trace route. */
+export function getIssueArtifact(issueId, artifactId) {
+    const row = getDb()
+        .prepare("SELECT * FROM artifacts WHERE id = ? AND issue_id = ?")
+        .get(artifactId, issueId);
+    return row ? rowToArtifact(row) : null;
+}
+export function listArtifactsForIssue(issueId, opts) {
+    const limit = opts?.limit ?? 50;
+    const rows = opts?.before
+        ? getDb()
+            .prepare("SELECT * FROM artifacts WHERE issue_id = ? AND created_at < ? ORDER BY created_at DESC LIMIT ?")
+            .all(issueId, opts.before, limit)
+        : getDb()
+            .prepare("SELECT * FROM artifacts WHERE issue_id = ? ORDER BY created_at DESC LIMIT ?")
+            .all(issueId, limit);
+    return rows.map(rowToArtifact);
+}
+/** Every artifact of `kind` for the issue, unbounded — unlike `listArtifactsForIssue`'s
+ * newest-first `limit` window, filtering by kind in SQL means a caller that needs "all
+ * artifacts of this kind ever recorded" (e.g. reflect-trigger's already-proposed-playbook
+ * scan) can't have an old row fall outside the window on an artifact-heavy issue. */
+export function listArtifactsForIssueByKind(issueId, kind) {
+    const rows = getDb()
+        .prepare("SELECT * FROM artifacts WHERE issue_id = ? AND kind = ? ORDER BY created_at DESC")
+        .all(issueId, kind);
+    return rows.map(rowToArtifact);
+}

package/bundle/server/dist/repository/artifacts-for-issue.test.js

@@ -0,0 +1,48 @@
+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-artifacts-issue-"));
+const { migrate, getDb } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue } = await import("./issues.js");
+const { listArtifactsForIssue, listArtifactsForIssueByKind } = await import("./artifacts-for-issue.js");
+const { recordUsageEvent } = await import("./usage-events.js");
+const { createWorkerSession } = await import("./worker-sessions.js");
+before(() => {
+    migrate();
+});
+test("lists artifacts for an issue newest first, respects limit", () => {
+    const issue = createIssue({ title: "T", repo: "acme/app", baseBranch: "main", developerAgentId: BUILTIN_AGENT_CLAUDE_ID, reviewerAgentId: BUILTIN_AGENT_CURSOR_ID, maxReviewRounds: 3, maxInfraAttempts: 3, source: "manual" });
+    const db = getDb();
+    const now = Date.now();
+    for (let i = 0; i < 3; i++) {
+        db.prepare(`INSERT INTO artifacts (id, issue_id, run_id, kind, content_json, author, created_at) VALUES (?, ?, NULL, 'task_snapshot', '{}', 'system', ?)`).run(`art-${i}`, issue.id, new Date(now + i * 1000).toISOString());
+    }
+    const all = listArtifactsForIssue(issue.id);
+    assert.equal(all.length, 3);
+    assert.equal(all[0].id, "art-2"); // newest first
+    const limited = listArtifactsForIssue(issue.id, { limit: 2 });
+    assert.equal(limited.length, 2);
+});
+test("listArtifactsForIssueByKind finds a matching row regardless of how many newer rows of other kinds exist", () => {
+    const issue = createIssue({ title: "K", repo: "acme/app", baseBranch: "main", developerAgentId: BUILTIN_AGENT_CLAUDE_ID, reviewerAgentId: BUILTIN_AGENT_CURSOR_ID, maxReviewRounds: 3, maxInfraAttempts: 3, source: "manual" });
+    const db = getDb();
+    const now = Date.now();
+    db.prepare(`INSERT INTO artifacts (id, issue_id, run_id, kind, content_json, author, created_at) VALUES (?, ?, NULL, 'playbook_patch', '{}', 'system', ?)`).run("patch-1", issue.id, new Date(now).toISOString());
+    for (let i = 0; i < 250; i++) {
+        db.prepare(`INSERT INTO artifacts (id, issue_id, run_id, kind, content_json, author, created_at) VALUES (?, ?, NULL, 'reflect_status', '{}', 'system', ?)`).run(`status-${i}`, issue.id, new Date(now + (i + 1) * 1000).toISOString());
+    }
+    const matches = listArtifactsForIssueByKind(issue.id, "playbook_patch");
+    assert.equal(matches.length, 1);
+    assert.equal(matches[0].id, "patch-1");
+});
+test("listUsageEventsForIssue returns recorded events", async () => {
+    const { listUsageEventsForIssue } = await import("./usage-events.js");
+    const issue = createIssue({ title: "U", repo: "acme/app", baseBranch: "main", developerAgentId: BUILTIN_AGENT_CLAUDE_ID, reviewerAgentId: BUILTIN_AGENT_CURSOR_ID, maxReviewRounds: 3, maxInfraAttempts: 3, source: "manual" });
+    const session = createWorkerSession({ issueId: issue.id, role: "developer", round: 1, agentId: BUILTIN_AGENT_CLAUDE_ID, runtime: "claude_code" });
+    recordUsageEvent({ issueId: issue.id, workerSessionId: session.id, role: "developer", costUsd: 1 });
+    const events = listUsageEventsForIssue(issue.id);
+    assert.equal(events.length, 1);
+});

package/bundle/server/dist/repository/artifacts.js

@@ -0,0 +1,47 @@
+// packages/server/src/repository/artifacts.ts
+//
+// Write side for issue-scoped artifacts. `artifacts-for-issue.ts` only ever read this
+// table (issue_id/worker_session_id columns added additively by migrate(), see
+// db/index.ts) — nothing wrote an issue-scoped row until NOT-61 needed one for the frozen
+// task snapshot and the developer's implementation conclusion.
+import { v4 as uuid } from "uuid";
+import { getDb } from "../db/index.js";
+export function createIssueArtifact(input) {
+    const id = uuid();
+    const now = new Date().toISOString();
+    const contentJson = input.content !== undefined ? JSON.stringify(input.content) : null;
+    getDb()
+        .prepare(`
+      INSERT INTO artifacts (id, issue_id, worker_session_id, kind, content_json, blob_path, author, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `)
+        .run(id, input.issueId, input.workerSessionId ?? null, input.kind, contentJson, input.blobPath ?? null, input.author, now);
+    return {
+        id,
+        issueId: input.issueId,
+        workerSessionId: input.workerSessionId ?? null,
+        kind: input.kind,
+        contentJson,
+        blobPath: input.blobPath ?? null,
+        author: input.author,
+        createdAt: now,
+    };
+}
+/** Most recent artifact of `kind` for the issue — used to read the frozen task snapshot. */
+export function latestIssueArtifact(issueId, kind) {
+    const row = getDb()
+        .prepare("SELECT * FROM artifacts WHERE issue_id = ? AND kind = ? ORDER BY created_at DESC LIMIT 1")
+        .get(issueId, kind);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        issueId: row.issue_id,
+        workerSessionId: row.worker_session_id,
+        kind: row.kind,
+        contentJson: row.content_json,
+        blobPath: row.blob_path,
+        author: row.author,
+        createdAt: row.created_at,
+    };
+}

package/bundle/server/dist/repository/artifacts.test.js

@@ -0,0 +1,48 @@
+// packages/server/src/repository/artifacts.test.ts
+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-artifacts-"));
+const { migrate } = await import("../db/index.js");
+const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
+const { createIssue } = await import("./issues.js");
+const { createIssueArtifact, latestIssueArtifact } = await import("./artifacts.js");
+const { listArtifactsForIssue } = await import("./artifacts-for-issue.js");
+before(() => migrate());
+function issue() {
+    return createIssue({
+        title: "T",
+        repo: "acme/app",
+        baseBranch: "main",
+        developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+        reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+        maxReviewRounds: 3,
+        maxInfraAttempts: 3,
+        source: "manual"
+    }).id;
+}
+test("createIssueArtifact writes a row readable via listArtifactsForIssue", () => {
+    const issueId = issue();
+    const created = createIssueArtifact({ issueId, kind: "task_snapshot", author: "system", content: { title: "T" } });
+    const listed = listArtifactsForIssue(issueId);
+    assert.equal(listed.length, 1);
+    assert.equal(listed[0].id, created.id);
+    assert.equal(listed[0].kind, "task_snapshot");
+    assert.deepEqual(JSON.parse(listed[0].contentJson), { title: "T" });
+    assert.equal(listed[0].workerSessionId, null);
+});
+test("latestIssueArtifact returns the newest row of that kind, ignoring other kinds", async () => {
+    const issueId = issue();
+    createIssueArtifact({ issueId, kind: "task_snapshot", author: "system", content: { v: 1 } });
+    // created_at is millisecond-resolution — sleep past a tie so ordering is deterministic.
+    await new Promise((r) => setTimeout(r, 5));
+    const later = createIssueArtifact({ issueId, kind: "task_snapshot", author: "system", content: { v: 2 } });
+    createIssueArtifact({ issueId, kind: "implementation_conclusion", author: "agent", content: { text: "done" } });
+    const latest = latestIssueArtifact(issueId, "task_snapshot");
+    assert.ok(latest);
+    assert.equal(latest.id, later.id);
+    assert.equal(latest.kind, "task_snapshot");
+    assert.equal(latestIssueArtifact(issueId, "no_such_kind"), null);
+});