agent-dealer 1.2.11 → 1.2.13

package/dist/issue.js

@@ -71,6 +71,23 @@ export function parseIssueArgs(args) {
                 throw new Error("execute requires an issue id");
             return { subcommand: "execute", id };
         }
+        case "update": {
+            const id = rest[0];
+            if (!id)
+                throw new Error("update requires an issue id");
+            const developerAgentId = flag(rest, "--developer-agent");
+            const reviewerAgentId = flag(rest, "--reviewer-agent");
+            if (!developerAgentId && !reviewerAgentId) {
+                throw new Error("update requires --developer-agent and/or --reviewer-agent");
+            }
+            return { subcommand: "update", id, developerAgentId, reviewerAgentId };
+        }
+        case "park": {
+            const id = rest[0];
+            if (!id)
+                throw new Error("park requires an issue id");
+            return { subcommand: "park", id };
+        }
         case "guide": {
             const id = rest[0];
             const message = flag(rest, "--message");
@@ -144,6 +161,24 @@ export async function runIssueCommand(args) {
                 console.error("Admitted — the workflow started immediately (queue order bypassed).");
                 return 0;
             }
+            case "update": {
+                // NOT-358: swap the developer and/or reviewer profile on a parked issue.
+                // Either flag alone is valid; the server enforces the parked-edit surface.
+                const body = {};
+                if (parsed.developerAgentId)
+                    body.developerAgentId = parsed.developerAgentId;
+                if (parsed.reviewerAgentId)
+                    body.reviewerAgentId = parsed.reviewerAgentId;
+                const result = await apiFetch(`/api/issues/${parsed.id}`, { method: "PATCH", body });
+                console.log(JSON.stringify(result, null, 2));
+                return 0;
+            }
+            case "park": {
+                // NOT-358: park an issue waiting on a usage-cap or deck-outage window for a human.
+                const result = await apiFetch(`/api/issues/${parsed.id}/park`, { method: "POST" });
+                console.log(JSON.stringify(result, null, 2));
+                return 0;
+            }
             case "guide": {
                 const result = await apiFetch(`/api/issues/${parsed.id}/guidance`, { method: "POST", body: { markdown: parsed.message } });
                 console.log(JSON.stringify(result, null, 2));

package/dist/issue.test.js

@@ -266,6 +266,98 @@ test("issue execute prints the admitted response shape and exits 0", async () =>
         stub.restore();
     }
 });
+test("parseIssueArgs: update accepts either agent flag alone, park requires an id", () => {
+    assert.deepEqual(parseIssueArgs(["update", "issue-123", "--developer-agent", "a1"]), {
+        subcommand: "update",
+        id: "issue-123",
+        developerAgentId: "a1",
+        reviewerAgentId: undefined,
+    });
+    assert.deepEqual(parseIssueArgs(["update", "issue-123", "--reviewer-agent", "a2"]), {
+        subcommand: "update",
+        id: "issue-123",
+        developerAgentId: undefined,
+        reviewerAgentId: "a2",
+    });
+    assert.deepEqual(parseIssueArgs(["update", "issue-123", "--developer-agent", "a1", "--reviewer-agent", "a2"]), { subcommand: "update", id: "issue-123", developerAgentId: "a1", reviewerAgentId: "a2" });
+    assert.throws(() => parseIssueArgs(["update", "issue-123"]), /--developer-agent/);
+    assert.throws(() => parseIssueArgs(["update"]), /issue id/);
+    assert.deepEqual(parseIssueArgs(["park", "issue-123"]), { subcommand: "park", id: "issue-123" });
+    assert.throws(() => parseIssueArgs(["park"]), /issue id/);
+});
+test("NOT-358: issue update PATCHes the agents and prints the updated issue as JSON", async () => {
+    const updated = { id: "issue-123", status: "needs_human", developerAgentId: "a-new" };
+    for (const args of [
+        ["update", "issue-123", "--developer-agent", "a-new"],
+        ["update", "issue-123", "--reviewer-agent", "r-new"],
+        ["update", "issue-123", "--developer-agent", "a-new", "--reviewer-agent", "r-new"],
+    ]) {
+        const stub = stubFetch("/api/issues/issue-123", "PATCH", updated);
+        const logs = [];
+        const originalLog = console.log;
+        console.log = (message) => logs.push(String(message));
+        try {
+            const code = await runIssueCommand(args);
+            assert.equal(code, 0);
+            const sent = stub.assertCalled();
+            const expectedKeys = args
+                .filter((a) => a.startsWith("--"))
+                .map((a) => (a === "--developer-agent" ? "developerAgentId" : "reviewerAgentId"))
+                .sort();
+            assert.deepEqual(Object.keys(sent).sort(), expectedKeys);
+            const printed = JSON.parse(logs.join("\n"));
+            assert.equal(printed.id, "issue-123");
+            assert.equal(printed.status, "needs_human");
+        }
+        finally {
+            console.log = originalLog;
+            stub.restore();
+        }
+    }
+});
+test("NOT-358: issue update returns nonzero on API failure", async () => {
+    const stub = stubFetch("/api/issues/issue-123", "PATCH", { error: "Cannot edit an issue with an active workflow" }, 409);
+    try {
+        const code = await runIssueCommand(["update", "issue-123", "--developer-agent", "a-new"]);
+        assert.equal(code, 1);
+    }
+    finally {
+        stub.restore();
+    }
+});
+test("NOT-358: issue park POSTs to the park route and prints the updated issue as JSON", async () => {
+    const stub = stubFetch("/api/issues/issue-123/park", "POST", {
+        id: "issue-123",
+        status: "needs_human",
+        humanActionId: "action-1",
+    });
+    const logs = [];
+    const originalLog = console.log;
+    console.log = (message) => logs.push(String(message));
+    try {
+        const code = await runIssueCommand(["park", "issue-123"]);
+        assert.equal(code, 0);
+        stub.assertCalled();
+        const printed = JSON.parse(logs.join("\n"));
+        assert.equal(printed.id, "issue-123");
+        assert.equal(printed.status, "needs_human");
+        assert.equal(printed.humanActionId, "action-1");
+    }
+    finally {
+        console.log = originalLog;
+        stub.restore();
+    }
+});
+test("NOT-358: issue park returns nonzero on API failure", async () => {
+    const stub = stubFetch("/api/issues/issue-123/park", "POST", { error: "Issue is not waiting on a usage-cap or deck-outage window" }, 409);
+    try {
+        const code = await runIssueCommand(["park", "issue-123"]);
+        assert.equal(code, 1);
+    }
+    finally {
+        stub.restore();
+    }
+});
 test("issue execute returns nonzero on refusal without claiming a queue action", async () => {
     const stub = stubFetch("/api/issues/issue-123/execute", "POST", { error: "waiting for slot — running: Other issue" }, 409);
     const errs = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dealer",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "description": "Human control plane for agent execution — queue, plan approval, audit",
   "license": "MIT",
   "type": "module",