agent-dealer 1.2.7 → 1.2.9

package/bundle/server/dist/coordinator/human-resolution.js

@@ -10,6 +10,13 @@ export const MERGE_FAILURE_RESPONSE_OPTIONS = [
 ];
 /** Evidence key marking a policy_escalation as a NOT-194 merge failure. */
 export const MERGE_FAILURE_EVIDENCE_KEY = "mergeFailure";
+/**
+ * NOT-310: conflicting file paths (string[]) carried on a merge-failure
+ * policy_escalation's evidence once the automatic sync + conflict-repair round are
+ * spent. Read by operators, not by routing — choice narrowing still keys off
+ * `MERGE_FAILURE_EVIDENCE_KEY` alone.
+ */
+export const MERGE_CONFLICT_FILES_EVIDENCE_KEY = "conflictingFiles";
 /** Evidence key marking a policy_escalation as a NOT-221 diverged-push escalation. */
 export const PUSH_DIVERGENCE_EVIDENCE_KEY = "pushDivergence";
 /** NOT-280: evidence key holding a worktree blocker's `{ fingerprint }` for action dedupe. */
@@ -71,6 +78,11 @@ const VALID_CHOICES = {
     deck_interaction_required: ["resume", "close"],
     reflection_interaction_required: ["retry", "dismiss"],
     outbound_delivery_interaction_required: ["retry_send", "reject"],
+    // NOT-308: listed only so the map stays total over HumanActionType — parse rejects it
+    // below and the only legal resolver is commands.ts's dedicated muse_capability branch
+    // (acknowledge records a per-version override; there is no workflow outcome to map).
+    muse_capability: ["acknowledge"],
+    operator_verification: ["verified", "waive", "repair"],
 };
 /**
  * Validates a raw (actionType, choice) pair against that action type's allowed response
@@ -84,9 +96,14 @@ const VALID_CHOICES = {
  * `outbound_delivery_interaction_required` is rejected for the same reason (NOT-95): it is
  * Run-scoped, has no Issue/workflow_instance to advance, and its only legal resolver is
  * `resolveOutboundDeliveryAction` (queue/approve-deliver.ts).
+ * `muse_capability` is rejected the same way (NOT-308): acknowledging it records a
+ * per-version capability override, not a workflow outcome, and its only legal resolver
+ * is commands.ts's dedicated branch.
  */
 export function parseHumanResolution(actionType, choice, note) {
-    if (actionType === "reflection_interaction_required" || actionType === "outbound_delivery_interaction_required") {
+    if (actionType === "reflection_interaction_required" ||
+        actionType === "outbound_delivery_interaction_required" ||
+        actionType === "muse_capability") {
         return null;
     }
     if (!(actionType in VALID_CHOICES))
@@ -98,6 +115,16 @@ export function parseHumanResolution(actionType, choice, note) {
     if (actionType === "product_scope_decision" && note) {
         return { actionType, choice, note };
     }
+    // NOT-314: operator_verification always carries a required non-empty note (the
+    // recorded result, the waiver reason, or the repair instruction). A missing or
+    // blank note is a caller error — resolveHumanActionAndAdvance 400s, never stores.
+    if (actionType === "operator_verification") {
+        if (!VALID_CHOICES.operator_verification.includes(choice))
+            return null;
+        if (!note || !note.trim())
+            return null;
+        return { actionType, choice, note: note.trim() };
+    }
     return { actionType, choice };
 }
 /**
@@ -148,6 +175,14 @@ export function resolveHumanActionOutcome(resolution) {
             throw new Error(`Unrecognized policy_escalation choice: ${resolution.choice}`);
         case "product_scope_decision":
             return { issueStatus: "developing", startNewRound: true, roundKind: "none" };
+        case "operator_verification":
+            // NOT-314: `repair` is a genuine repair cycle (same shape as
+            // final_review:repair). `verified` / `waive` never reach here — the sync
+            // core parks them for undraft+merge before consulting this outcome map
+            // (same as policy_escalation:retry_merge).
+            if (resolution.choice === "repair")
+                return { issueStatus: "repairing", startNewRound: true, roundKind: "review" };
+            throw new Error(`Unrecognized operator_verification choice: ${resolution.choice}`);
         case "deck_interaction_required":
             // Same semantics as policy_escalation:resume — an authority/control-plane hiccup is
             // not a review-round spend; a fresh attempt mints its own new authority when it runs.

package/bundle/server/dist/coordinator/human-resolution.test.js

@@ -82,3 +82,36 @@ test("deck_interaction_required close ends the issue", () => {
     assert.equal(result.issueStatus, "closed");
     assert.equal(result.workflowOutcome, "closed");
 });
+// NOT-314: operator_verification parses only with a non-empty note.
+test("parseHumanResolution accepts operator_verification choices only with a note", () => {
+    assert.deepStrictEqual(parseHumanResolution("operator_verification", "verified", "SSO login OK"), {
+        actionType: "operator_verification",
+        choice: "verified",
+        note: "SSO login OK",
+    });
+    assert.deepStrictEqual(parseHumanResolution("operator_verification", "waive", "  waiver reason  "), {
+        actionType: "operator_verification",
+        choice: "waive",
+        note: "waiver reason",
+    });
+    assert.deepStrictEqual(parseHumanResolution("operator_verification", "repair", "fix the probe"), {
+        actionType: "operator_verification",
+        choice: "repair",
+        note: "fix the probe",
+    });
+    assert.equal(parseHumanResolution("operator_verification", "verified"), null);
+    assert.equal(parseHumanResolution("operator_verification", "verified", ""), null);
+    assert.equal(parseHumanResolution("operator_verification", "verified", "   "), null);
+    assert.equal(parseHumanResolution("operator_verification", "merge", "a note"), null);
+});
+test("operator_verification repair queues another repair round; verified/waive never map here", () => {
+    const result = resolveHumanActionOutcome({
+        actionType: "operator_verification",
+        choice: "repair",
+        note: "fix the probe",
+    });
+    assert.equal(result.issueStatus, "repairing");
+    assert.equal(result.startNewRound, true);
+    assert.equal(result.roundKind, "review");
+    assert.throws(() => resolveHumanActionOutcome({ actionType: "operator_verification", choice: "verified", note: "ok" }), /Unrecognized operator_verification choice/);
+});