agent-dealer 1.2.11 → 1.2.13

package/bundle/server/dist/adapters/linear-inbox.js

@@ -1,9 +1,11 @@
 import { resolveLinearRepoWithMappings } from "@agent-dealer/shared";
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { listRepositoryMappings } from "../repository/repository-mappings.js";
-import { linearGraphqlRequest } from "./linear-graphql.js";
+import { LinearApiKeyMissingError, linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
-const PAGE_SIZE = 50;
+/** NOT-361: first-page bound for the From Linear picker — never walk further cursors. */
+export const LINEAR_CANDIDATE_PAGE_SIZE = 50;
+const PAGE_SIZE = LINEAR_CANDIDATE_PAGE_SIZE;
 function hasApiKey() {
     return Boolean(process.env.LINEAR_API_KEY);
 }
@@ -81,35 +83,89 @@ export function parseLinearIssueRef(raw) {
     }
     return null;
 }
+/**
+ * NOT-361: at most one GraphQL page of candidates, most recently updated first.
+ * Does not walk `pageInfo` cursors — `hasMore` tells the UI when matches remain.
+ */
 export async function listLinearCandidates() {
     if (!hasApiKey())
-        return [];
+        return { candidates: [], hasMore: false };
     const settings = getLinearIntakeConfig();
     let viewerId;
     if (settings.assigneeMe) {
         const viewer = await getLinearViewer();
         viewerId = viewer?.id;
         if (!viewerId)
-            return [];
+            return { candidates: [], hasMore: false };
     }
     const filter = buildIssueFilter(settings, viewerId);
-    const nodes = [];
-    let after;
+    const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter) {
+      issues(filter: $filter, first: ${PAGE_SIZE}, orderBy: updatedAt) {
+        nodes { ${ISSUE_FIELDS} }
+        pageInfo { hasNextPage }
+      }
+    }`, { filter }));
+    // NOT-260: mappings load once per list operation, not once per candidate.
+    const mappings = listRepositoryMappings();
+    return {
+        candidates: data.issues.nodes.map((n) => nodeToCandidate(n, mappings)),
+        hasMore: Boolean(data.issues.pageInfo.hasNextPage),
+    };
+}
+/** Page size when walking Linear teams for the filter editor metadata. */
+const METADATA_TEAM_PAGE_SIZE = 50;
+/**
+ * NOT-361: teams, workflow statuses, and the authenticated Linear viewer for
+ * the inline filter editor — never ask the operator for raw UUIDs or CSV text.
+ * Teams are walked page-by-page so large workspaces are not truncated at
+ * Linear's default first page.
+ */
+export async function fetchLinearIntakeMetadata() {
+    if (!hasApiKey())
+        throw new LinearApiKeyMissingError();
+    const viewerData = (await linearQuery("fetchLinearIntakeMetadataViewer", `query IntakeMetadataViewer { viewer { id name email } }`));
+    const teams = [];
+    const workflowStates = [];
+    let after = null;
     for (;;) {
-        const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter, $after: String) {
-        issues(filter: $filter, first: ${PAGE_SIZE}, after: $after) {
-          nodes { ${ISSUE_FIELDS} }
+        const page = (await linearQuery("fetchLinearIntakeMetadataTeams", `query IntakeMetadataTeams($first: Int!, $after: String) {
+        teams(first: $first, after: $after) {
+          nodes {
+            id
+            name
+            key
+            states { nodes { name type } }
+          }
           pageInfo { hasNextPage endCursor }
         }
-      }`, { filter, after: after ?? null }));
-        nodes.push(...data.issues.nodes);
-        if (!data.issues.pageInfo.hasNextPage || !data.issues.pageInfo.endCursor)
+      }`, { first: METADATA_TEAM_PAGE_SIZE, after }));
+        for (const team of page.teams?.nodes ?? []) {
+            teams.push({ id: team.id, name: team.name, key: team.key });
+            for (const state of team.states?.nodes ?? []) {
+                const name = state.name?.trim();
+                if (!name)
+                    continue;
+                workflowStates.push({ name, type: state.type, teamId: team.id });
+            }
+        }
+        if (!page.teams?.pageInfo?.hasNextPage || !page.teams.pageInfo.endCursor)
             break;
-        after = data.issues.pageInfo.endCursor;
+        after = page.teams.pageInfo.endCursor;
     }
-    // NOT-260: mappings load once per list operation, not once per candidate.
-    const mappings = listRepositoryMappings();
-    return nodes.map((n) => nodeToCandidate(n, mappings));
+    // Stable team order by name; statuses keep Linear's per-team order, then
+    // unique-by-name order is left to the UI when "All teams" is selected.
+    teams.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        teams,
+        workflowStates,
+        viewer: viewerData.viewer
+            ? {
+                id: viewerData.viewer.id,
+                name: viewerData.viewer.name,
+                email: viewerData.viewer.email,
+            }
+            : null,
+    };
 }
 export async function getLinearIssue(issueId) {
     const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {

package/bundle/server/dist/adapters/linear-inbox.test.js

@@ -1,6 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { buildIssueFilter, nodeToCandidate, parseLinearIssueRef } from "./linear-inbox.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { buildIssueFilter, LINEAR_CANDIDATE_PAGE_SIZE, listLinearCandidates, fetchLinearIntakeMetadata, nodeToCandidate, parseLinearIssueRef, } from "./linear-inbox.js";
 test("parseLinearIssueRef accepts identifier, URL, and UUID", () => {
     assert.equal(parseLinearIssueRef("NOT-103"), "NOT-103");
     assert.equal(parseLinearIssueRef("  not-90  "), "NOT-90");
@@ -81,3 +84,182 @@ test("buildIssueFilter includes assignee when assigneeMe is true", () => {
         assignee: { id: { eq: "viewer-1" } },
     });
 });
+// NOT-361: bounded candidate fetch — AND filters, updatedAt order, first page only.
+test("listLinearCandidates requests AND filters, updatedAt order, and a single page", async () => {
+    process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-linear-inbox-"));
+    process.env.LINEAR_API_KEY = "test-key";
+    delete process.env.LINEAR_STATE_FILTER;
+    delete process.env.LINEAR_TEAM_ID;
+    const { migrate } = await import("../db/index.js");
+    migrate();
+    const { patchLinearIntakeConfig } = await import("../repository/intake-settings.js");
+    patchLinearIntakeConfig({
+        stateFilter: ["Todo", "In Progress"],
+        teamId: "team-9",
+        assigneeMe: true,
+    });
+    const requests = [];
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        requests.push({ query: body.query ?? "", variables: body.variables });
+        if ((body.query ?? "").includes("viewer {")) {
+            return {
+                ok: true,
+                status: 200,
+                headers: new Headers(),
+                text: async () => JSON.stringify({ data: { viewer: { id: "viewer-1", name: "Ada" } } }),
+            };
+        }
+        return {
+            ok: true,
+            status: 200,
+            headers: new Headers(),
+            text: async () => JSON.stringify({
+                data: {
+                    issues: {
+                        nodes: [
+                            {
+                                id: "i1",
+                                identifier: "NOT-1",
+                                title: "one",
+                                url: "https://linear.app/x/issue/NOT-1/one",
+                                state: { name: "Todo" },
+                                team: { id: "team-9" },
+                                labels: { nodes: [] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true },
+                    },
+                },
+            }),
+        };
+    });
+    try {
+        const page = await listLinearCandidates();
+        assert.equal(page.candidates.length, 1);
+        assert.equal(page.hasMore, true);
+        // viewer (assigneeMe) + one issues page — never a second cursor page.
+        assert.equal(requests.length, 2);
+        const issuesReq = requests.find((r) => r.query.includes("issues("));
+        assert.ok(issuesReq, "issues query sent");
+        assert.match(issuesReq.query, /orderBy:\s*updatedAt/);
+        assert.match(issuesReq.query, new RegExp(`first:\\s*${LINEAR_CANDIDATE_PAGE_SIZE}`));
+        assert.ok(!issuesReq.query.includes("$after"), "no cursor variable");
+        assert.deepEqual(issuesReq.variables?.filter, {
+            state: { name: { in: ["Todo", "In Progress"] } },
+            team: { id: { eq: "team-9" } },
+            assignee: { id: { eq: "viewer-1" } },
+        });
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata returns teams, statuses, and viewer", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    const bodies = [];
+    globalThis.fetch = (async (_input, init) => {
+        bodies.push(JSON.parse(String(init?.body ?? "{}")));
+        const op = bodies[bodies.length - 1].query ?? "";
+        if (op.includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({
+                data: { viewer: { id: "v1", name: "Ada", email: "ada@example.com" } },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t1",
+                            name: "Core",
+                            key: "COR",
+                            states: {
+                                nodes: [
+                                    { name: "Todo", type: "unstarted" },
+                                    { name: "Done", type: "completed" },
+                                ],
+                            },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(meta.viewer?.name, "Ada");
+        assert.equal(meta.teams[0]?.name, "Core");
+        assert.ok(meta.workflowStates.some((s) => s.name === "Todo" && s.teamId === "t1"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata walks team pages beyond Linear's default first page", async () => {
+    process.env.LINEAR_API_KEY = "test-key";
+    const realFetch = globalThis.fetch;
+    let teamPageCalls = 0;
+    globalThis.fetch = (async (_input, init) => {
+        const body = JSON.parse(String(init?.body ?? "{}"));
+        if ((body.query ?? "").includes("IntakeMetadataViewer")) {
+            return new Response(JSON.stringify({ data: { viewer: { id: "v1", name: "Ada" } } }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        teamPageCalls += 1;
+        assert.equal(body.variables?.first, 50, "requests a bounded team page");
+        if (teamPageCalls === 1) {
+            assert.equal(body.variables?.after ?? null, null, "first page has no cursor");
+            return new Response(JSON.stringify({
+                data: {
+                    teams: {
+                        nodes: [
+                            {
+                                id: "t1",
+                                name: "Alpha",
+                                states: { nodes: [{ name: "Todo", type: "unstarted" }] },
+                            },
+                        ],
+                        pageInfo: { hasNextPage: true, endCursor: "cursor-1" },
+                    },
+                },
+            }), { status: 200, headers: { "Content-Type": "application/json" } });
+        }
+        assert.equal(body.variables?.after, "cursor-1", "follows endCursor");
+        return new Response(JSON.stringify({
+            data: {
+                teams: {
+                    nodes: [
+                        {
+                            id: "t2",
+                            name: "Zeta",
+                            states: { nodes: [{ name: "In Progress", type: "started" }] },
+                        },
+                    ],
+                    pageInfo: { hasNextPage: false, endCursor: null },
+                },
+            },
+        }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    try {
+        const meta = await fetchLinearIntakeMetadata();
+        assert.equal(teamPageCalls, 2, "walks a second team page");
+        assert.deepEqual(meta.teams.map((t) => t.name), ["Alpha", "Zeta"]);
+        assert.ok(meta.workflowStates.some((s) => s.name === "In Progress" && s.teamId === "t2"));
+    }
+    finally {
+        globalThis.fetch = realFetch;
+        delete process.env.LINEAR_API_KEY;
+    }
+});
+test("fetchLinearIntakeMetadata fails clearly without LINEAR_API_KEY", async () => {
+    delete process.env.LINEAR_API_KEY;
+    await assert.rejects(() => fetchLinearIntakeMetadata(), /LINEAR_API_KEY/);
+});

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

@@ -7,9 +7,9 @@
 // duplicate delivery is a no-op. The effect *work* itself runs elsewhere, through a leased
 // worker whose structured result comes back into applyCompletion.
 import fs from "node:fs";
-import { canTransitionIssue, tryCompileContract } from "@agent-dealer/shared";
+import { canTransitionIssue, ExecutionContractError, tryCompileContract } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
-import { getIssue, incrementIssueRound, incrementIssueInfraAttempts, incrementIssueCiAttempts, resetIssueInfraAttempts, resetIssueCiAttempts, grantReviewRetry, transitionIssue, } from "../repository/issues.js";
+import { getIssue, incrementIssueRound, incrementIssueInfraAttempts, incrementIssueCiAttempts, resetIssueInfraAttempts, resetIssueCiAttempts, grantReviewRetry, transitionIssue, updateIssue, } from "../repository/issues.js";
 import { appendWorkflowEvent, completeWorkflowInstance, getActiveWorkflowInstance, getWorkflowInstance, listWorkflowEventsForIssue, startWorkflowInstance, WorkflowAlreadyActiveError, } from "../repository/workflow-events.js";
 import { createHumanAction, findOpenHumanAction, getHumanAction, listHumanActionsForIssue, reopenHumanAction, resolveHumanAction, updateOpenHumanAction, } from "../repository/human-actions.js";
 import { pushLeaseToSha, readRemoteTip } from "../adapters/git-worktree.js";
@@ -21,7 +21,7 @@ import { githubIssuesSync, invalidateMuseHealthCache } from "../adapters/agent-h
 import { recordMuseCapabilityOverride } from "../adapters/muse-capability.js";
 import { createIssueArtifact, latestIssueArtifact } from "../repository/artifacts.js";
 import { cancelWorkItem, enqueueWorkItem, finishWorkItem, getWorkItem, getWorkItemByIdempotencyKey, listWorkItemsForIssue, } from "../repository/work-items.js";
-import { completeSession, getWorkerSession, listWorkerSessionsForIssue } from "../repository/worker-sessions.js";
+import { completeSession, getActiveWorkerSessionForIssue, getWorkerSession, listWorkerSessionsForIssue } from "../repository/worker-sessions.js";
 import { killRunProcess } from "../runners/spawn-cli.js";
 import { buildProfileSnapshot, serializeProfileSnapshot } from "./profile-snapshot.js";
 import { workerSessionPayload } from "./session-progress.js";
@@ -83,16 +83,130 @@ export function getTaskSnapshot(issue) {
  * retried. True only while the workflow is active, the issue is `needs_human` with that
  * action open, and no work item is pending or leased — so no session can be reading the
  * snapshot an edit would supersede.
+ *
+ * NOT-358: the same parked-edit surface covers an open `policy_escalation` (e.g. after a
+ * developer budget failure) so the owner can swap the developer and/or reviewer agent
+ * profile and resume in the same worktree instead of recreating the issue.
  */
 export function canEditParkedIssue(issue) {
     if (issue.status !== "needs_human")
         return false;
     if (!getActiveWorkflowInstance(issue.id))
         return false;
-    if (!findOpenHumanAction(issue.id, "attempts_exhausted"))
+    if (!findOpenHumanAction(issue.id, "attempts_exhausted") &&
+        !findOpenHumanAction(issue.id, "policy_escalation")) {
         return false;
+    }
     return !listWorkItemsForIssue(issue.id).some((w) => w.status === "pending" || w.status === "leased");
 }
+function parkableWaitFor(item) {
+    if (item.status !== "pending" || !item.errorJson)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(item.errorJson);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const { kind, until, reason } = parsed;
+    if (kind !== "usage_capped" && kind !== "deck_unavailable")
+        return null;
+    if (typeof until !== "string" || !until || typeof reason !== "string" || !reason)
+        return null;
+    return { kind, until, reason };
+}
+/** First usage-cap / deck-outage wait on the issue, if any. */
+export function capWaitForIssue(issueId) {
+    for (const item of listWorkItemsForIssue(issueId)) {
+        const wait = parkableWaitFor(item);
+        if (wait)
+            return wait;
+    }
+    return null;
+}
+/**
+ * NOT-185: the only fields a parked edit may touch. Re-scoping (title/description/
+ * criteria) re-freezes the task snapshot on retry; agent profiles re-freeze on the
+ * resumed round's profile snapshot (NOT-358). Repo, base branch, review budget and
+ * autoMerge stay as the running workflow saw them.
+ */
+export const PARKED_EDITABLE_FIELDS = new Set([
+    "title",
+    "description",
+    "acceptanceCriteria",
+    "developerAgentId",
+    "reviewerAgentId",
+]);
+/**
+ * NOT-358: applies a parked-issue edit (re-scope and/or agent swap) as one short
+ * transaction: guard re-check + agent-profile existence + row write + `issue.reassigned`
+ * audit. The guard re-reads the row so an edit that races a resume fails closed with
+ * 409 instead of landing on a live snapshot. A swap keeps the worktree, branch,
+ * `currentRound` and `maxReviewRounds` — `updateIssue` never touches those — and the
+ * next resume freezes the new profile into its work item payload.
+ */
+export function applyParkedEdit(issueId, patch) {
+    try {
+        return getDb().transaction(() => {
+            const fresh = getIssue(issueId);
+            if (!fresh)
+                return { ok: false, code: 404, error: "Issue not found" };
+            if (getActiveWorkerSessionForIssue(issueId)) {
+                return { ok: false, code: 409, error: "Cannot edit an issue with an actively running session" };
+            }
+            if (!getActiveWorkflowInstance(issueId) || !canEditParkedIssue(fresh)) {
+                return { ok: false, code: 409, error: "Cannot edit an issue with an active workflow" };
+            }
+            const blocked = Object.keys(patch).filter((k) => !PARKED_EDITABLE_FIELDS.has(k));
+            if (blocked.length > 0) {
+                return {
+                    ok: false,
+                    code: 409,
+                    error: `Only title, description, acceptanceCriteria, developerAgentId and reviewerAgentId can be edited while parked (got: ${blocked.join(", ")})`,
+                };
+            }
+            for (const role of ["developerAgentId", "reviewerAgentId"]) {
+                const agentId = patch[role];
+                if (agentId !== undefined && !getAgent(agentId)) {
+                    return { ok: false, code: 400, error: `Unknown agent profile: ${agentId}` };
+                }
+            }
+            const next = updateIssue(issueId, patch);
+            // NOT-217/NOT-240: durable configuration audit — only when an execution input
+            // actually changed, comparing against the freshly read row so a concurrent edit
+            // is attributed exactly.
+            if (fresh.repo !== next.repo ||
+                fresh.developerAgentId !== next.developerAgentId ||
+                fresh.reviewerAgentId !== next.reviewerAgentId) {
+                appendWorkflowEvent({
+                    issueId,
+                    type: "issue.reassigned",
+                    actorType: "human",
+                    stage: next.status,
+                    payload: {
+                        fromRepo: fresh.repo,
+                        toRepo: next.repo,
+                        fromDeveloperAgentId: fresh.developerAgentId,
+                        toDeveloperAgentId: next.developerAgentId,
+                        fromReviewerAgentId: fresh.reviewerAgentId,
+                        toReviewerAgentId: next.reviewerAgentId,
+                    },
+                });
+            }
+            return { ok: true, issue: next };
+        })();
+    }
+    catch (err) {
+        // NOT-306: a contract edit that turns ambiguous/malformed is a 400.
+        if (err instanceof ExecutionContractError) {
+            return { ok: false, code: 400, error: err.message };
+        }
+        throw err;
+    }
+}
 /**
  * Re-freezes the snapshot when the operator edited title/description/criteria
  * (or the contract compiled from the description); returns the changed fields
@@ -1825,7 +1939,10 @@ export function resolveHumanActionAndAdvance(actionId, resolvedBy, choice, opts)
         const issueNow = getIssue(issue.id);
         // NOT-185: freeze before queuing so the next developer prompt and the reviewer both
         // read the re-scoped task. An unedited issue writes nothing.
-        if (action.actionType === "attempts_exhausted" && resolution.choice === "retry") {
+        // NOT-358: a policy_escalation park is editable the same way (title/description/
+        // criteria as well as agent profiles), so its resume re-freezes too.
+        if ((action.actionType === "attempts_exhausted" && resolution.choice === "retry") ||
+            (action.actionType === "policy_escalation" && resolution.choice === "resume")) {
             const changedFields = refreshTaskSnapshotIfEdited(issueNow);
             if (changedFields.length > 0) {
                 ev.emit("task_snapshot.refreshed", { actorType: "human", payload: { actionId: action.id, changedFields } });
@@ -2330,6 +2447,88 @@ export function closeReadyIssue(issueId, closedBy) {
     }
     return { ok: true, ...out };
 }
+export function parkCapWait(issueId, parkedBy) {
+    const issue = getIssue(issueId);
+    if (!issue)
+        return { ok: false, code: 404, error: "Issue not found" };
+    if (issue.status === "done" || issue.status === "closed") {
+        return { ok: false, code: 409, error: `Cannot park an issue that is ${issue.status}` };
+    }
+    if (getActiveWorkerSessionForIssue(issueId)) {
+        return { ok: false, code: 409, error: "Cannot park an issue with an actively running session" };
+    }
+    if (!getActiveWorkflowInstance(issueId)) {
+        return { ok: false, code: 409, error: "Cannot park an issue with no active workflow" };
+    }
+    const items = listWorkItemsForIssue(issueId);
+    if (items.some((w) => w.status === "leased")) {
+        return { ok: false, code: 409, error: "Cannot park an issue with leased work — wait for the attempt to finish" };
+    }
+    if (!capWaitForIssue(issueId)) {
+        return { ok: false, code: 409, error: "Issue is not waiting on a usage-cap or deck-outage window" };
+    }
+    return getDb().transaction(() => {
+        const fresh = getIssue(issueId);
+        if (!fresh)
+            return { ok: false, code: 404, error: "Issue not found" };
+        if (getActiveWorkerSessionForIssue(issueId)) {
+            return { ok: false, code: 409, error: "Cannot park an issue with an actively running session" };
+        }
+        const instance = getActiveWorkflowInstance(issueId);
+        if (!instance)
+            return { ok: false, code: 409, error: "Cannot park an issue with no active workflow" };
+        const liveItems = listWorkItemsForIssue(issueId);
+        if (liveItems.some((w) => w.status === "leased")) {
+            return { ok: false, code: 409, error: "Cannot park an issue with leased work — wait for the attempt to finish" };
+        }
+        const waitItem = liveItems.find((w) => w.status === "pending" && parkableWaitFor(w) != null);
+        if (!waitItem) {
+            return { ok: false, code: 409, error: "Issue is not waiting on a usage-cap or deck-outage window" };
+        }
+        const wait = parkableWaitFor(waitItem);
+        const kindLabel = wait.kind === "usage_capped" ? "usage cap" : "Agent Deck outage";
+        const reason = `Parked by ${parkedBy} while waiting on ${kindLabel}: ${wait.reason} (wait until ${wait.until})`;
+        // A reviewer-role wait resumes as a reviewer at the pinned head (the same
+        // continuation reviewer-origin infra escalations tag); anything else takes the
+        // generic developer resume.
+        const resumeAsReviewer = waitItem.kind === "reviewer" && fresh.headSha != null;
+        for (const item of liveItems) {
+            if (item.status === "pending")
+                cancelWorkItem(item.id);
+        }
+        const ev = eventEmitter(fresh, instance, waitItem.workerSessionId, "needs_human", fresh.currentRound);
+        if (fresh.status === "needs_human") {
+            getDb()
+                .prepare("UPDATE issues SET current_owner = 'human', current_intent = ?, updated_at = ? WHERE id = ?")
+                .run(reason, new Date().toISOString(), issueId);
+        }
+        else {
+            transitionIssue(issueId, "needs_human", { currentOwner: "human", currentIntent: reason });
+        }
+        const action = createHumanAction({
+            issueId,
+            workflowInstanceId: instance.id,
+            actionType: "policy_escalation",
+            reason,
+            question: questionFor("policy_escalation", reason, resumeAsReviewer),
+            evidence: {
+                parkedCapWait: {
+                    kind: wait.kind,
+                    until: wait.until,
+                    reason: wait.reason,
+                    parkedBy,
+                    parkedAt: new Date().toISOString(),
+                },
+            },
+            continuationPreview: resumeAsReviewer
+                ? { resumeRole: "reviewer", resumeHeadSha: fresh.headSha }
+                : undefined,
+            responseOptions: responseOptionsFor("policy_escalation", resumeAsReviewer),
+        });
+        ev.emit("human_action.requested", { payload: { actionType: "policy_escalation", actionId: action.id } });
+        return { ok: true, issueStatus: getIssue(issueId).status, humanActionId: action.id };
+    })();
+}
 export async function abortIssueAsync(issueId, resolvedBy, deps = defaultAbortDeps) {
     let externalMergeState;
     try {