@nanobpm/nano-workforce 0.57.0 → 0.58.0

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 };
   }
 

package/operations/revertEscalationCompletion.ts

@@ -0,0 +1,44 @@
+// POST /app/api/hooks/revert-completion → operationId `revertEscalationCompletion` (epic #156, slice
+// U6; ADR 0046 reversibility). A completed user task cannot be un-completed in the engine, so an
+// AGENT answer is never a silent irreversible commit: this endpoint lets a human mark a reversible
+// agent completion reverted/overridden, recording who did it and when. Host-side consumers read the
+// `task_completions` ledger to see whether the latest completion is still authoritative. Human
+// completions are not reversible (they are already the authority), and a completion can be reverted
+// only once. Optional shared-secret guard (x-hook-secret), enforced only when NANO_PR_WEBHOOK_SECRET
+// is set.
+
+import { revertAgentCompletion } 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("revertEscalationCompletion", async ({ req, body }, app) => {
+  if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
+    app.log.warn("revert-completion rejected: missing/invalid shared secret");
+    return { status: 401, body: { ok: false, error: "unauthorized" } };
+  }
+  if (!body || typeof body !== "object") {
+    app.log.warn("revert-completion rejected: missing request body");
+    return { status: 400, body: { ok: false, error: "completionId and reverterId are required" } };
+  }
+
+  const completionId = typeof body.completionId === "number" ? body.completionId : Number.NaN;
+  const reverterId = str(body.reverterId);
+  const note = str(body.note);
+  if (!Number.isInteger(completionId)) {
+    return { status: 400, body: { ok: false, error: "completionId must be an integer" } };
+  }
+  if (!reverterId) return { status: 400, body: { ok: false, error: "reverterId is required" } };
+
+  const r = await revertAgentCompletion(app.data, completionId, { kind: "human", id: reverterId }, note);
+  if (r.ok) {
+    app.log.info("agent completion reverted", { completionId, reverterId });
+    return { status: 200, body: { ok: true, completionId: r.completionId } };
+  }
+  const status = r.reason === "no such completion" ? 404 : 400;
+  app.log.warn("revert-completion: not reverted", { completionId, reason: r.reason });
+  return { status, body: { ok: false, error: r.reason } };
+});

package/operations/startAndMessage.test.ts

@@ -222,61 +222,3 @@ test("postMessage → 400 when escalation-answered lacks a correlationKey", asyn
   assertEquals(r.status, 400);
   assertEquals(r.body.error, "correlationKey is required");
 });
-
-function planEscalationMessageApp() {
-  const plans = [{ plan_key: "owner/repo#12", open_plan_escalation_id: 1 }];
-  const escalations = [{
-    id: 1,
-    plan_key: "owner/repo#12",
-    epoch: 0,
-    round: 2,
-    findings: "needs guidance",
-    status: "open",
-    directive: null,
-    note: null,
-  }];
-  const published: any[] = [];
-  const match = (r: Record<string, unknown>, q: Record<string, unknown>) =>
-    Object.entries(q).every(([f, v]) => r[f] === v);
-  const table = (rows: any[], key: string) => ({
-    find: (q: any) => Promise.resolve(rows.filter((r) => match(r, q))),
-    update: (id: any, patch: any) => {
-      const row = rows.find((r) => r[key] === id);
-      if (row) Object.assign(row, patch);
-      return Promise.resolve(row);
-    },
-  });
-  return {
-    app: {
-      data: {
-        table(name: string) {
-          return name === "plans" ? table(plans, "plan_key") : table(escalations, "id");
-        },
-      },
-      engine: {
-        publishMessage: (m: any) => {
-          published.push(m);
-          return Promise.resolve();
-        },
-      },
-      log: noopLog(),
-    } as any as AppApi,
-    escalations,
-    published,
-  };
-}
-
-test("postMessage accepts mixed-case plan escalation directive like the dedicated hook", async () => {
-  const { app: msgApp, escalations, published } = planEscalationMessageApp();
-  const res = await postMessage(input({
-    name: "plan-escalation-answered",
-    correlationKey: "owner/repo#12",
-    variables: { directive: "PrOcEeD", note: "ship it" },
-  }), msgApp);
-  const r = res as any;
-  assertEquals(r.status, 200);
-  assertEquals(r.body.ok, true);
-  assertEquals(r.body.directive, "proceed");
-  assertEquals(escalations[0].directive, "proceed");
-  assertEquals(published[0].variables.planEscalationDirective, "proceed");
-});

package/operations/startFeature.ts

@@ -0,0 +1,127 @@
+// POST /app/api/actions/start/feature → operationId `startFeature` (ADR 0058/0059, base /app/api).
+// The ONE door for starting a SINGLE-issue feature run — the "missing middle" between Epics
+// (startPlanFanout) and PR convergence (startConvergenceLoop): hand one issue to a single
+// implementation agent that raises exactly one PR, then OPTIONALLY converge + merge (issue #172).
+//
+// The request body is FLAT (`{ issue | url, baseBranch, converge?, autoMerge? }`), not wrapped in a
+// `variables` envelope — a purpose-built operation, not a generic engine "start process" call. The
+// body is a `oneOf` — EXACTLY ONE of `issue` or `url` — so an empty or ambiguous target is a 400 at
+// the edge; this delegate narrows the validated variant and keeps the issue-FORMAT parse guard.
+//
+// Base-branch handling is IDENTICAL to the epic path: it reuses `admitPlan` (ADR 0003) verbatim, so
+// a feature run's PR is admitted through the same required+explicit / create-if-missing /
+// confirm-default / shared-base rules, with the same typed-error → HTTP mapping.
+
+import { startFeature } from "../app/feature.ts";
+import { BaseBranchMustExistError } from "../app/github.ts";
+import {
+  admitPlan,
+  DefaultBaseNotConfirmedError,
+  InvalidBaseBranchError,
+  MissingBaseBranchError,
+  parseIssue,
+  SharedBaseError,
+} from "../app/plan.ts";
+import { defineOperation } from "../nano-generated/operations.ts";
+
+export default defineOperation("startFeature", async ({ body }, app) => {
+  // The runtime validates a well-formed body against openapi.yaml, but a directly-invoked delegate
+  // (or a missing body) leaves `body` undefined — guard so that becomes a 400, not a 500 from `in`.
+  if (!body || typeof body !== "object") {
+    app.log.warn("start-feature rejected: missing request body");
+    return { status: 400, body: { error: "request body is required (owner/repo#123 or an issue URL)" } };
+  }
+  // The `oneOf` variant is normally narrowed by OpenAPI validation, but a directly-invoked delegate
+  // can pass a missing/mistyped `issue`/`url` — guard so that stays a 400, not a 500 from `.trim()`.
+  const target = "issue" in body ? body.issue : "url" in body ? body.url : undefined;
+  if (typeof target !== "string") {
+    app.log.warn("start-feature rejected: issue/url must be a string");
+    return { status: 400, body: { error: "issue or url must be a string (owner/repo#123 or an issue URL)" } };
+  }
+  const raw = target.trim();
+  const parsed = parseIssue(raw);
+  if (!parsed) {
+    app.log.warn("start-feature rejected: unparseable issue reference", { raw });
+    return { status: 400, body: { error: "could not parse issue (use owner/repo#123 or an issue URL)" } };
+  }
+  // Base branch (ADR 0003): admit the launch through the same fail-fast `admitPlan` gate the epic
+  // path uses BEFORE starting the run. A feature run also raises a PR against a base, so it honors
+  // the identical admission policy and error → HTTP mapping.
+  const rawBase = "baseBranch" in body && typeof body.baseBranch === "string" ? body.baseBranch : null;
+  const allowSharedBase = "allowSharedBase" in body && body.allowSharedBase === true;
+  const confirmDefaultBase = "confirmDefaultBase" in body && body.confirmDefaultBase === true;
+  const token = process.env.GITHUB_TOKEN ?? "";
+  let normalizedBase: string;
+  try {
+    // No `selfPlanKey`: a feature run creates a `feature_runs` row, NOT a `plans` row, so there is no
+    // own plan to exclude from the shared-base guard (rule 4). Passing `parsed.planKey` here would
+    // exclude an ACTIVE EPIC sharing the same `owner/repo#N` key, silently bypassing shared-base
+    // protection. Feature-run idempotency is enforced separately by `startFeature` on `feature_runs`.
+    normalizedBase = await admitPlan(app.data, parsed.repo, rawBase, token, {
+      allowSharedBase,
+      confirmDefaultBase,
+    });
+  } catch (err) {
+    if (err instanceof MissingBaseBranchError) {
+      app.log.warn("start-feature rejected: missing base branch");
+      return {
+        status: 400,
+        body: { error: "baseBranch is required (name the branch the PR targets, e.g. main or epic/agent-protocol)" },
+      };
+    }
+    if (err instanceof InvalidBaseBranchError) {
+      app.log.warn("start-feature rejected: invalid base branch", { baseBranch: err.value });
+      return {
+        status: 400,
+        body: { error: "invalid baseBranch (must be a plausible git branch name, e.g. main)" },
+      };
+    }
+    if (err instanceof BaseBranchMustExistError) {
+      app.log.warn("start-feature rejected: base branch does not exist", { baseBranch: err.branch });
+      return {
+        status: 400,
+        body: {
+          error:
+            `baseBranch "${err.branch}" does not exist and is not an epic/* branch, so it is not ` +
+            `auto-created — create it first, or use the epic/* convention`,
+        },
+      };
+    }
+    if (err instanceof DefaultBaseNotConfirmedError) {
+      app.log.warn("start-feature rejected: default base not confirmed", { baseBranch: err.branch });
+      return {
+        status: 400,
+        body: {
+          error:
+            `baseBranch "${err.branch}" is the repository default branch — the PR would target it ` +
+            `directly. Re-submit with confirmDefaultBase: true to proceed`,
+        },
+      };
+    }
+    if (err instanceof SharedBaseError) {
+      app.log.warn("start-feature rejected: shared base branch", { baseBranch: err.branch });
+      return {
+        status: 409,
+        body: {
+          error:
+            `baseBranch "${err.branch}" is already in use by another active epic. Re-submit with ` +
+            `allowSharedBase: true to stack on it, or name a distinct branch`,
+        },
+      };
+    }
+    throw err;
+  }
+  const converge = "converge" in body && body.converge === true;
+  // Auto-merge is only meaningful as a follow-on to convergence; pin it off when converge is off so
+  // the persisted row and the process variable can't disagree.
+  const autoMerge = converge && "autoMerge" in body && body.autoMerge === true;
+  const result = await startFeature(app.data, app.engine, parsed, normalizedBase, converge, autoMerge);
+  app.log.info("feature run started", {
+    featureKey: parsed.planKey,
+    requestedBaseBranch: normalizedBase,
+    converge,
+    autoMerge,
+    alreadyRunning: "alreadyRunning" in result && result.alreadyRunning === true,
+  });
+  return { status: 202, body: result };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.57.0",
+  "version": "0.58.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",
@@ -35,12 +35,15 @@
     "typecheck": "tsc --noEmit",
     "pretypecheck": "urban gen",
     "check:prompts": "node --experimental-strip-types scripts/check-agent-prompts.ts",
+    "check:migrations": "node --experimental-strip-types scripts/check-migrations.ts",
     "gen": "urban gen",
     "gen:check": "urban gen --check",
     "layout": "node --experimental-strip-types scripts/layout-bpmn.ts",
     "layout:check": "node --experimental-strip-types scripts/layout-bpmn.ts --check",
     "dev": "urban dev",
+    "pretest": "urban gen",
     "test": "node --experimental-strip-types --test",
+    "pree2e": "urban gen",
     "e2e": "node --experimental-strip-types --test \"e2e/**/*.e2e.ts\"",
     "lint": "biome check app operations workers pages components scripts e2e main.ts",
     "lint:fix": "biome check --write app operations workers pages components scripts e2e main.ts"

package/pages/cockpit.page.json

@@ -11,6 +11,7 @@
         "items": [
           { "label": "Convergence", "page": "home" },
           { "label": "Epics", "page": "epic" },
+          { "label": "Feature", "page": "feature" },
           { "label": "Cockpit", "page": "cockpit" }
         ],
         "sticky": true

package/pages/epic-detail.page.json

@@ -12,6 +12,7 @@
         "items": [
           { "label": "Convergence", "page": "home" },
           { "label": "Epics", "page": "epic" },
+          { "label": "Feature", "page": "feature" },
           { "label": "Cockpit", "page": "cockpit" }
         ]
       }
@@ -29,6 +30,14 @@
         "variant": "sub"
       }
     },
+    {
+      "type": "text",
+      "id": "escalations-pointer",
+      "props": {
+        "text": "Escalations (task, plan-review, trial-merge) are native user tasks — answer them from the Task inbox at /tasks: list the open tasks, pick the one for this epic, and submit the typed decision. There is no separate answer form on this page.",
+        "variant": "sub"
+      }
+    },
     {
       "type": "dataGrid",
       "id": "epic-plan",
@@ -48,51 +57,16 @@
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
           { "field": "wave_label", "header": "Wave" },
           { "field": "task_count", "header": "Tasks" },
-          { "field": "open_task_id", "header": "Open escalation" },
-          { "field": "open_plan_round", "header": "Plan escalation round" },
           { "field": "updated_at", "header": "Updated" }
         ],
-        "rowActions": [
-          {
-            "label": "Proceed with plan",
-            "confirm": "Dispatch the current unapproved plan as a human override?",
-            "showWhenField": "open_plan_escalation_id",
-            "action": {
-              "path": "/app/api/actions/message",
-              "body": {
-                "name": "plan-escalation-answered",
-                "correlationKey": "{{row.plan_key}}",
-                "variables": { "directive": "proceed", "note": "Proceed override from the epic page." }
-              }
-            }
-          }
-        ],
         "detail": {
           "linkField": "issue_url",
           "fields": [
             { "field": "repo", "label": "Repository" },
             { "field": "issue_number", "label": "Issue number" },
             { "field": "base_branch", "label": "Base branch (blank = repo default)" },
-            { "field": "outcome", "label": "Outcome" },
-            { "field": "open_plan_findings", "label": "Open plan-review findings" },
-            { "field": "open_task_question", "label": "Open escalation question" }
-          ],
-          "form": {
-            "showWhenField": "open_plan_escalation_id",
-            "title": "Answer the open plan-review escalation",
-            "promptField": "open_plan_findings",
-            "inputKey": "note",
-            "inputLabel": "Revision directive note for the planner",
-            "submitLabel": "Revise plan",
-            "action": {
-              "path": "/app/api/actions/message",
-              "body": {
-                "name": "plan-escalation-answered",
-                "correlationKey": "{{row.plan_key}}",
-                "variables": { "directive": "revise", "note": "{{form.note}}" }
-              }
-            }
-          }
+            { "field": "outcome", "label": "Outcome" }
+          ]
         }
       }
     },

package/pages/epic.page.json

@@ -12,6 +12,7 @@
         "items": [
           { "label": "Convergence", "page": "home" },
           { "label": "Epics", "page": "epic" },
+          { "label": "Feature", "page": "feature" },
           { "label": "Cockpit", "page": "cockpit" }
         ]
       }
@@ -75,7 +76,6 @@
           { "field": "base_branch", "header": "Base branch" },
           { "field": "wave_label", "header": "Wave" },
           { "field": "task_count", "header": "Tasks" },
-          { "field": "open_plan_findings", "header": "Attention", "badge": { "tone": "danger", "label": "!" } },
           { "field": "issue_number", "header": "Issue", "linkField": "issue_url" },
           { "field": "updated_at", "header": "Updated" }
         ]

package/pages/feature.page.json

@@ -0,0 +1,82 @@
+{
+  "schemaVersion": "1.0",
+  "title": "Feature Run",
+  "nodes": [
+    {
+      "type": "nav",
+      "id": "nav",
+      "props": {
+        "variant": "bar",
+        "sticky": true,
+        "title": "Nano Workforce",
+        "items": [
+          { "label": "Convergence", "page": "home" },
+          { "label": "Epics", "page": "epic" },
+          { "label": "Feature", "page": "feature" },
+          { "label": "Cockpit", "page": "cockpit" }
+        ]
+      }
+    },
+    {
+      "type": "text",
+      "id": "title",
+      "props": { "text": "Single-issue feature run", "variant": "heading" }
+    },
+    {
+      "type": "text",
+      "id": "subtitle",
+      "props": {
+        "text": "Hand one issue to a single implementation agent — it raises exactly one PR. Optionally converge (review rounds) and auto-merge as follow-on steps. The missing middle between Epics (many PRs) and PR convergence (an already-open PR).",
+        "variant": "sub"
+      }
+    },
+    {
+      "type": "actionForm",
+      "id": "feature-submit",
+      "props": {
+        "title": "Implement one issue",
+        "submitLabel": "Implement & raise PR",
+        "action": { "path": "/app/api/actions/start/feature", "body": "{{form}}" },
+        "fields": [
+          { "key": "issue", "label": "owner/repo#123 or a GitHub issue URL", "type": "text" },
+          { "key": "baseBranch", "label": "Base branch (REQUIRED; the branch the PR targets, e.g. main). A missing epic/* branch is auto-created off default HEAD; a non-epic/* branch must already exist.", "type": "text" },
+          { "key": "converge", "label": "Converge \u2014 hand the raised PR to the review-convergence loop", "type": "checkbox" },
+          { "key": "autoMerge", "label": "Auto-merge \u2014 after convergence, drive the merge-loop (only applies when Converge is on)", "type": "checkbox" },
+          { "key": "confirmDefaultBase", "label": "Confirm landing on the default branch \u2014 required only when the base above IS the repository default", "type": "checkbox" },
+          { "key": "allowSharedBase", "label": "Allow sharing a custom integration branch with another active epic", "type": "checkbox" }
+        ]
+      }
+    },
+    {
+      "type": "dataGrid",
+      "id": "feature-runs",
+      "props": {
+        "title": "Feature runs",
+        "rowKey": "feature_key",
+        "refreshMs": 5000,
+        "data": {
+          "kind": "datasource",
+          "source": "app",
+          "table": "feature_runs",
+          "orderBy": { "field": "updated_at", "dir": "desc" },
+          "filter": [{ "field": "status", "in": ["running"] }]
+        },
+        "tabs": [
+          { "label": "Active", "filter": [{ "field": "status", "in": ["running"] }] },
+          { "label": "History", "filter": [{ "field": "status", "in": ["opened", "converging", "blocked", "skipped", "failed", "abandoned"] }] },
+          { "label": "All", "filter": [] }
+        ],
+        "columns": [
+          { "field": "feature_key", "header": "Feature", "linkField": "issue_url" },
+          { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
+          { "field": "base_branch", "header": "Base branch" },
+          { "field": "pr_key", "header": "PR", "link": { "kind": "page", "page": "home", "keyField": "pr_key" } },
+          { "field": "converge", "header": "Converge" },
+          { "field": "auto_merge", "header": "Auto-merge" },
+          { "field": "outcome", "header": "Outcome" },
+          { "field": "updated_at", "header": "Updated" }
+        ]
+      }
+    }
+  ]
+}

package/pages/home.page.json

@@ -17,6 +17,10 @@
             "label": "Epics",
             "page": "epic"
           },
+          {
+            "label": "Feature",
+            "page": "feature"
+          },
           {
             "label": "Cockpit",
             "page": "cockpit"
@@ -37,7 +41,7 @@
       "type": "text",
       "id": "subtitle",
       "props": {
-        "text": "Submit a pull request to run the autonomous review-convergence loop. Answer escalations inline; cancel a run at any time.",
+        "text": "Submit a pull request to run the autonomous review-convergence loop. Answer escalations from the Task inbox at /tasks; cancel a run at any time.",
         "variant": "sub"
       }
     },
@@ -329,23 +333,7 @@
                 }
               ]
             }
-          ],
-          "form": {
-            "showWhenField": "open_escalation_id",
-            "title": "Answer the open escalation",
-            "promptField": "open_escalation_question",
-            "inputKey": "answer",
-            "inputLabel": "Your answer",
-            "submitLabel": "Send answer",
-            "action": {
-              "path": "/app/api/actions/message",
-              "body": {
-                "name": "escalation-answered",
-                "correlationKey": "{{row.pr_key}}",
-                "variables": "{{form}}"
-              }
-            }
-          }
+          ]
         }
       }
     }