@nanobpm/nano-workforce 0.57.0 → 0.58.0

package/workers/resolve-trial-attention/worker.test.ts

@@ -0,0 +1,77 @@
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
+import { recordTrialMergeAudit, resolveTrialMergeAttention } from "../../app/trialMerge.ts";
+import handler from "./worker.ts";
+
+// In-memory DataLayer.table shim backing `plan_trial_merges` for the audit helpers.
+function fakeApp() {
+  const rows: any[] = [];
+  let nextId = 1;
+  const table = {
+    async find(q: Record<string, unknown>) {
+      return rows.filter((r) => Object.entries(q).every(([k, v]) => r[k] === v));
+    },
+    async insert(row: Record<string, unknown>) {
+      const id = nextId++;
+      rows.push({ id, ...row });
+      return id;
+    },
+    async update(id: number, patch: Record<string, unknown>) {
+      const r = rows.find((x) => x.id === id);
+      if (r) Object.assign(r, patch);
+    },
+  };
+  const app = {
+    data: { table: (_name: string, _key: string) => table },
+    log: noopLog(),
+  };
+  return { app, rows };
+}
+
+// Red/green regression: a `proceed` override on a trial-merge escalation records NO re-run row, so
+// without this serviceTask the wave's red `plan_trial_merges` audit row stays unresolved forever in
+// the epic page's "Needs attention" tab (the caller was dropped in the userTask refactor). The
+// worker must clear it. (Confirmed red against a no-op handler.)
+test("resolve-trial-attention clears the wave's unresolved audit rows", async () => {
+  const { app, rows } = fakeApp();
+  await recordTrialMergeAudit(app.data as any, {
+    planKey: "o/r#69",
+    wave: 2,
+    result: "suite-failed",
+    summary: "combined suite red",
+  });
+  // A different wave must be left untouched.
+  await recordTrialMergeAudit(app.data as any, { planKey: "o/r#69", wave: 3, result: "suite-failed" });
+
+  assertEquals(rows.filter((r) => r.wave === 2 && r.resolved !== 1).length, 1);
+
+  await handler(
+    { key: 1, variables: { planKey: "o/r#69", currentWave: 2 } } as any,
+    app as any,
+  );
+
+  assertEquals(rows.filter((r) => r.wave === 2 && r.resolved !== 1).length, 0);
+  // Wave 3 is a distinct escalation and must remain unresolved.
+  assertEquals(rows.filter((r) => r.wave === 3 && r.resolved !== 1).length, 1);
+  // Idempotent: a follow-up (e.g. rebase re-entry) clears nothing new.
+  assertEquals(await resolveTrialMergeAttention(app.data as any, "o/r#69", 2), 0);
+});
+
+test("resolve-trial-attention never throws when cleanup fails", async () => {
+  const app = {
+    data: {
+      table: () => ({
+        find: async () => {
+          throw new Error("db down");
+        },
+        insert: async () => 1,
+        update: async () => {},
+      }),
+    },
+    log: noopLog(),
+  };
+  // Best-effort/cosmetic: a transient failure must not wedge the plan.
+  const out = await handler({ key: 2, variables: { planKey: "o/r#1", currentWave: 0 } } as any, app as any);
+  assertEquals(out, {});
+});

package/workers/resolve-trial-attention/worker.ts

@@ -0,0 +1,43 @@
+// pr.resolve-trial-attention — clear the wave's trial-merge "Needs attention" audit rows once a
+// human has made a decision on the trial-merge escalation (issue #69 / #131 follow-up).
+//
+// Before the escalations were converted to native userTasks, the app-side answer path called
+// `resolveTrialMergeAttention` so that a `proceed` override (which records no re-run row and so
+// would otherwise pin the red `plan_trial_merges` row in the epic page's "Needs attention" tab
+// forever) cleared the wave. The userTask refactor retired that app-side path, leaving this
+// cleanup uncalled. This serviceTask restores it in the process: it runs on EVERY answer variant
+// (proceed / rebase / abandon) between the `trial-merge-decision` userTask and the answer gateway,
+// so the human's decision always clears the wave. It is idempotent w.r.t. a `rebase` re-run, which
+// records a fresh unresolved row that supersedes any prior (so re-resolving here changes nothing).
+//
+// Cleanup is best-effort/cosmetic: a transient failure must never wedge the plan, so it is caught
+// and logged rather than thrown.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { resolveTrialMergeAttention } from "../../app/trialMerge.ts";
+
+interface In extends Record<string, unknown> {
+  planKey: string;
+  currentWave?: unknown;
+  trialMergeWave?: unknown;
+}
+
+const waveNo = (v: unknown): number => {
+  const n = Math.trunc(Number(v));
+  return Number.isFinite(n) && n >= 0 ? n : 0;
+};
+
+const handler: AppJobHandler<In> = async (job, app) => {
+  const planKey = job.variables.planKey;
+  const wave = waveNo(job.variables.trialMergeWave ?? job.variables.currentWave);
+  try {
+    const cleared = await resolveTrialMergeAttention(app.data, planKey, wave);
+    if (cleared > 0) {
+      app.log.info(`resolve-trial-attention: cleared ${cleared} row(s) for ${planKey} wave ${wave}`);
+    }
+  } catch (err) {
+    app.log.error(`resolve-trial-attention: cleanup failed for ${planKey} wave ${wave}`, { err: String(err) });
+  }
+  return {};
+};
+
+export default handler;

package/operations/answerFeatureEscalation.test.ts

@@ -1,112 +0,0 @@
-import { test } from "node:test";
-import { assertEquals } from "#test-assert";
-import type { AppApi } from "@nanobpm/urban";
-import { noopLog } from "../test/log.ts";
-
-const hadSecret = Object.prototype.hasOwnProperty.call(process.env, "NANO_PR_WEBHOOK_SECRET");
-const previousSecret = process.env.NANO_PR_WEBHOOK_SECRET;
-let answerFeatureEscalation: typeof import("./answerFeatureEscalation.ts").default;
-try {
-  process.env.NANO_PR_WEBHOOK_SECRET = " test-secret ";
-  answerFeatureEscalation = (await import("./answerFeatureEscalation.ts")).default;
-} finally {
-  if (hadSecret && previousSecret !== undefined) process.env.NANO_PR_WEBHOOK_SECRET = previousSecret;
-  else delete process.env.NANO_PR_WEBHOOK_SECRET;
-}
-
-function memTable(rows: any[], key: string) {
-  return {
-    find: (where: Record<string, unknown>) =>
-      Promise.resolve(rows.filter((row) => Object.entries(where).every(([field, value]) => row[field] === value))),
-    update: (value: unknown, patch: Record<string, unknown>) => {
-      const row = rows.find((candidate) => candidate[key] === value);
-      if (row) Object.assign(row, patch);
-      return Promise.resolve(row);
-    },
-  };
-}
-
-function memApp(escalations: any[] = []) {
-  const stores: Record<string, { rows: any[]; key: string }> = {
-    plans: { rows: [{ plan_key: "owner/repo#9" }], key: "plan_key" },
-    plan_escalations: { rows: escalations, key: "id" },
-    plan_tasks: { rows: [{ id: 1, plan_key: "owner/repo#9", task_id: "task-1" }], key: "id" },
-  };
-  const published: Record<string, unknown>[] = [];
-  const app = {
-    data: {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
-    },
-    engine: {
-      publishMessage: (message: Record<string, unknown>) => {
-        published.push(message);
-        return Promise.resolve();
-      },
-    },
-    log: noopLog(),
-  } as any as AppApi;
-  return { app, published };
-}
-
-function input(body: Record<string, unknown>, secret?: string) {
-  const headers = new Headers();
-  if (secret !== undefined) headers.set("x-hook-secret", secret);
-  return {
-    req: {
-      method: "POST",
-      path: "/app/api/hooks/feature-answer",
-      query: new URLSearchParams(),
-      headers,
-      text: async () => "",
-    } as any,
-    params: {},
-    query: {},
-    body,
-  };
-}
-
-test("rejects a request without the configured hook secret", async () => {
-  const { app } = memApp();
-  const result = await answerFeatureEscalation(input({ corrKey: "owner/repo#9:task-1", answer: "yes" }), app) as any;
-  assertEquals(result.status, 401);
-  assertEquals(result.body, { ok: false, error: "unauthorized" });
-});
-
-test("derives corrKey from plan + task and maps an answered escalation to 200", async () => {
-  const { app, published } = memApp([{
-    id: 1,
-    plan_key: "owner/repo#9",
-    task_id: "task-1",
-    corr_key: "owner/repo#9:task-1",
-    question: "Proceed?",
-    status: "open",
-  }]);
-  const result = await answerFeatureEscalation(
-    input({ plan: "owner/repo#9", task: "task-1", answer: " yes " }, "test-secret"),
-    app,
-  ) as any;
-  assertEquals(result.status, 200);
-  assertEquals(result.body.ok, true);
-  assertEquals(published[0]?.correlationKey, "owner/repo#9:task-1");
-  assertEquals((published[0]?.variables as Record<string, unknown>).answer, "yes");
-});
-
-test("maps an unmatched corrKey to 404", async () => {
-  const { app } = memApp();
-  const result = await answerFeatureEscalation(
-    input({ corrKey: "owner/repo#9:missing", answer: "yes" }, "test-secret"),
-    app,
-  ) as any;
-  assertEquals(result.status, 404);
-  assertEquals(result.body.ok, false);
-});
-
-test("rejects a missing request body with 400 (not 500)", async () => {
-  const { app } = memApp();
-  const result = await answerFeatureEscalation(
-    { ...input({}, "test-secret"), body: undefined },
-    app,
-  ) as any;
-  assertEquals(result.status, 400);
-  assertEquals(result.body.ok, false);
-});

package/operations/answerFeatureEscalation.ts

@@ -1,58 +0,0 @@
-// POST /app/api/hooks/feature-answer → operationId `answerFeatureEscalation` (ADR 0059 webhook
-// operation; was the `/hooks/feature-answer` action). Answers an implementation-phase task
-// escalation out of band (optional shared-secret guard via X-Hook-Secret, enforced only when
-// NANO_PR_WEBHOOK_SECRET is set — mirrors the operator control surface), issue #25. Lets an
-// external system (a chat relay, a CI job, a human via curl) resume a parked implementation agent
-// without the page. Same idempotent `answerTaskEscalation` path the page's answer form uses.
-//
-// The runtime validates the body shape against openapi.yaml — a `oneOf` of EXACTLY ONE addressing
-// form (`{ corrKey, answer }` OR `{ plan, task, answer }`), so a body that supplies neither form (or
-// mixes them) is rejected at the edge with a 400 that names the allowed shapes. This delegate narrows
-// the validated variant and keeps the semantic normalization the schema can't express (an answer /
-// correlation key that is present but blank-after-trim) plus the shared-secret guard.
-//   { "corrKey": "owner/repo#12:task-3", "answer": "…" }
-//   { "plan": "owner/repo#12", "task": "task-3", "answer": "…" }
-
-import { answerTaskEscalation, featureCorrKey } from "../app/plan.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("answerFeatureEscalation", async ({ req, body }, app) => {
-  if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
-    app.log.warn("feature-answer rejected: missing/invalid shared secret");
-    return { status: 401, body: { ok: false, error: "unauthorized" } };
-  }
-  // 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.
-  if (!body || typeof body !== "object") {
-    app.log.warn("feature-answer rejected: missing request body");
-    return { status: 400, body: { ok: false, error: "answer is required" } };
-  }
-  const answer = str(body.answer);
-  if (!answer) {
-    app.log.warn("feature-answer rejected: blank answer");
-    return { status: 400, body: { ok: false, error: "answer is required" } };
-  }
-
-  const corrKey = "corrKey" in body
-    ? str(body.corrKey)
-    : str(body.plan) && str(body.task)
-      ? featureCorrKey(str(body.plan), str(body.task))
-      : "";
-  if (!corrKey) {
-    app.log.warn("feature-answer rejected: unresolvable correlation key");
-    return {
-      status: 400,
-      body: { ok: false, error: "provide corrKey, or both plan (owner/repo#N) and task" },
-    };
-  }
-
-  const r = await answerTaskEscalation(app.data, app.engine, corrKey, answer);
-  if (r.ok) app.log.info("feature escalation answered", { corrKey });
-  else app.log.warn("feature-answer: no open escalation to answer", { corrKey });
-  return { status: r.ok ? 200 : 404, body: r };
-});

package/operations/answerPlanEscalation.test.ts

@@ -1,115 +0,0 @@
-import { test } from "node:test";
-import { assertEquals } from "#test-assert";
-import type { AppApi } from "@nanobpm/urban";
-import { noopLog } from "../test/log.ts";
-
-const hadSecret = Object.prototype.hasOwnProperty.call(process.env, "NANO_PR_WEBHOOK_SECRET");
-const previousSecret = process.env.NANO_PR_WEBHOOK_SECRET;
-let answerPlanEscalation: typeof import("./answerPlanEscalation.ts").default;
-try {
-  process.env.NANO_PR_WEBHOOK_SECRET = " test-secret ";
-  answerPlanEscalation = (await import("./answerPlanEscalation.ts")).default;
-} finally {
-  if (hadSecret && previousSecret !== undefined) process.env.NANO_PR_WEBHOOK_SECRET = previousSecret;
-  else delete process.env.NANO_PR_WEBHOOK_SECRET;
-}
-
-function memTable(rows: any[], key: string) {
-  return {
-    find: (where: Record<string, unknown>) =>
-      Promise.resolve(rows.filter((row) => Object.entries(where).every(([field, value]) => row[field] === value))),
-    update: (value: unknown, patch: Record<string, unknown>) => {
-      const row = rows.find((candidate) => candidate[key] === value);
-      if (row) Object.assign(row, patch);
-      return Promise.resolve(row);
-    },
-  };
-}
-
-function memApp(escalations: any[] = []) {
-  const stores: Record<string, { rows: any[]; key: string }> = {
-    plans: { rows: [{ plan_key: "owner/repo#9", open_plan_escalation_id: 1 }], key: "plan_key" },
-    plan_review_escalations: { rows: escalations, key: "id" },
-  };
-  const published: Record<string, unknown>[] = [];
-  const app = {
-    data: {
-      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
-    },
-    engine: {
-      publishMessage: (message: Record<string, unknown>) => {
-        published.push(message);
-        return Promise.resolve();
-      },
-    },
-    log: noopLog(),
-  } as any as AppApi;
-  return { app, published, stores };
-}
-
-function input(body: Record<string, unknown>, secret?: string) {
-  const headers = new Headers();
-  if (secret !== undefined) headers.set("x-hook-secret", secret);
-  return {
-    req: {
-      method: "POST",
-      path: "/app/api/hooks/plan-answer",
-      query: new URLSearchParams(),
-      headers,
-      text: async () => "",
-    } as any,
-    params: {},
-    query: {},
-    body,
-  };
-}
-
-test("rejects a request without the configured hook secret", async () => {
-  const { app } = memApp();
-  const result = await answerPlanEscalation(input({ plan: "owner/repo#9", directive: "revise" }), app) as any;
-  assertEquals(result.status, 401);
-  assertEquals(result.body, { ok: false, error: "unauthorized" });
-});
-
-test("answers an open plan escalation and publishes the plan correlation message", async () => {
-  const { app, published, stores } = memApp([{
-    id: 1,
-    plan_key: "owner/repo#9",
-    epoch: 0,
-    round: 2,
-    findings: "needs wave 0",
-    status: "open",
-  }]);
-  const result = await answerPlanEscalation(
-    input({ plan: "owner/repo#9", directive: "revise", note: " use issue-1 first " }, "test-secret"),
-    app,
-  ) as any;
-  assertEquals(result.status, 200);
-  assertEquals(result.body.ok, true);
-  assertEquals(stores.plan_review_escalations.rows[0].status, "answered");
-  assertEquals(stores.plan_review_escalations.rows[0].directive, "revise");
-  assertEquals(stores.plan_review_escalations.rows[0].note, "use issue-1 first");
-  assertEquals(published[0]?.name, "plan-escalation-answered");
-  assertEquals(published[0]?.correlationKey, "owner/repo#9");
-  assertEquals((published[0]?.variables as Record<string, unknown>).planEscalationDirective, "revise");
-});
-
-test("maps an unmatched plan to 404", async () => {
-  const { app } = memApp();
-  const result = await answerPlanEscalation(
-    input({ plan: "owner/repo#missing", directive: "revise" }, "test-secret"),
-    app,
-  ) as any;
-  assertEquals(result.status, 404);
-  assertEquals(result.body.ok, false);
-});
-
-test("rejects an invalid directive with 400", async () => {
-  const { app } = memApp();
-  const result = await answerPlanEscalation(
-    input({ plan: "owner/repo#9", directive: "ship-it" }, "test-secret"),
-    app,
-  ) as any;
-  assertEquals(result.status, 400);
-  assertEquals(result.body.ok, false);
-});

package/operations/answerPlanEscalation.ts

@@ -1,41 +0,0 @@
-// POST /app/api/hooks/plan-answer → operationId `answerPlanEscalation`. Answers a plan-review
-// cap escalation out of band. The process is parked on `plan-escalation-answered`, correlated by
-// planKey; the answer records the human directive and resumes the plan.
-import {
-  answerPlanEscalation as answerPlanEscalationState,
-  parsePlanEscalationDirective,
-} from "../app/plan.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("answerPlanEscalation", async ({ req, body }, app) => {
-  if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
-    app.log.warn("plan-answer rejected: missing/invalid shared secret");
-    return { status: 401, body: { ok: false, error: "unauthorized" } };
-  }
-  if (!body || typeof body !== "object") {
-    app.log.warn("plan-answer rejected: missing request body");
-    return { status: 400, body: { ok: false, error: "plan and directive are required" } };
-  }
-
-  const planKey = str(body.plan);
-  const directive = parsePlanEscalationDirective(body.directive);
-  const note = str(body.note);
-  if (!planKey) {
-    app.log.warn("plan-answer rejected: missing plan");
-    return { status: 400, body: { ok: false, error: "plan is required" } };
-  }
-  if (!directive) {
-    app.log.warn("plan-answer rejected: invalid directive", { directive: str(body.directive) });
-    return { status: 400, body: { ok: false, error: "directive must be proceed or revise" } };
-  }
-
-  const r = await answerPlanEscalationState(app.data, app.engine, planKey, directive, note);
-  if (r.ok) app.log.info("plan escalation answered", { planKey, directive });
-  else app.log.warn("plan-answer: no open plan escalation to answer", { planKey });
-  return { status: r.ok ? 200 : 404, body: r };
-});

package/workers/persist-plan-escalation/worker.test.ts

@@ -1,80 +0,0 @@
-import { test } from "node:test";
-import { assertEquals, assertRejects } from "#test-assert";
-import { noopLog } from "../../test/log.ts";
-import handler from "./worker.ts";
-
-function fakeApp(escalations: any[] = []) {
-  const plans = [{ plan_key: "owner/repo#12", status: "dispatched" }];
-  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))),
-    insert: (row: any) => {
-      row.id = row.id ?? rows.length + 1;
-      rows.push(row);
-      return Promise.resolve(row.id);
-    },
-    update: (id: any, patch: any) => {
-      const row = rows.find((r) => r[key] === id);
-      if (row) Object.assign(row, patch);
-      return Promise.resolve(row);
-    },
-  });
-  return {
-    data: {
-      table(name: string) {
-        return name === "plans" ? table(plans, "plan_key") : table(escalations, "id");
-      },
-    },
-    log: noopLog(),
-    _plans: plans,
-    _escalations: escalations,
-  } as any;
-}
-
-test("records an open plan-review escalation and surfaces it on the plan", async () => {
-  const app = fakeApp();
-  const out = await handler({
-    variables: {
-      planKey: "owner/repo#12",
-      planReviewEpoch: 1,
-      planReviewRound: 2,
-      planFindings: "needs a seam",
-    },
-    jobKey: "j1",
-  } as any, app as any);
-
-  assertEquals(out.planEscalationId, 1);
-  assertEquals(app._escalations[0].plan_key, "owner/repo#12");
-  assertEquals(app._escalations[0].epoch, 1);
-  assertEquals(app._escalations[0].round, 2);
-  assertEquals(app._escalations[0].findings, "needs a seam");
-  assertEquals(app._plans[0].open_plan_escalation_id, 1);
-  assertEquals(app._plans[0].open_plan_findings, "needs a seam");
-  assertEquals(app._plans[0].status, "planning");
-});
-
-test("missing planKey fails loudly instead of parking an unanswerable escalation", async () => {
-  const app = fakeApp();
-  await assertRejects(
-    () => handler({
-      variables: { planKey: "   ", planFindings: "needs a seam" },
-      jobKey: "j-missing",
-    } as any, app as any),
-    Error,
-    "persist-plan-escalation: missing planKey in process scope",
-  );
-});
-
-test("non-string planKey is treated as missing rather than coerced to a bogus key", async () => {
-  const app = fakeApp();
-  await assertRejects(
-    () => handler({
-      variables: { planKey: 123, planFindings: "needs a seam" },
-      jobKey: "j-nonstring",
-    } as any, app as any),
-    Error,
-    "persist-plan-escalation: missing planKey in process scope",
-  );
-  assertEquals(app._escalations.length, 0);
-});

package/workers/persist-plan-escalation/worker.ts

@@ -1,73 +0,0 @@
-// pr.persist-plan-escalation — the adversarial plan-review loop reached its per-epoch budget
-// without approval. Record a plan-level human escalation and park the process until an operator
-// answers with either `revise` (default: loop back to the planner with guidance and a fresh epoch)
-// or `proceed` (explicit override: dispatch the current plan as-is).
-import type { AppJobHandler } from "@nanobpm/urban";
-import { planReviewEscalations, plans } from "../../app/plan.ts";
-
-interface In extends Record<string, unknown> {
-  planKey: string;
-  planFindings?: unknown;
-  planReviewEpoch?: unknown;
-  planReviewRound?: unknown;
-}
-interface Out extends Record<string, unknown> {
-  planEscalationId: number;
-}
-
-// Accept only genuine strings (trimmed); anything else is treated as missing so
-// the explicit planKey guard fires instead of silently coercing (e.g. 123 -> "123")
-// an escalation that BPMN correlation ("owner/repo#N") could never resume.
-const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
-const int = (v: unknown): number => {
-  const n = Math.trunc(Number(v));
-  return Number.isFinite(n) && n >= 0 ? n : 0;
-};
-
-const handler: AppJobHandler<In, Out> = async (job, app) => {
-  const planKey = str(job.variables.planKey);
-  if (!planKey) {
-    // No plan binding means we cannot correlate a resume — fail loudly rather
-    // than silently parking a token that can never be answered.
-    throw new Error("persist-plan-escalation: missing planKey in process scope");
-  }
-  const epoch = int(job.variables.planReviewEpoch);
-  const round = int(job.variables.planReviewRound);
-  const findings = str(job.variables.planFindings) || null;
-  const ts = new Date().toISOString();
-
-  const escTable = planReviewEscalations(app.data);
-  const existing = (await escTable.find({ plan_key: planKey, status: "open" }))
-    .sort((a, b) => b.id - a.id)[0];
-  let escalationId: number;
-  if (existing) {
-    await escTable.update(existing.id, { epoch, round, findings });
-    escalationId = existing.id;
-  } else {
-    escalationId = Number(
-      await escTable.insert({
-        plan_key: planKey,
-        epoch,
-        round,
-        findings,
-        status: "open",
-        directive: null,
-        note: null,
-        asked_at: ts,
-        answered_at: null,
-      }),
-    );
-  }
-
-  await plans(app.data).update(planKey, {
-    status: "planning",
-    open_plan_escalation_id: escalationId,
-    open_plan_findings: findings,
-    open_plan_round: round,
-    updated_at: ts,
-  });
-
-  return { planEscalationId: escalationId };
-};
-
-export default handler;