@nanobpm/nano-workforce 0.56.0 → 0.58.0

package/openapi.yaml

@@ -306,6 +306,19 @@ components:
         alreadyRunning:
           type: boolean
           description: True when a non-terminal plan for this issue already exists; no new instance was started.
+    StartFeatureResult:
+      type: object
+      required:
+        - featureKey
+      properties:
+        featureKey:
+          type: string
+        processKey:
+          type: string
+          nullable: true
+        alreadyRunning:
+          type: boolean
+          description: True when a non-terminal feature run for this issue already exists; no new instance was started.
     ConvergenceStart:
       description: The start-convergence request body. Names the target PR by EXACTLY ONE of `pr`
         (an `owner/repo#123` reference) or `url` (a bare PR URL) — never both, never neither — with
@@ -361,9 +374,10 @@ components:
             per-request review-only override; defaults to false (the global auto-merge default applies).
     PlanStart:
       description: The start-plan-fanout request body. Names the target issue by EXACTLY ONE of
-        `issue` (an `owner/repo#123` reference) or `url` (a bare issue URL). Modeled as `oneOf`
-        named variants (Camunda REST v2 pattern) so an ambiguous or empty target is a 400 at the
-        edge, not a silent `issue ?? url` coalesce in the delegate.
+        `issue` (an `owner/repo#123` reference) or `url` (a bare issue URL), plus a REQUIRED
+        `baseBranch` (ADR 0003) the fleet branches off — a blank/absent base is a 400. Modeled as
+        `oneOf` named variants (Camunda REST v2 pattern) so an ambiguous or empty target is a 400 at
+        the edge, not a silent `issue ?? url` coalesce in the delegate.
       oneOf:
         - $ref: "#/components/schemas/PlanStartByIssue"
         - $ref: "#/components/schemas/PlanStartByUrl"
@@ -372,105 +386,215 @@ components:
       additionalProperties: false
       required:
         - issue
+        - baseBranch
       properties:
         issue:
           type: string
           description: "Issue reference: owner/repo#123."
         baseBranch:
           type: string
+          minLength: 1
+          maxLength: 255
+          pattern: '\S'
+          description: >-
+            REQUIRED target branch the fleet branches off and opens every PR against. Every epic
+            launch must name its base explicitly (ADR 0003): a blank/absent value is rejected with a
+            400, not silently coalesced to the repository default branch. Use it to land an entire
+            epic on a long-lived integration branch (e.g. `epic/agent-protocol`) so nothing reaches
+            the default branch — and any merge-to-default side effect, such as auto-publishing a
+            package — until you deliberately merge the integration branch. NOTE: this slice (B0)
+            only enforces that `baseBranch` is present and a plausible branch name; branch-existence
+            admission (auto-creating a missing `epic/*` base off the default branch HEAD, and
+            rejecting a missing non-`epic/*` base with a 400) is specified by ADR 0003 but NOT yet
+            enforced here — it lands in a later admission slice.
+        allowSharedBase:
+          type: boolean
           description: >-
-            Optional target branch the fleet branches off and opens every PR against, instead of the
-            repository's default branch. Use this to land an entire epic on a long-lived integration
-            branch (e.g. `epic/agent-protocol`) so nothing reaches the default branch — and any
-            merge-to-default side effect, such as auto-publishing a package — until you deliberately
-            merge the integration branch. Blank/omitted keeps the current behaviour (the repo
-            default branch).
+            Reserved for a later ADR 0003 admission slice — NOT yet enforced in this slice (B0). When
+            implemented it will opt in to sharing a custom integration base branch with another
+            already-active plan: admission will otherwise reject (409) when another active plan already
+            targets the same repo + same custom base branch, to stop two epics interleaving commits on
+            one integration branch (the repository default branch is exempt from that guard). Accepted
+            by the schema today but currently has no runtime effect.
+        confirmDefaultBase:
+          type: boolean
+          description: >-
+            Reserved for a later ADR 0003 admission slice — NOT yet enforced in this slice (B0). When
+            implemented it will be the required acknowledgement when `baseBranch` names the repository
+            default branch: targeting the default lands every task directly on it with no integration
+            buffer — and fires any merge-to-default side effect per task — so admission will reject
+            (400) unless confirmed with true (no effect for a non-default base). Accepted by the schema
+            today but currently has no runtime effect.
     PlanStartByUrl:
       type: object
       additionalProperties: false
       required:
         - url
+        - baseBranch
       properties:
         url:
           type: string
           description: A bare issue URL, when no `owner/repo#123` reference is supplied.
         baseBranch:
           type: string
+          minLength: 1
+          maxLength: 255
+          pattern: '\S'
           description: >-
-            Optional target branch the fleet branches off and opens every PR against, instead of the
-            repository's default branch. See `PlanStartByIssue.baseBranch`.
-    MessageResult:
-      type: object
-      description: The result of publishing a message / answering an escalation. Shape varies by message
-        name; `ok` is always present.
-      additionalProperties: true
-      required:
-        - ok
-      properties:
-        ok:
+            REQUIRED target branch the fleet branches off and opens every PR against. See
+            `PlanStartByIssue.baseBranch`.
+        allowSharedBase:
+          type: boolean
+          description: >-
+            Reserved for a later ADR 0003 admission slice — NOT yet enforced in this slice (B0).
+            Accepted by the schema today but currently has no runtime effect. When implemented it
+            will opt in to sharing a custom integration base branch with another already-active plan.
+            See `PlanStartByIssue.allowSharedBase`.
+        confirmDefaultBase:
           type: boolean
-    FeatureAnswerRequest:
-      description: "Answer an implementation-phase task escalation (issue #25). Supply the target by
-        EXACTLY ONE of `corrKey`, or the `plan`+`task` pair the delegate derives it from; `answer`
-        is always required. Modeled as `oneOf` named variants (Camunda REST v2 pattern) so a body
-        that supplies neither addressing form — or mixes them — is a 400 at the edge that names the
-        allowed shapes, instead of the delegate re-deriving the precedence by hand."
+          description: >-
+            Reserved for a later ADR 0003 admission slice — NOT yet enforced in this slice (B0).
+            Accepted by the schema today but currently has no runtime effect. When implemented it
+            will be the required acknowledgement when `baseBranch` names the repository default
+            branch. See `PlanStartByIssue.confirmDefaultBase`.
+    FeatureStart:
+      description: The start-feature request body — a SINGLE-issue feature run. Names the target issue
+        by EXACTLY ONE of `issue` (an `owner/repo#123` reference) or `url` (a bare issue URL), plus a
+        REQUIRED `baseBranch` (ADR 0003, same admission as the epic path), and the two optional
+        follow-on knobs `converge` / `autoMerge`. Modeled as `oneOf` named variants (Camunda REST v2
+        pattern) so an ambiguous or empty target is a 400 at the edge.
       oneOf:
-        - $ref: "#/components/schemas/FeatureAnswerByCorrKey"
-        - $ref: "#/components/schemas/FeatureAnswerByPlanTask"
-    FeatureAnswerByCorrKey:
+        - $ref: "#/components/schemas/FeatureStartByIssue"
+        - $ref: "#/components/schemas/FeatureStartByUrl"
+    FeatureStartByIssue:
       type: object
       additionalProperties: false
       required:
-        - corrKey
-        - answer
+        - issue
+        - baseBranch
       properties:
-        corrKey:
+        issue:
           type: string
-          description: The task correlation key, `<plan_key>:<task_id>` (e.g. owner/repo#12:task-3).
-        answer:
+          description: "Issue reference: owner/repo#123."
+        baseBranch:
           type: string
           minLength: 1
-          description: The operator's answer that resumes the parked implementation agent.
-    FeatureAnswerByPlanTask:
+          maxLength: 255
+          pattern: '\S'
+          description: >-
+            REQUIRED target branch the agent branches off and opens its PR against. Admitted through
+            the same ADR 0003 policy as the epic path (`admitPlan`): a missing `epic/*` base is
+            auto-created off default HEAD; a non-`epic/*` base must already exist; naming the default
+            branch requires `confirmDefaultBase`.
+        converge:
+          type: boolean
+          description: >-
+            When true, hand the opened PR to the convergence loop (review rounds) as a follow-on step.
+            When false (default) the run ends at "PR raised, not reviewed".
+        autoMerge:
+          type: boolean
+          description: >-
+            When true (and `converge` is true), drive the merge-loop after convergence — mirrors
+            `convergeOnly`/`NANO_PR_AUTO_MERGE` inverted. When false the run stops at `converged`.
+            Moot when `converge` is false.
+        confirmDefaultBase:
+          type: boolean
+          description: >-
+            Acknowledge that `baseBranch` is the repository default branch (the PR would target it
+            directly). See `PlanStartByIssue.confirmDefaultBase`.
+        allowSharedBase:
+          type: boolean
+          description: >-
+            Opt in to sharing a custom integration base branch with another already-active epic. See
+            `PlanStartByIssue.allowSharedBase`.
+    FeatureStartByUrl:
       type: object
       additionalProperties: false
       required:
-        - plan
-        - task
-        - answer
+        - url
+        - baseBranch
       properties:
-        plan:
-          type: string
-          description: Plan reference (owner/repo#N); combined with `task` to derive the corrKey.
-        task:
+        url:
           type: string
-          description: Task id within the plan; combined with `plan` to derive the corrKey.
-        answer:
+          description: A bare issue URL, when no `owner/repo#123` reference is supplied.
+        baseBranch:
           type: string
           minLength: 1
-          description: The operator's answer that resumes the parked implementation agent.
-    PlanAnswerRequest:
+          maxLength: 255
+          pattern: '\S'
+          description: >-
+            REQUIRED target branch the agent branches off and opens its PR against. See
+            `FeatureStartByIssue.baseBranch`.
+        converge:
+          type: boolean
+          description: When true, hand the opened PR to the convergence loop. See `FeatureStartByIssue.converge`.
+        autoMerge:
+          type: boolean
+          description: When true (with `converge`), drive the merge-loop. See `FeatureStartByIssue.autoMerge`.
+        confirmDefaultBase:
+          type: boolean
+          description: Acknowledge landing on the default branch. See `PlanStartByIssue.confirmDefaultBase`.
+        allowSharedBase:
+          type: boolean
+          description: Share a custom integration base with another active epic. See `PlanStartByIssue.allowSharedBase`.
+    MessageResult:
+      type: object
+      description: The result of publishing a message / answering an escalation. Shape varies by message
+        name; `ok` is always present.
+      additionalProperties: true
+      required:
+        - ok
+      properties:
+        ok:
+          type: boolean
+    AgentCompleteRequest:
       type: object
       additionalProperties: false
+      description: >-
+        Complete an escalation user task AS AN AGENT (epic #156 / ADR 0046). The agent submits the
+        SAME typed form variables a human would through the task inbox; the host routes them through
+        the one canonical attributed completer, records the agent's identity for the audit trail, and
+        resumes the process. Only the migrated escalation user tasks may be completed this way.
       required:
-        - plan
-        - directive
+        - userTaskKey
+        - agentId
+        - variables
       properties:
-        plan:
+        userTaskKey:
           type: string
-          description: Plan reference (owner/repo#N), also the message correlation key.
-        directive:
+          minLength: 1
+          description: The engine user-task key of the parked escalation task (from GET /tasks/api/tasks).
+        agentId:
           type: string
+          minLength: 1
+          description: The completing agent's identity (ADR 0046), recorded for attribution.
+        variables:
+          type: object
+          additionalProperties: true
           description: >-
-            One of `proceed` or `revise` (case-insensitive; normalized to lowercase and trimmed
-            server-side, see `parsePlanEscalationDirective`).
-            `proceed` dispatches the current unapproved plan as an explicit human override;
-            `revise` loops back to the planner with the note folded into planFindings and a fresh
-            review budget.
+            The typed form completion variables — the SAME shape a human submits (e.g.
+            `{ resolution, answer }`, `{ directive, notes }`, `{ action, notes }`, or `{ answer }`).
+    RevertCompletionRequest:
+      type: object
+      additionalProperties: false
+      description: >-
+        Revert/override an agent escalation completion (the reversibility guarantee of ADR 0046). A
+        human marks a reversible agent completion reverted so the agent's answer is no longer treated
+        as authoritative; the reverter's identity + timestamp are recorded.
+      required:
+        - completionId
+        - reverterId
+      properties:
+        completionId:
+          type: integer
+          description: The `task_completions` id returned when the agent completion was recorded.
+        reverterId:
+          type: string
+          minLength: 1
+          description: The human identity overriding the agent completion, recorded for the audit trail.
         note:
           type: string
-          description: Human guidance for the planner (used for `revise`; optional for `proceed`).
+          description: Optional corrective guidance from the human that overrides the agent's answer.
     BlackboardEntry:
       type: object
       additionalProperties: false
@@ -722,12 +846,43 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/ErrorBody"
+  /actions/start/feature:
+    post:
+      operationId: startFeature
+      summary: Register/refresh a feature-run aggregate (idempotent on featureKey) and start the single-issue run.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/FeatureStart"
+      responses:
+        "202":
+          description: The feature run was started (or was already running).
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/StartFeatureResult"
+        "400":
+          description: The issue reference could not be parsed, or the base branch was rejected.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorBody"
+        "409":
+          description: The base branch is already in use by another active epic.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorBody"
   /actions/message:
     post:
       operationId: postMessage
-      summary: Publish a message / answer an escalation. For escalation-answered,
-        feature-escalation-answered, and plan-escalation-answered names, runs the corresponding
-        answer flow; otherwise a plain publishMessage.
+      summary: "Publish a message / answer an escalation. For the merge-loop `escalation-answered`
+        name, runs the merge-loop escalation answer flow; otherwise a plain publishMessage. The
+        epic #156 escalation
+        kinds (task, plan-review, trial-merge, PR review-loop) are native user tasks answered via
+        the task inbox (POST /tasks/api/complete), not this route."
       requestBody:
         required: true
         content:
@@ -750,13 +905,7 @@ paths:
                   properties:
                     answer:
                       type: string
-                    directive:
-                      type: string
-                      description: >-
-                        One of `proceed` or `revise` (case-insensitive; normalized to lowercase and
-                        trimmed server-side, see `parsePlanEscalationDirective`).
-                    note:
-                      type: string
+                      description: The operator's answer that resumes a parked merge-loop escalation.
       responses:
         "200":
           description: The message was published (or the escalation answered).
@@ -776,11 +925,13 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
-  /hooks/feature-answer:
+  /hooks/agent-complete:
     post:
-      operationId: answerFeatureEscalation
-      summary: "Answer an implementation-phase task escalation out of band (issue #25). Optional
-        shared-secret guard (x-hook-secret), enforced only when NANO_PR_WEBHOOK_SECRET is set."
+      operationId: agentCompleteEscalation
+      summary: "Complete an escalation user task as an agent assignee (ADR 0046). Reuses the same
+        `.form` contract + engine resume path a human uses; records the agent identity for
+        attribution. Optional shared-secret guard (x-hook-secret), enforced only when
+        NANO_PR_WEBHOOK_SECRET is set."
       security:
         - hookSecret: []
         - {}
@@ -789,16 +940,16 @@ paths:
         content:
           application/json:
             schema:
-              $ref: "#/components/schemas/FeatureAnswerRequest"
+              $ref: "#/components/schemas/AgentCompleteRequest"
       responses:
         "200":
-          description: The escalation was answered and the parked agent resumed.
+          description: The agent completed the escalation task and the process resumed.
           content:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
         "400":
-          description: A required field was missing (answer, or a resolvable correlation key).
+          description: A required field was missing (userTaskKey, agentId, variables), or the target is not an escalation task.
           content:
             application/json:
               schema:
@@ -810,16 +961,18 @@ paths:
               schema:
                 $ref: "#/components/schemas/MessageResult"
         "404":
-          description: No matching open task escalation for the correlation key.
+          description: No open escalation user task matches the userTaskKey.
           content:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
-  /hooks/plan-answer:
+  /hooks/revert-completion:
     post:
-      operationId: answerPlanEscalation
-      summary: "Answer a plan-review cap escalation out of band. Optional shared-secret guard
-        (x-hook-secret), enforced only when NANO_PR_WEBHOOK_SECRET is set."
+      operationId: revertEscalationCompletion
+      summary: "Revert/override an agent escalation completion (ADR 0046 reversibility). A human marks
+        a reversible agent completion reverted so the agent's answer is no longer authoritative.
+        Optional shared-secret guard (x-hook-secret), enforced only when NANO_PR_WEBHOOK_SECRET is
+        set."
       security:
         - hookSecret: []
         - {}
@@ -828,16 +981,16 @@ paths:
         content:
           application/json:
             schema:
-              $ref: "#/components/schemas/PlanAnswerRequest"
+              $ref: "#/components/schemas/RevertCompletionRequest"
       responses:
         "200":
-          description: The escalation was answered and the parked plan resumed.
+          description: The agent completion was reverted.
           content:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
         "400":
-          description: A required field was missing (plan or directive).
+          description: A required field was missing, or the completion is not reversible / already reverted.
           content:
             application/json:
               schema:
@@ -849,7 +1002,7 @@ paths:
               schema:
                 $ref: "#/components/schemas/MessageResult"
         "404":
-          description: No matching open plan escalation for the plan key.
+          description: No completion matches the completionId.
           content:
             application/json:
               schema:

package/operations/agentCompleteEscalation.ts

@@ -0,0 +1,53 @@
+// POST /app/api/hooks/agent-complete → operationId `agentCompleteEscalation` (epic #156, slice U6;
+// ADR 0046). Lets an AGENT assignee complete an escalation user task by submitting the SAME typed
+// form variables a human would through the task inbox. The completion routes through the one
+// canonical attributed completer (`completeEscalationAsAgent` → `completeUserTaskAttributed`), which
+// records the agent's identity in the `task_completions` ledger (for attribution) and then resumes
+// the process via `engine.completeUserTask` — the exact same resume path a human drives, no parallel
+// lane. Optional shared-secret guard (x-hook-secret), enforced only when NANO_PR_WEBHOOK_SECRET is
+// set, mirroring the other operator/webhook control surfaces.
+//
+// The runtime validates the body against openapi.yaml (`userTaskKey`, `agentId`, `variables` all
+// required); this delegate narrows the validated shape and applies the shared-secret guard.
+
+import { completeEscalationAsAgent } from "../app/agentCompletion.ts";
+import { envVar } from "../app/version.ts";
+import { defineOperation } from "../nano-generated/operations.ts";
+
+const WEBHOOK_SECRET = envVar("NANO_PR_WEBHOOK_SECRET") ?? "";
+
+const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
+
+export default defineOperation("agentCompleteEscalation", async ({ req, body }, app) => {
+  if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
+    app.log.warn("agent-complete rejected: missing/invalid shared secret");
+    return { status: 401, body: { ok: false, error: "unauthorized" } };
+  }
+  if (!body || typeof body !== "object") {
+    app.log.warn("agent-complete rejected: missing request body");
+    return { status: 400, body: { ok: false, error: "userTaskKey, agentId and variables are required" } };
+  }
+
+  const userTaskKey = str(body.userTaskKey);
+  const agentId = str(body.agentId);
+  const variables = body.variables;
+  if (!userTaskKey) return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
+  if (!agentId) return { status: 400, body: { ok: false, error: "agentId is required" } };
+  if (!variables || typeof variables !== "object" || Array.isArray(variables)) {
+    return { status: 400, body: { ok: false, error: "variables must be an object" } };
+  }
+
+  const r = await completeEscalationAsAgent(app.data, app.engine, {
+    userTaskKey,
+    agentId,
+    variables,
+  });
+  if (r.ok) {
+    app.log.info("agent completed escalation", { userTaskKey, agentId, elementId: r.elementId });
+    return { status: 200, body: { ok: true, completionId: r.completionId, elementId: r.elementId } };
+  }
+  // A non-escalation / missing-target is a client error; an unknown key is a 404.
+  const status = r.reason === "no open escalation task" ? 404 : 400;
+  app.log.warn("agent-complete: not completed", { userTaskKey, reason: r.reason });
+  return { status, body: { ok: false, error: r.reason } };
+});

package/operations/listActivePrs.test.ts

@@ -7,13 +7,24 @@ import type { AppApi } from "@nanobpm/urban";
 import { noopLog } from "../test/log.ts";
 import handler from "./listActivePrs.ts";
 
-function memApp(rows: any[]): AppApi {
-  const tbl = {
-    async all() {
-      return rows;
-    },
+function memApp(rows: any[], escalations: any[] = []): AppApi {
+  const table = (name: string) => {
+    if (name === "escalations") {
+      return {
+        async find(where: Record<string, unknown>) {
+          return escalations.filter((e) =>
+            Object.entries(where).every(([k, v]) => e[k] === v)
+          );
+        },
+      };
+    }
+    return {
+      async all() {
+        return rows;
+      },
+    };
   };
-  return { data: { table: () => tbl }, log: noopLog() } as any as AppApi;
+  return { data: { table }, log: noopLog() } as any as AppApi;
 }
 
 function input(headers: Record<string, string> = {}) {
@@ -46,6 +57,28 @@ test("returns 200 with a count + projected active PRs", async () => {
   assertEquals(r.body.prs[0].processKey, "9");
 });
 
+test("surfaces openEscalation for an escalated PR from its open escalations row (both loops)", async () => {
+  // Regression: a merge-loop escalation parks on a message catch (no user task), so deriving
+  // openEscalation from a user-task probe hid it. Deriving from the canonical `escalations` row
+  // surfaces it. Two escalated PRs — one with an open row (visible), one already answered (null).
+  const app = memApp(
+    [
+      { pr_key: "o/r#10", repo: "o/r", number: 10, url: "u10", title: "merge blocked", status: "escalated", current_round: 3, process_key: "m1", updated_at: "2026-02-02" },
+      { pr_key: "o/r#11", repo: "o/r", number: 11, url: "u11", title: "answered", status: "escalated", current_round: 4, process_key: "m2", updated_at: "2026-02-01" },
+    ],
+    [
+      { id: 1, pr_key: "o/r#10", status: "open", question: "Resolve the conflict on the branch, then retry?" },
+      { id: 2, pr_key: "o/r#11", status: "answered", question: "old question" },
+    ],
+  );
+  const res = (await handler(input(), app)) as any;
+  assertEquals(res.status, 200);
+  const p10 = res.body.prs.find((p: any) => p.prKey === "o/r#10");
+  const p11 = res.body.prs.find((p: any) => p.prKey === "o/r#11");
+  assertEquals(p10.openEscalation, "Resolve the conflict on the branch, then retry?");
+  assertEquals(p11.openEscalation, null);
+});
+
 test("shared-secret guard rejects a missing secret when configured", async () => {
   const prev = process.env["NANO_PR_WEBHOOK_SECRET"];
   process.env["NANO_PR_WEBHOOK_SECRET"] = "s3cr3t";

package/operations/postMessage.ts

@@ -1,21 +1,18 @@
 // POST /app/api/actions/message → operationId `postMessage` (ADR 0058, base /app/api).
 // Replaces the hand-rolled action that overrode the generic publishMessage action. For the
-// `escalation-answered` message we run the review answer flow, for `feature-escalation-answered`
-// (issue #25) the implementation-phase (per-task) answer flow, and for
-// `plan-escalation-answered` the plan-review cap answer flow. Any other message falls back to a
-// plain publishMessage.
+// merge-loop `escalation-answered` message we run the merge-loop escalation answer flow; any other
+// message falls back to a plain publishMessage.
+//
+// The four #156 escalation kinds (task, plan-review, trial-merge, PR review-loop) are now native
+// `userTask`s answered directly through the task inbox (`POST /tasks/api/complete`), so this
+// delegate no longer carries their bespoke `feature-escalation-answered` / `plan-escalation-answered`
+// discriminators. The merge-loop escalation is still a durable message catch (out of scope for
+// #156), so its `escalation-answered` branch is kept.
 //
 // The runtime validates the body against openapi.yaml (`name` is required, so a missing name is a 400
 // for free); this delegate keeps the message-name dispatch — the discriminator + downstream behavior
 // is app logic, not something the JSON schema can express.
 
-import {
-  answerPlanEscalation,
-  answerTaskEscalation,
-  FEATURE_ESCALATION_MESSAGE,
-  PLAN_ESCALATION_MESSAGE,
-  parsePlanEscalationDirective,
-} from "../app/plan.ts";
 import { answerEscalation } from "../app/service.ts";
 import { defineOperation } from "../nano-generated/operations.ts";
 
@@ -33,36 +30,8 @@ export default defineOperation("postMessage", async ({ body }, app) => {
     if (!prKey) return { status: 400, body: { error: "correlationKey is required" } };
     if (!answer) return { status: 400, body: { error: "answer is required" } };
     const r = await answerEscalation(app.data, app.engine, prKey, answer);
-    if (r.ok) app.log.info("review escalation answered", { name, prKey });
-    else app.log.warn("postMessage: no open review escalation to answer", { name, prKey });
-    return { status: r.ok ? 200 : 404, body: r };
-  }
-
-  if (name === FEATURE_ESCALATION_MESSAGE) {
-    // Implementation-phase task escalation (issue #25): correlationKey is the task's
-    // `<plan_key>:<task_id>`; record the answer, resume the parked child, and re-surface the next
-    // open escalation.
-    const corrKey = String(b.correlationKey ?? "");
-    const answer = String(b.variables?.answer ?? "").trim();
-    if (!corrKey) return { status: 400, body: { error: "correlationKey is required" } };
-    if (!answer) return { status: 400, body: { error: "answer is required" } };
-    const r = await answerTaskEscalation(app.data, app.engine, corrKey, answer);
-    if (r.ok) app.log.info("feature escalation answered", { name, corrKey });
-    else app.log.warn("postMessage: no open feature escalation to answer", { name, corrKey });
-    return { status: r.ok ? 200 : 404, body: r };
-  }
-
-  if (name === PLAN_ESCALATION_MESSAGE) {
-    const planKey = String(b.correlationKey ?? "");
-    const directive = parsePlanEscalationDirective(b.variables?.directive ?? "revise");
-    const note = String(b.variables?.note ?? b.variables?.answer ?? "").trim();
-    if (!planKey) return { status: 400, body: { error: "correlationKey is required" } };
-    if (!directive) {
-      return { status: 400, body: { error: "directive must be proceed or revise" } };
-    }
-    const r = await answerPlanEscalation(app.data, app.engine, planKey, directive, note);
-    if (r.ok) app.log.info("plan escalation answered", { name, planKey, directive });
-    else app.log.warn("postMessage: no open plan escalation to answer", { name, planKey });
+    if (r.ok) app.log.info("merge-loop escalation answered", { name, prKey });
+    else app.log.warn("postMessage: no open merge-loop escalation to answer", { name, prKey });
     return { status: r.ok ? 200 : 404, body: r };
   }