@nanobpm/nano-workforce 0.99.1 → 0.101.0

package/e2e/feature-run.e2e.ts

@@ -23,7 +23,7 @@ import type { EngineJob } from "@nanobpm/urban/runtime";
 import { bootTestApp, type TestApp } from "@nanobpm/urban-testkit";
 import { admitGithubState, installAdmitGithub } from "./support/github-admit.ts";
 import { asEngineClient } from "./support/engine-client.ts";
-import { pollFeatureBlocked, pollFeatureEscalations } from "../app/service.ts";
+import { pollUserTasks } from "../app/service.ts";
 
 const APP_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -58,9 +58,6 @@ interface FeatureRow {
   status: string;
   pr_key: string | null;
   delivery_label: string | null;
-  escalation_question: string | null;
-  escalation_user_task_key: string | null;
-  blocked_user_task_key: string | null;
 }
 interface PrRow {
   pr_key: string;
@@ -191,18 +188,23 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
         const prs = await app.db.table<PrRow>("pull_requests", "pr_key").find({});
         assert.equal(prs.length, 0, "a blocked run never enrolled a PR into the convergence loop");
 
-        // The poller fills in the completable user-task key (which no service task can know — the task
-        // doesn't exist yet when record-feature runs) so the pages can drive an attributed acknowledge.
-        await pollFeatureBlocked(app.db, asEngineClient(app.engine));
-        const denorm = await featureRow(app, featureKey);
-        assert.ok(denorm.blocked_user_task_key, "the poller denormalised the completable blocked user-task key");
-        assert.equal(denorm.status, "awaiting_operator", "the run stays awaiting_operator while parked");
-
-        // Acknowledge through the app's OWN operation (the nwf UI's affordance) — the attributed
-        // completer resumes the SAME record-blocked-ack path a human would from the task inbox, with NO
-        // out-of-band /v2/user-tasks/{key}/completion call.
-        const acked = await app.api?.call("acknowledgeBlocked", {
-          body: { userTaskKey: denorm.blocked_user_task_key, note: "reassigned to a human" },
+        // The escalation state now lives on the native user task + the Tasks inbox `user_tasks`
+        // read-model (issue #332 dropped the denormalised `feature_runs.blocked_user_task_key` pointer),
+        // so `pollUserTasks` projects the parked `feature-blocked` task onto `user_tasks` by reading the
+        // engine directly — no per-run column write.
+        await pollUserTasks(app.db, asEngineClient(app.engine));
+        const inboxRow = await app.db
+          .table<{ user_task_key: string; element_id: string }>("user_tasks", "user_task_key")
+          .findOne({ user_task_key: task!.userTaskKey });
+        assert.ok(inboxRow, "the poller projected the blocked task onto the Tasks inbox read-model");
+        assert.equal(inboxRow!.element_id, "feature-blocked", "the projected row is a feature-blocked task");
+        assert.equal(parked.status, "awaiting_operator", "the run stays awaiting_operator while parked");
+
+        // Acknowledge through the ONE canonical `complete-user-task` door (issue #332 retired the bespoke
+        // `acknowledge-blocked` operation) — the attributed human completer resumes the SAME
+        // record-blocked-ack path from the task inbox, with NO out-of-band completion call.
+        const acked = await app.api?.call("completeUserTask", {
+          body: { userTaskKey: task!.userTaskKey, variables: { note: "reassigned to a human" } },
         });
         assert.equal(acked?.status, 200, "the operator acknowledgement completed the blocked task");
         await app.settle();
@@ -212,10 +214,10 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
         const settled = await featureRow(app, featureKey);
         assert.equal(settled.status, "blocked", "the acknowledged run settles at terminal blocked");
         assert.equal(settled.delivery_label, "operator: reassigned to a human", "the operator note is recorded");
-        assert.equal(settled.blocked_user_task_key, null, "the completable-task pointer was cleared on ack");
 
-        // A further poll pass is an idempotent no-op — a terminal run is not a candidate.
-        await pollFeatureBlocked(app.db, asEngineClient(app.engine));
+        // A further poll pass is an idempotent no-op — the task is completed, so the read-model row is
+        // reconciled away and a terminal run is not a candidate.
+        await pollUserTasks(app.db, asEngineClient(app.engine));
         assert.equal((await featureRow(app, featureKey)).status, "blocked");
       },
     );
@@ -276,7 +278,7 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
     );
   });
 
-  test("escalate → the poller surfaces it on the read model, and the operator answer resolves it (issue #210)", async () => {
+  test("escalate → the poller surfaces it on the Tasks inbox, and the operator answer resolves it (issue #210/#332)", async () => {
     let calls = 0;
     await withApp(
       {
@@ -288,25 +290,32 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
         },
       },
       { baseBranch: "epic/e2e" },
-      async ({ app, featureKey }) => {
+      async ({ app, featureKey, processKey }) => {
         // The `record-feature-escalation` service task runs on the escalated arm (before the user task),
-        // so the row already carries the flipped status + the agent's question when the run parks — the
-        // read model the pages read is no longer blind to the native user-task wait (the #210 bug).
+        // so the row already carries the flipped status when the run parks, and the agent's question is
+        // recorded in the `feature_escalations` audit log the poller reads (issue #332 dropped the
+        // denormalised `feature_runs.escalation_question` column).
         const parked = await featureRow(app, featureKey);
         assert.equal(parked.status, "escalated", "the escalated status is surfaced on the read model");
-        assert.equal(parked.escalation_question, "Which API should I use?", "the agent's question is surfaced");
-
-        // The poller fills in the completable user-task key (which the service task can't know — the
-        // task doesn't exist yet when it runs) so the UI can drive an attributed answer.
-        await pollFeatureEscalations(app.db, asEngineClient(app.engine));
-        const escalated = await featureRow(app, featureKey);
-        assert.ok(escalated.escalation_user_task_key, "the poller denormalised the completable user-task key");
-        assert.equal(escalated.status, "escalated", "the run stays escalated while parked");
-
-        // Answer through the app's OWN operation (the nwf UI's answer affordance) — the attributed
-        // completer resumes the SAME implement task a human would from the task inbox.
-        const answered = await app.api?.call("answerFeatureEscalation", {
-          body: { userTaskKey: escalated.escalation_user_task_key, resolution: "answer", answer: "use v2" },
+
+        const tasks = await app.engine.searchUserTasks({ processInstanceKey: processKey });
+        const task = tasks.find((t) => t.elementId === "feature-escalation") as InboxTask | undefined;
+        assert.ok(task?.userTaskKey, "the feature escalation parked a completable native user task");
+
+        // The poller projects the parked task onto the Tasks inbox `user_tasks` read-model by reading
+        // the engine directly, sourcing the question from the `feature_escalations` audit log.
+        await pollUserTasks(app.db, asEngineClient(app.engine));
+        const inboxRow = await app.db
+          .table<{ user_task_key: string; element_id: string; question: string | null }>("user_tasks", "user_task_key")
+          .findOne({ user_task_key: task!.userTaskKey });
+        assert.ok(inboxRow, "the poller projected the escalation onto the Tasks inbox read-model");
+        assert.equal(inboxRow!.question, "Which API should I use?", "the agent's question is surfaced from the audit log");
+
+        // Answer through the ONE canonical `complete-user-task` door (issue #332 retired the bespoke
+        // `answer-escalation` operation) — the attributed human completer resumes the SAME implement task
+        // a human would from the task inbox.
+        const answered = await app.api?.call("completeUserTask", {
+          body: { userTaskKey: task!.userTaskKey, variables: { resolution: "answer", answer: "use v2" } },
         });
         assert.equal(answered?.status, 200, "the operator answer completed the escalation task");
         await app.settle();
@@ -318,14 +327,16 @@ describe("single-issue feature run (#172 — feature.bpmn)", () => {
         );
         assert.equal(calls, 2, "the implementation agent was re-dispatched exactly once after the answer");
 
-        // The run opened its PR; the escalation pointer + question were cleared once resolved.
+        // The run opened its PR.
         const settled = await featureRow(app, featureKey);
         assert.equal(settled.status, "opened", "the resumed run opened its PR");
-        assert.equal(settled.escalation_user_task_key, null, "the escalation pointer was cleared once resolved");
-        assert.equal(settled.escalation_question, null, "the surfaced question was cleared once resolved");
 
-        // A further poll pass is an idempotent no-op — a terminal run is not a candidate.
-        await pollFeatureEscalations(app.db, asEngineClient(app.engine));
+        // A further poll pass reconciles the completed task's read-model row away.
+        await pollUserTasks(app.db, asEngineClient(app.engine));
+        const gone = await app.db
+          .table<{ user_task_key: string }>("user_tasks", "user_task_key")
+          .findOne({ user_task_key: task!.userTaskKey });
+        assert.equal(gone, undefined, "the completed escalation's inbox row was reconciled away");
         assert.equal((await featureRow(app, featureKey)).status, "opened");
       },
     );

package/e2e/retire-escalation-subsystem.e2e.ts

@@ -155,6 +155,32 @@ describe("retire escalation subsystem (U7 — destructive contract phase)", () =
     }
   });
 
+  test("issue #332 contract phase: feature_runs escalation columns + bespoke feature doors are gone", async () => {
+    // The destructive contract phase of #305 dropped the denormalised feature-run escalation surface now
+    // that escalation state lives on the native `user_tasks` inbox + the `feature_escalations` audit log.
+    const featureCols = await columnNames(app, "feature_runs");
+    assert.ok(featureCols.length > 0, "feature_runs table still exists");
+    for (const dropped of [
+      "escalation_question",
+      "escalation_user_task_key",
+      "blocked_user_task_key",
+      "escalation_open",
+    ]) {
+      assert.ok(!featureCols.includes(dropped), `feature_runs.${dropped} column dropped (#332)`);
+    }
+
+    // The bespoke feature-run answer doors are gone — the ONE canonical `/actions/complete-user-task`
+    // door now completes `feature-escalation` / `feature-blocked` alongside the epic/PR kinds.
+    for (const path of ["/app/api/actions/answer-escalation", "/app/api/actions/acknowledge-blocked"]) {
+      const res = await app.callRoute({
+        method: "POST",
+        path,
+        body: JSON.stringify({ userTaskKey: "x" }),
+      });
+      assert.equal(res.status, 404, `retired feature door ${path} is unmounted (404)`);
+    }
+  });
+
   test("an escalation still round-trips via userTask + inbox with no denormalised pointer or dead form", async () => {
     const api = app.api;
     assert.ok(api, "the OpenAPI driver is available");

package/openapi.yaml

@@ -1908,69 +1908,17 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
-  /actions/answer-escalation:
-    post:
-      operationId: answerFeatureEscalation
-      summary: "Answer a native feature-run escalation (issue #210). Completes the parked
-        `feature-escalation` user task with the operator's typed form variables (resolution=answer/abandon
-        + guidance), driving the canonical attributed completer (completeUserTaskAttributed) — the same
-        resume path the task inbox uses, recording who answered. The poller then reconciles the run off
-        `escalated`. This is the nwf UI's answer affordance for a feature run parked on a human decision."
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              additionalProperties: false
-              required:
-                - userTaskKey
-                - resolution
-              properties:
-                userTaskKey:
-                  type: string
-                  minLength: 1
-                  description: The parked `feature-escalation` user-task key (feature_runs.escalation_user_task_key).
-                resolution:
-                  type: string
-                  enum: [answer, abandon]
-                  description: answer ⇒ re-dispatch the implement task with the guidance; abandon ⇒ give up on the task.
-                answer:
-                  type: string
-                  description: Guidance for the implementation agent. Required (non-blank) when resolution is answer.
-                operator:
-                  type: string
-                  description: Optional operator handle recorded in the attribution ledger; defaults to "operator".
-      responses:
-        "200":
-          description: The escalation user task was completed and the process resumed.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
-        "400":
-          description: A required field was missing/invalid, or the target is not an escalation task.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
-        "404":
-          description: No open escalation user task matches the userTaskKey.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
   /actions/complete-user-task:
     post:
       operationId: completeUserTask
       summary: "Complete an open native user-task escalation from the nwf Tasks inbox (issue #236).
         Submits the parked task's typed `.form` variables (e.g. a plan-review `{ directive, notes }`, a
-        trial-merge `{ action, notes }`, or a PR `{ answer }`) to the canonical human completer
-        (completeEscalationAsHuman → completeUserTaskAttributed) — the same resume path the task inbox
-        uses, recording who answered. The completer refuses any user task that is not one of the
-        migrated escalation elements. The feature-run kinds keep their own operations
-        (answer-escalation / acknowledge-blocked); this door is for the plan-review / trial-merge / PR
-        `wait-answer` kinds whose completion is a straight typed pass-through. On success the answered
+        trial-merge `{ action, notes }`, a PR `{ answer }`, a feature escalation `{ resolution, answer }`,
+        or a blocked-run `{ note }`) to the canonical human completer (completeEscalationAsHuman →
+        completeUserTaskAttributed) — the same resume path the task inbox uses, recording who answered.
+        The completer refuses any user task that is not one of the human-completable elements. Issue #332
+        retired the bespoke feature-run doors (answer-escalation / acknowledge-blocked) and folded
+        `feature-escalation` / `feature-blocked` onto this one canonical door. On success the answered
         task's read-model row is dropped so the Tasks grid stops offering a decision for it."
       requestBody:
         required: true
@@ -2013,61 +1961,12 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/MessageResult"
-  /actions/acknowledge-blocked:
-    post:
-      operationId: acknowledgeBlocked
-      summary: "Acknowledge a blocked native feature run (issue #220). Completes the parked
-        `feature-blocked` operator user task with the operator's optional disposition note, driving the
-        canonical attributed completer (completeUserTaskAttributed) — the same resume path the task inbox
-        uses, recording who acknowledged. Completing it fires pr.record-blocked-ack, settling the run to
-        the terminal `blocked` status with the note, and the poller reconciles the completable-task
-        pointer off the row. This is the nwf UI's completion affordance for a feature run parked as
-        blocked (the blocked twin of answer-escalation)."
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              type: object
-              additionalProperties: false
-              required:
-                - userTaskKey
-              properties:
-                userTaskKey:
-                  type: string
-                  minLength: 1
-                  description: The parked `feature-blocked` user-task key (feature_runs.blocked_user_task_key).
-                note:
-                  type: string
-                  description: Optional operator disposition note, recorded on the run (delivery_label). Blank ⇒ "acknowledged".
-                operator:
-                  type: string
-                  description: Optional operator handle recorded in the attribution ledger; defaults to "operator".
-      responses:
-        "200":
-          description: The blocked user task was completed and the process resumed.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
-        "400":
-          description: A required field was missing/invalid, or the target is not a blocked task.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
-        "404":
-          description: No open blocked user task matches the userTaskKey.
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/MessageResult"
   /actions/acknowledge-done:
     post:
       operationId: acknowledgeDone
       summary: "Tick off a TERMINAL feature run (issue #254 §5). Stamps `acknowledged_at` on the run so
         the gateway recomputes its `list_bucket` to 'history', dropping the finished run out of the
-        primary Active list into History. The Done twin of acknowledge-blocked, but a terminal run is
+        primary Active list into History. The Done twin of the blocked acknowledgement, but a terminal run is
         not parked at a user task, so this completes no user task and only writes the row. Keyed on the
         run's `feature_key`; idempotent-safe (re-acknowledging keeps it in History)."
       requestBody:

package/operations/agentCompleteEscalation.ts

@@ -46,8 +46,8 @@ export default defineOperation("agentCompleteEscalation", async ({ req, body },
     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;
+  // A non-completable / missing-target is a client error; an unknown key is a 404.
+  const status = r.reason === "no open completable task" ? 404 : 400;
   app.log.warn("agent-complete: not completed", { userTaskKey, reason: r.reason });
   return { status, body: { ok: false, error: r.reason } };
 });

package/operations/completeUserTask.test.ts

@@ -1,15 +1,17 @@
 // Tests for the POST /app/api/actions/complete-user-task operation `completeUserTask` (issue #236).
 // The nwf Tasks page's decision affordance for the plan-review / trial-merge / PR `wait-answer`
-// escalations: it routes the typed form variables through the canonical human completer
-// (completeEscalationAsHuman → completeUserTaskAttributed), resuming the process exactly as the task
-// inbox would, and drops the answered task's read-model row so the grid stops offering a decision.
+// escalations plus the feature kinds `feature-escalation` / `feature-blocked` (issue #332 folded the
+// bespoke feature doors onto this one canonical door): it routes the typed form variables through the
+// canonical human completer (completeEscalationAsHuman → completeUserTaskAttributed), resuming the
+// process exactly as the task inbox would, and drops the answered task's read-model row so the grid
+// stops offering a decision.
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import { noopLog } from "../test/log.ts";
 import handler from "./completeUserTask.ts";
 
-// biome-ignore lint/suspicious/noExplicitAny: in-memory doubles, mirrors acknowledgeBlocked.test.ts
+// biome-ignore lint/suspicious/noExplicitAny: in-memory doubles, mirrors sibling op tests
 function memApp(openTasks: { userTaskKey: string; elementId?: string }[]): {
   app: AppApi;
   // biome-ignore lint/suspicious/noExplicitAny: see above
@@ -49,6 +51,7 @@ function memApp(openTasks: { userTaskKey: string; elementId?: string }[]): {
     };
   }
   const engine = {
+    openUserTasks: async () => openTasks,
     searchUserTasks: async () => openTasks,
     completeUserTask: async (userTaskKey: string, variables: Record<string, unknown>) => {
       completed.push({ userTaskKey, variables });
@@ -106,14 +109,30 @@ test("complete-user-task: non-object variables are rejected 400", async () => {
   assertEquals(res.status, 400);
 });
 
-test("complete-user-task: an unknown key is a 404 (no open escalation task)", async () => {
+test("complete-user-task: an unknown key is a 404 (no open completable task)", async () => {
   const { app } = memApp([]);
   const res = await call(app, { userTaskKey: "ghost", variables: { answer: "x" } });
   assertEquals(res.status, 404);
 });
 
-test("complete-user-task: refuses a non-escalation user task (400)", async () => {
+test("complete-user-task: completes a feature-blocked acknowledgement with the typed note (issue #332)", async () => {
   const { app, completed } = memApp([{ userTaskKey: "ut-4", elementId: "feature-blocked" }]);
+  const res = await call(app, { userTaskKey: "ut-4", variables: { note: "reassigned" } });
+  assertEquals(res.status, 200);
+  assertEquals(res.body.elementId, "feature-blocked");
+  assertEquals(completed, [{ userTaskKey: "ut-4", variables: { note: "reassigned" } }]);
+});
+
+test("complete-user-task: completes a feature-escalation answer (issue #332)", async () => {
+  const { app, completed } = memApp([{ userTaskKey: "ut-6", elementId: "feature-escalation" }]);
+  const res = await call(app, { userTaskKey: "ut-6", variables: { resolution: "answer", answer: "use v2" } });
+  assertEquals(res.status, 200);
+  assertEquals(res.body.elementId, "feature-escalation");
+  assertEquals(completed, [{ userTaskKey: "ut-6", variables: { resolution: "answer", answer: "use v2" } }]);
+});
+
+test("complete-user-task: refuses a non-completable internal user task (400)", async () => {
+  const { app, completed } = memApp([{ userTaskKey: "ut-4", elementId: "some-internal-task" }]);
   const res = await call(app, { userTaskKey: "ut-4", variables: { note: "x" } });
   assertEquals(res.status, 400);
   assertEquals(completed, []);

package/operations/completeUserTask.ts

@@ -1,19 +1,21 @@
 // POST /app/api/actions/complete-user-task → operationId `completeUserTask` (issue #236).
 //
-// The nwf **Tasks** page's decision affordance for the epic/PR native escalations that had no
-// app-side completion path — `plan-review-decision`, `trial-merge-decision`, and the PR review-loop
-// `wait-answer`. An operator submits the parked task's typed `.form` variables (e.g. a plan-review
-// `{ directive, notes }`, a trial-merge `{ action, notes }`, or a PR `{ answer }`) directly from the
-// Tasks inbox instead of only from Urban's read-only task-inbox stub.
+// The nwf **Tasks** page's decision affordance for the native user-task escalations that had no
+// app-side completion path — `plan-review-decision`, `trial-merge-decision`, the PR review-loop
+// `wait-answer`, the feature escalation `feature-escalation`, and the human-only `feature-blocked`
+// acknowledgement. An operator submits the parked task's typed `.form` variables (e.g. a plan-review
+// `{ directive, notes }`, a trial-merge `{ action, notes }`, a PR `{ answer }`, a feature escalation
+// `{ resolution, answer }`, or a blocked-run `{ note }`) directly from the Tasks inbox instead of only
+// from Urban's read-only task-inbox stub.
 //
 // It routes through the ONE canonical human completer (`completeEscalationAsHuman` →
 // `completeUserTaskAttributed`), so the completion uses the exact same typed variables and engine
 // resume path a human drives from the task inbox — no parallel completion — while recording WHO
 // answered in the `task_completions` ledger. That completer refuses any user task that is not one of
-// the migrated escalation elements (`ESCALATION_TASK_ELEMENTS`), so this generic door can never
-// complete an arbitrary internal user task. The feature-run kinds keep their own reconcile-bearing
-// operations (`answer-escalation` / `acknowledge-blocked`); this door is for the escalation kinds
-// whose completion is a straight typed pass-through.
+// the human-completable elements (`HUMAN_COMPLETABLE_ELEMENTS`), so this generic door can never
+// complete an arbitrary internal user task. Issue #332 retired the bespoke feature-run reconcile doors
+// (`answer-escalation` / `acknowledge-blocked`) and folded `feature-escalation` / `feature-blocked`
+// onto this one canonical door.
 //
 // On success it removes the answered task's `user_tasks` read-model row so the Tasks grid stops
 // offering a decision for a task that is now completed, without waiting a poll cycle; the poller
@@ -66,7 +68,7 @@ export default defineOperation("completeUserTask", async ({ body }, app) => {
     app.log.info("operator completed user task", { userTaskKey, elementId: r.elementId });
     return { status: 200, body: { ok: true, completionId: r.completionId, elementId: r.elementId } };
   }
-  const status = r.reason === "no open escalation task" ? 404 : 400;
+  const status = r.reason === "no open completable task" ? 404 : 400;
   app.log.warn("complete-user-task: not completed", { userTaskKey, reason: r.reason });
   return { status, body: { ok: false, error: r.reason } };
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.99.1",
+  "version": "0.101.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@nanobpm/agentic": "^0.1.0",
-    "@nanobpm/urban": "^0.61.0"
+    "@nanobpm/urban": "^0.68.1"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",

package/pages/feature.page.json

@@ -126,24 +126,6 @@
           { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
-          {
-            "label": "Abandon",
-            "confirm": "Abandon this escalated task? The run gives up on it (no PR).",
-            "showWhenField": "escalation_open",
-            "action": {
-              "path": "/app/api/actions/answer-escalation",
-              "body": { "userTaskKey": "{{row.escalation_user_task_key}}", "resolution": "abandon" }
-            }
-          },
-          {
-            "label": "Acknowledge blocked",
-            "confirm": "Acknowledge this blocked run? It settles to terminal blocked (the agent could not open a PR).",
-            "showWhenField": "blocked_user_task_key",
-            "action": {
-              "path": "/app/api/actions/acknowledge-blocked",
-              "body": { "userTaskKey": "{{row.blocked_user_task_key}}" }
-            }
-          },
           {
             "label": "Dismiss",
             "confirm": "Tick off this finished run? It acknowledges the run as done and files it under History.",
@@ -156,28 +138,10 @@
         ],
         "detail": {
           "fields": [
-            { "field": "escalation_question", "label": "Escalation question" },
             { "field": "base_branch", "label": "Base branch" },
             { "field": "outcome", "label": "Outcome" },
             { "field": "delivery_label", "label": "Delivery" }
-          ],
-          "form": {
-            "showWhenField": "escalation_open",
-            "title": "Answer escalation",
-            "promptField": "escalation_question",
-            "inputKey": "answer",
-            "inputLabel": "Guidance for the implementation agent",
-            "submitLabel": "Answer & re-dispatch",
-            "action": {
-              "path": "/app/api/actions/answer-escalation",
-              "successLabel": "Answered — the agent will resume",
-              "body": {
-                "userTaskKey": "{{row.escalation_user_task_key}}",
-                "resolution": "answer",
-                "answer": "{{form.answer}}"
-              }
-            }
-          }
+          ]
         }
       }
     }

package/pages/overview.page.json

@@ -165,48 +165,10 @@
           { "field": "delivery_label", "header": "Delivery" },
           { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
-        "rowActions": [
-          {
-            "label": "Abandon",
-            "confirm": "Abandon this escalated task? The run gives up on it (no PR).",
-            "showWhenField": "escalation_open",
-            "action": {
-              "path": "/app/api/actions/answer-escalation",
-              "body": { "userTaskKey": "{{row.escalation_user_task_key}}", "resolution": "abandon" }
-            }
-          },
-          {
-            "label": "Acknowledge blocked",
-            "confirm": "Acknowledge this blocked run? It settles to terminal blocked (the agent could not open a PR).",
-            "showWhenField": "blocked_user_task_key",
-            "action": {
-              "path": "/app/api/actions/acknowledge-blocked",
-              "body": { "userTaskKey": "{{row.blocked_user_task_key}}" }
-            }
-          }
-        ],
         "detail": {
           "fields": [
-            { "field": "escalation_question", "label": "Escalation question" },
             { "field": "outcome", "label": "Outcome" }
-          ],
-          "form": {
-            "showWhenField": "escalation_open",
-            "title": "Answer escalation",
-            "promptField": "escalation_question",
-            "inputKey": "answer",
-            "inputLabel": "Guidance for the implementation agent",
-            "submitLabel": "Answer & re-dispatch",
-            "action": {
-              "path": "/app/api/actions/answer-escalation",
-              "successLabel": "Answered — the agent will resume",
-              "body": {
-                "userTaskKey": "{{row.escalation_user_task_key}}",
-                "resolution": "answer",
-                "answer": "{{form.answer}}"
-              }
-            }
-          }
+          ]
         }
       }
     }