agent-dealer 1.3.0 → 1.3.2

package/bundle/server/dist/coordinator/commands.test.js

@@ -12,12 +12,13 @@ const { parseProfileSnapshot } = await import("@agent-dealer/shared");
 const { randomUUID } = await import("node:crypto");
 const { createIssue, getIssue, updateIssue } = await import("../repository/issues.js");
 const { listWorkflowEventsForIssue, getActiveWorkflowInstance } = await import("../repository/workflow-events.js");
-const { createHumanAction, getHumanAction, listHumanActionsForIssue } = await import("../repository/human-actions.js");
+const { createHumanAction, getHumanAction, listHumanActionsForIssue, resolveHumanAction } = await import("../repository/human-actions.js");
 const { setResumeLiveHeadReaderForTests } = await import("./resume-live-head.js");
 const { listFindingsForIssue, reconcileFinding } = await import("../repository/findings.js");
 const { cancelWorkItem, claimWorkItem, listWorkItemsForIssue, getWorkItem, enqueueWorkItem } = await import("../repository/work-items.js");
 const { createWorkerSession, completeSession, startSession, listWorkerSessionsForIssue } = await import("../repository/worker-sessions.js");
-const { startWorkflow, applyCompletion, applyParkedEdit, capWaitForIssue, resolveHumanActionAndAdvance, resolveHumanActionAndAdvanceAsync, getTaskSnapshot, canEditParkedIssue, parkCapWait, TASK_SNAPSHOT_ARTIFACT_KIND, checkIssueReadiness, abortIssue } = await import("./commands.js");
+const { startWorkflow, applyCompletion, applyParkedEdit, capWaitForIssue, resolveHumanActionAndAdvance, resolveHumanActionAndAdvanceAsync, getTaskSnapshot, diffTaskSnapshotFromLive, canEditParkedIssue, parkCapWait, TASK_SNAPSHOT_ARTIFACT_KIND, checkIssueReadiness, abortIssue } = await import("./commands.js");
+const { replaceSourceAttachments, listSourceAttachments } = await import("../repository/source-attachments.js");
 const { ReviewerResult } = await import("./reviewer-result.js");
 const { listArtifactsForIssue } = await import("../repository/artifacts-for-issue.js");
 const { setMergePrForTests, clearFinalizeInflightForTests } = await import("./auto-merge.js");
@@ -397,6 +398,231 @@ test("NOT-185: closing an edited attempts_exhausted issue does not re-freeze the
     assert.equal(resolved.ok, true);
     assert.equal(snapshotArtifacts(issueId).length, 1);
 });
+/** NOT-422: park at an active-workflow `product_scope_decision` the way a reviewer's escalated verdict does. */
+async function parkAtProductScope() {
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    await complete(issueId, cleanHandoff);
+    await complete(issueId, {
+        kind: "verdict",
+        result: { ...okReview("escalated"), productScopeQuestion: "Should deleted users retain sessions?" },
+    });
+    const action = listHumanActionsForIssue(issueId).find((a) => a.actionType === "product_scope_decision");
+    return { issueId, actionId: action.id };
+}
+test("NOT-422: canEditParkedIssue is true at an open product_scope_decision with nothing pending or leased", async () => {
+    const { issueId } = await parkAtProductScope();
+    assert.equal(canEditParkedIssue(getIssue(issueId)), true);
+    const instance = getActiveWorkflowInstance(issueId);
+    const item = enqueueWorkItem({
+        issueId,
+        workflowInstanceId: instance.id,
+        kind: "developer",
+        round: 1,
+        payload: {},
+        idempotencyKey: `${instance.id}:test:n422-pending`,
+    });
+    assert.equal(canEditParkedIssue(getIssue(issueId)), false, "a pending work item blocks the edit");
+    const leased = claim(issueId);
+    assert.equal(leased.id, item.id);
+    assert.equal(canEditParkedIssue(getIssue(issueId)), false, "a leased work item blocks the edit");
+    cancelWorkItem(item.id);
+    assert.equal(canEditParkedIssue(getIssue(issueId)), true);
+});
+test("NOT-422: other open action types keep the parked-edit surface closed", async () => {
+    const { issueId, actionId } = await parkAtProductScope();
+    // Close the scope decision without advancing (repository-level): needs_human +
+    // active workflow + no open action is not contract-editable.
+    resolveHumanAction(actionId, "test", { choice: "resume" });
+    assert.equal(getIssue(issueId).status, "needs_human");
+    assert.equal(canEditParkedIssue(getIssue(issueId)), false, "no open action");
+    // And a non-contract-editable open action does not open it either.
+    createHumanAction({
+        issueId,
+        actionType: "final_review",
+        reason: "r",
+        question: "q",
+        responseOptions: [{ choice: "merge", label: "Merge" }],
+    });
+    assert.equal(canEditParkedIssue(getIssue(issueId)), false, "final_review is not contract-editable");
+    // applyParkedEdit fails closed the same way, with no row or event change.
+    const before = getIssue(issueId);
+    const eventsBefore = listWorkflowEventsForIssue(issueId).length;
+    const refused = applyParkedEdit(issueId, { title: "Nope" });
+    assert.equal(refused.ok, false);
+    if (refused.ok !== false)
+        return;
+    assert.equal(refused.code, 409);
+    assert.deepEqual(getIssue(issueId), before);
+    assert.equal(listWorkflowEventsForIssue(issueId).length, eventsBefore);
+});
+test("NOT-422: applyParkedEdit at a scope pause accepts task text but rejects swaps, locked fields, pending items and running sessions", async () => {
+    const { issueId, actionId } = await parkAtProductScope();
+    const before = getIssue(issueId);
+    const edited = applyParkedEdit(issueId, {
+        title: "Rescoped title",
+        description: "d2",
+        acceptanceCriteria: "It works, and also does Y",
+    });
+    assert.equal(edited.ok, true);
+    if (edited.ok !== true)
+        return;
+    assert.equal(edited.issue.title, "Rescoped title");
+    assert.equal(edited.issue.description, "d2");
+    assert.equal(edited.issue.acceptanceCriteria, "It works, and also does Y");
+    // Everything else stays as the running workflow saw it, the scope action
+    // stays open, and the snapshot still carries the old text until Resume.
+    assert.equal(edited.issue.repo, before.repo);
+    assert.equal(edited.issue.baseBranch, before.baseBranch);
+    assert.equal(edited.issue.developerAgentId, before.developerAgentId);
+    assert.equal(edited.issue.reviewerAgentId, before.reviewerAgentId);
+    assert.equal(edited.issue.branch, before.branch);
+    assert.equal(edited.issue.headSha, before.headSha);
+    assert.equal(getHumanAction(actionId).status, "open");
+    assert.equal(snapshotArtifacts(issueId).length, 1);
+    assert.equal(getTaskSnapshot(getIssue(issueId)).description, "d");
+    // An agent swap at a scope pause is a 409 — the task-text allowlist names no roles.
+    const swap = applyParkedEdit(issueId, { developerAgentId: BUILTIN_AGENT_CURSOR_ID });
+    assert.equal(swap.ok, false);
+    if (swap.ok !== false)
+        return;
+    assert.equal(swap.code, 409);
+    assert.match(swap.error, /Only title, description and acceptanceCriteria can be edited while parked/);
+    assert.equal(getIssue(issueId).developerAgentId, before.developerAgentId);
+    for (const patch of [{ repo: "acme/other" }, { maxReviewRounds: 5 }, { autoMerge: true }]) {
+        const blocked = applyParkedEdit(issueId, patch);
+        assert.equal(blocked.ok, false, JSON.stringify(patch));
+        if (blocked.ok !== false)
+            return;
+        assert.equal(blocked.code, 409);
+    }
+    // A pending work item blocks the edit; cancelling it re-opens the surface.
+    const instance = getActiveWorkflowInstance(issueId);
+    const item = enqueueWorkItem({
+        issueId,
+        workflowInstanceId: instance.id,
+        kind: "developer",
+        round: 1,
+        payload: {},
+        idempotencyKey: `${instance.id}:test:n422-pending-2`,
+    });
+    const queued = applyParkedEdit(issueId, { title: "Racing edit" });
+    assert.equal(queued.ok, false);
+    if (queued.ok !== false)
+        return;
+    assert.equal(queued.code, 409);
+    cancelWorkItem(item.id);
+    assert.equal(applyParkedEdit(issueId, { title: "After cancel" }).ok, true);
+    // An actively running session blocks the edit even with nothing pending/leased.
+    const session = createWorkerSession({
+        issueId,
+        role: "developer",
+        round: 1,
+        agentId: BUILTIN_AGENT_CLAUDE_ID,
+        runtime: "claude_code",
+    });
+    startSession(session.id);
+    const running = applyParkedEdit(issueId, { title: "Racing session" });
+    assert.equal(running.ok, false);
+    if (running.ok !== false)
+        return;
+    assert.equal(running.code, 409);
+    assert.match(running.error, /actively running session/);
+    completeSession(session.id, { status: "done" });
+    const afterSession = applyParkedEdit(issueId, { title: "After session" });
+    assert.equal(afterSession.ok, true);
+});
+test("NOT-422: product-scope resume after an edit freezes one new snapshot before repair.started, note still riding", async () => {
+    const { issueId, actionId } = await parkAtProductScope();
+    assert.equal(snapshotArtifacts(issueId).length, 1);
+    updateIssue(issueId, { description: "d2", acceptanceCriteria: "It works, and also does Y" });
+    const resolved = resolveHumanActionAndAdvance(actionId, "yusuke", "resume", { note: "Scope says Y" });
+    assert.equal(resolved.ok, true);
+    assert.equal(snapshotArtifacts(issueId).length, 2);
+    const snap = getTaskSnapshot(getIssue(issueId));
+    assert.equal(snap.description, "d2");
+    assert.equal(snap.acceptanceCriteria, "It works, and also does Y");
+    assert.equal(snap.title, "Coordinate me");
+    const events = listWorkflowEventsForIssue(issueId);
+    const refreshed = events.filter((e) => e.type === "task_snapshot.refreshed");
+    assert.equal(refreshed.length, 1);
+    assert.deepEqual(JSON.parse(refreshed[0].payloadJson).changedFields, ["description", "acceptanceCriteria"]);
+    assert.equal(JSON.parse(refreshed[0].payloadJson).actionId, actionId);
+    assert.equal(refreshed[0].actorType, "human");
+    const types = events.map((e) => e.type);
+    assert.ok(types.indexOf("task_snapshot.refreshed") < types.lastIndexOf("repair.started"));
+    const pending = listWorkItemsForIssue(issueId).filter((i) => i.status === "pending");
+    assert.deepEqual(pending.map((i) => [i.kind, i.round]), [["developer", 1]]);
+    // The one-shot scope-decision note still accompanies that same work item.
+    assert.equal(JSON.parse(pending[0].payloadJson).scopeDecisionNote, "Scope says Y");
+});
+test("NOT-422: product-scope resume with no edit creates no new snapshot artifact or refresh event", async () => {
+    const { issueId, actionId } = await parkAtProductScope();
+    const resolved = resolveHumanActionAndAdvance(actionId, "yusuke", "resume");
+    assert.equal(resolved.ok, true);
+    assert.equal(snapshotArtifacts(issueId).length, 1);
+    assert.equal(listWorkflowEventsForIssue(issueId).filter((e) => e.type === "task_snapshot.refreshed").length, 0);
+});
+test("NOT-422: attachment-only row change re-freezes the manifest on product-scope resume", async () => {
+    const { issueId, actionId } = await parkAtProductScope();
+    assert.equal(snapshotArtifacts(issueId).length, 1);
+    // The post-reload row state with the text untouched: a new file manifest.
+    replaceSourceAttachments(issueId, [
+        {
+            linearAttachmentId: "att-file-1",
+            kind: "file",
+            title: "repro.tar.gz",
+            safeFileName: "repro.tar.gz",
+            blobPath: "/blobs/repro.tar.gz",
+            contentType: "application/gzip",
+            sizeBytes: 12,
+            sha256: "v2-sha",
+            url: "https://uploads.linear.app/abc/repro.tar.gz",
+        },
+    ]);
+    assert.deepEqual(diffTaskSnapshotFromLive(getIssue(issueId)), ["sourceAttachments"]);
+    const resolved = resolveHumanActionAndAdvance(actionId, "yusuke", "resume");
+    assert.equal(resolved.ok, true);
+    assert.equal(snapshotArtifacts(issueId).length, 2);
+    assert.deepEqual(getTaskSnapshot(getIssue(issueId)).sourceAttachments, listSourceAttachments(issueId));
+    const events = listWorkflowEventsForIssue(issueId);
+    const refreshed = events.filter((e) => e.type === "task_snapshot.refreshed");
+    assert.equal(refreshed.length, 1);
+    assert.deepEqual(JSON.parse(refreshed[0].payloadJson).changedFields, ["sourceAttachments"]);
+    const types = events.map((e) => e.type);
+    assert.ok(types.indexOf("task_snapshot.refreshed") < types.lastIndexOf("repair.started"));
+});
+test("NOT-422: product-scope resume with an unchanged attachment manifest creates no refresh", async () => {
+    const issueId = newIssue();
+    replaceSourceAttachments(issueId, [
+        {
+            linearAttachmentId: "att-file-1",
+            kind: "file",
+            title: "repro.tar.gz",
+            safeFileName: "repro.tar.gz",
+            blobPath: "/blobs/repro.tar.gz",
+            contentType: "application/gzip",
+            sizeBytes: 12,
+            sha256: "v1-sha",
+            url: "https://uploads.linear.app/abc/repro.tar.gz",
+        },
+        { linearAttachmentId: "att-link-1", kind: "link", title: "Design doc", url: "https://docs.example.com/spec" },
+    ]);
+    startWorkflow(issueId);
+    await complete(issueId, cleanHandoff);
+    await complete(issueId, {
+        kind: "verdict",
+        result: { ...okReview("escalated"), productScopeQuestion: "Still needed?" },
+    });
+    const action = listHumanActionsForIssue(issueId).find((a) => a.actionType === "product_scope_decision");
+    // Rows frozen at start, untouched since — the diff must be empty, not a
+    // false-positive manifest change from the row round-trip.
+    assert.deepEqual(diffTaskSnapshotFromLive(getIssue(issueId)), []);
+    const resolved = resolveHumanActionAndAdvance(action.id, "yusuke", "resume");
+    assert.equal(resolved.ok, true);
+    assert.equal(snapshotArtifacts(issueId).length, 1);
+    assert.equal(listWorkflowEventsForIssue(issueId).filter((e) => e.type === "task_snapshot.refreshed").length, 0);
+});
 test("resolving policy_escalation:resume resets the infra-attempt budget without spending a review round", async () => {
     const issueId = newIssue({ maxInfraAttempts: 1 });
     startWorkflow(issueId);

package/bundle/server/dist/coordinator/developer-effect.js

@@ -22,6 +22,8 @@ import { getTaskSnapshot } from "./commands.js";
 import { materializeSourceAttachments, SourceAttachmentError, } from "./source-attachments.js";
 import { extractOperatorCriteria } from "./operator-criteria.js";
 import { buildDeveloperPrompt } from "./prompts.js";
+import { VISUAL_QA_EXCLUDE_LINE, collectDeveloperVisualQa } from "./visual-qa.js";
+import { ensureWorktreeExcluded } from "../adapters/worktree-exclude.js";
 import { guidanceForNextSession } from "./guidance.js";
 import { realDeveloperSpawn, developerSessionLogPath } from "./spawn.js";
 import { ensureWorktreeDeps, worktreeDepsTimeoutMs, } from "../adapters/worktree-deps.js";
@@ -1093,6 +1095,16 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             : `source attachment materialization failed: ${String(err)}`;
         return { kind: "adapter_failure", reason };
     }
+    // NOT-381: git-ignore the transient visual-QA directory before the session
+    // spawns, so worker screenshots neither dirty the tree (which would break the
+    // verification receipt's clean gate and the handoff's clean check) nor get
+    // swept into a salvage commit — screenshots must never reach the product repo.
+    try {
+        ensureWorktreeExcluded(worktreePath, VISUAL_QA_EXCLUDE_LINE);
+    }
+    catch (err) {
+        return { kind: "adapter_failure", reason: `visual-QA worktree exclude failed: ${String(err)}` };
+    }
     // NOT-172: capture the worktree HEAD as this session's input-SHA baseline before
     // the agent spawns — developer work items are never enqueued with an input SHA,
     // so without this the sampler's HEAD diff (and the session_end fallback) have
@@ -1255,6 +1267,9 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             worktreePath,
             deckId: snapshot?.deckId ?? null,
             museDeveloper: isMuse,
+            // NOT-381: runtime-aware visual-QA guidance (Muse preflight vs the
+            // capable-runtime in-session attempt).
+            runtime,
             guidance: guidance.length ? guidance : undefined,
             scopeDecisionNote,
             conflictRepair,
@@ -1947,6 +1962,27 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
                 publishable: { branch: branchName },
             };
         }
+        // NOT-381: collect the structured Visual QA receipt against the just-pushed
+        // head, before the checks wait. Accepted screenshots move to Dealer-owned
+        // storage and the transient worktree directory is removed; a rejection is
+        // persisted loudly but never blocks the handoff — visual QA is evidence
+        // for review, not a gate, so a bad receipt must not burn another round.
+        try {
+            const visual = collectDeveloperVisualQa({
+                issueId: issue.id,
+                sessionId,
+                worktreePath,
+                conclusion: extractConclusion(spawned.transcript),
+                expectedHeadSha: localHead,
+            });
+            if (visual.kind === "rejected") {
+                console.warn(`[dealer] visual QA receipt rejected for ${issue.id}: ${visual.reason}`);
+            }
+        }
+        catch (err) {
+            // Evidence must never fail the handoff it describes.
+            console.warn(`[dealer] visual QA collection failed for ${issue.id}: ${String(err)}`);
+        }
         milestone("checks.started", `Developer · waiting on checks (round ${round})`, {
             prNumber: prView.number,
             headSha: prView.headRefOid,

package/bundle/server/dist/coordinator/operator-verification.integration.test.js

@@ -13,7 +13,8 @@ const { createIssue, getIssue, updateIssue, transitionIssue } = await import("..
 const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
 const { listArtifactsForIssueByKind } = await import("../repository/artifacts-for-issue.js");
 const { listWorkflowEventsForIssue, getActiveWorkflowInstance } = await import("../repository/workflow-events.js");
-const { claimWorkItem, getWorkItem } = await import("../repository/work-items.js");
+const { claimWorkItem, getWorkItem, listWorkItemsForIssue } = await import("../repository/work-items.js");
+const { createIssueArtifact } = await import("../repository/artifacts.js");
 const { startWorkflow, applyCompletion, resolveHumanActionAndAdvance, resolveHumanActionAndAdvanceAsync, responseOptionsFor, } = await import("./commands.js");
 const { ReviewerResult } = await import("./reviewer-result.js");
 const { setMergePrForTests, clearFinalizeInflightForTests, finalizeAutoMerge, gateOperatorVerification, OPERATOR_VERIFICATION_INTENT, } = await import("./auto-merge.js");
@@ -345,3 +346,103 @@ test("responseOptionsFor(operator_verification) matches the gate's stored option
         { choice: "repair", label: "Another repair round" },
     ]);
 });
+// NOT-384: a UI-affecting head whose recorded CI visual evidence is `missing`
+// holds at the same gate — one operator_verification action naming the head
+// SHA and the missing artifacts, no merge, and crucially no repair round.
+function recordVisualEvidence(issueId, opts) {
+    createIssueArtifact({
+        issueId,
+        kind: "visual_evidence",
+        content: {
+            headSha: opts.headSha,
+            baseSha: "base1",
+            uiAffecting: true,
+            state: opts.state,
+            runId: opts.state === "missing" ? null : 42,
+            artifactNames: opts.state === "available" ? ["ui-screenshots", "ui-baseline", "ui-diff"] : [],
+            reason: opts.state === "available"
+                ? null
+                : opts.state === "failed"
+                    ? "Visual run 42 for this head concluded failure — its captures are unusable"
+                    : "no Visual workflow run found for head abc123",
+        },
+        author: "system",
+    });
+}
+function assertNoRepairWorkScheduled(issueId) {
+    const pending = listWorkItemsForIssue(issueId).filter((item) => item.status === "pending" || item.status === "leased");
+    assert.deepEqual(pending.map((item) => item.kind), [], "missing visual evidence must never schedule a repair round");
+}
+for (const state of ["missing", "failed"]) {
+    test(`NOT-384: ${state} visual evidence on a UI head raises operator_verification and never a repair round`, async () => {
+        let merges = 0;
+        setMergePrForTests(async () => {
+            merges += 1;
+            return { ok: true };
+        });
+        const issueId = newIssue("It works");
+        startWorkflow(issueId);
+        recordVisualEvidence(issueId, { headSha: "abc123", state });
+        const result = await approve(issueId);
+        assert.equal(result.applied, true);
+        if (result.applied) {
+            assert.equal(result.issueStatus, "needs_human");
+            assert.equal(result.nextWorkItemId, null, "the gate queues no repair round");
+            assert.ok(result.humanActionId);
+        }
+        assert.equal(merges, 0, "the merge adapter must not run behind the gate");
+        assertNoRepairWorkScheduled(issueId);
+        const action = openOperatorAction(issueId);
+        assert.match(action.question, /abc123/, "the action names the head SHA");
+        assert.match(action.question, /ui-screenshots/, "the action names the missing artifacts");
+        assert.match(action.question, new RegExp(state), "the action names the evidence state");
+        const evidence = JSON.parse(action.evidenceJson);
+        assert.equal(evidence.operatorVerification.headSha, "abc123");
+        assert.equal(evidence.operatorVerification.visualEvidence.state, state);
+        assert.ok(evidence.operatorVerification.visualEvidence.missingArtifacts.length > 0);
+        const options = JSON.parse(action.responseOptionsJson);
+        assert.deepEqual(options.map((o) => o.choice), ["verified", "waive", "repair"]);
+    });
+}
+test("NOT-384: available visual evidence on a UI head merges normally", async () => {
+    const calls = [];
+    setMergePrForTests(async (opts) => {
+        calls.push(opts);
+        return { ok: true };
+    });
+    const issueId = newIssue("It works");
+    startWorkflow(issueId);
+    recordVisualEvidence(issueId, { headSha: "abc123", state: "available" });
+    const result = await approve(issueId);
+    assert.equal(result.applied, true);
+    if (result.applied)
+        assert.equal(result.issueStatus, "done");
+    assert.deepEqual(calls, [{ cwd: managedCwd, number: 42 }]);
+    assert.equal(getIssue(issueId).status, "done");
+});
+test("NOT-384: [operator] criteria plus a visual hold raise one action naming both", async () => {
+    let merges = 0;
+    setMergePrForTests(async () => {
+        merges += 1;
+        return { ok: true };
+    });
+    const issueId = newIssue();
+    startWorkflow(issueId);
+    recordVisualEvidence(issueId, { headSha: "abc123", state: "missing" });
+    await approve(issueId);
+    assert.equal(merges, 0);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1, "criteria and visual hold share one action for the head");
+    assert.equal(open[0].actionType, "operator_verification");
+    assert.match(open[0].question, /sign in with SSO/);
+    assert.match(open[0].question, /ui-screenshots/);
+    const evidence = JSON.parse(open[0].evidenceJson);
+    assert.equal(evidence.operatorVerification.criteria.length, 1);
+    assert.equal(evidence.operatorVerification.visualEvidence.state, "missing");
+    // One recorded result releases the combined action — a second finalize for
+    // the same head reuses it instead of raising another.
+    const again = await finalizeAutoMerge(issueId);
+    assert.equal(again.humanActionId, open[0].id);
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 1);
+    assert.equal(merges, 0);
+});