@nanobpm/nano-workforce 0.56.0 → 0.58.0

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;

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

@@ -1,120 +0,0 @@
-// pr.persist-task-escalation — an implementation agent escalated a task during the
-// fan-out (issue #25). It reported `status = "escalated"` with a `question` and,
-// ideally, a work-preserving DRAFT PR, then completed its job. This worker records
-// that escalation and parks the plan on a per-task human answer:
-//   • opens (or refreshes) a `plan_escalations` row (status = open),
-//   • marks the `plan_tasks` row `escalated` with the question / draft PR / corr key,
-//   • re-points the plan's denormalised "open task escalation" fields at the
-//     oldest still-open escalation, so the page's single answer form surfaces it.
-//
-// The process then parks the child at the `feature-escalation-answered` message
-// catch (correlationKey `<plan_key>:<task_id>`). Answering it (page form or
-// `/app/api/hooks/feature-answer`) resumes the child, which re-dispatches the SAME task.
-//
-// Retry-safe: if an open escalation already exists for this corr key (a worker
-// re-activation before the wait subscription opened), it is UPDATED, not
-// duplicated — a fresh escalation row is only created after the previous one was
-// answered.
-import type { AppJobHandler } from "@nanobpm/urban";
-import {
-  featureCorrKey,
-  planEscalations,
-  planTasks,
-  refreshOpenTaskEscalation,
-} from "../../app/plan.ts";
-
-interface TaskIn {
-  id?: unknown;
-  title?: unknown;
-}
-interface In extends Record<string, unknown> {
-  planKey: string;
-  task?: TaskIn;
-  question?: unknown;
-  pr?: unknown;
-  summary?: unknown;
-}
-interface Out extends Record<string, unknown> {
-  escalationId: number;
-  escalationCorrKey: string;
-}
-
-// A non-blank trimmed string, else undefined. A blank question/PR must not reach
-// the UI answer form or masquerade as preserved work.
-const str = (v: unknown): string | undefined =>
-  typeof v === "string" && v.trim() !== "" ? v.trim() : undefined;
-
-const handler: AppJobHandler<In, Out> = async (job, app) => {
-  const planKey = job.variables.planKey;
-  const taskId = str(job.variables.task?.id);
-  if (!taskId) {
-    // No task binding means we cannot correlate a resume — fail loudly rather
-    // than silently parking a token that can never be answered.
-    throw new Error("persist-task-escalation: missing task.id in child scope");
-  }
-  const corrKey = featureCorrKey(planKey, taskId);
-  const question = str(job.variables.question);
-  if (!question) {
-    // A blank question would surface a non-actionable placeholder in the answer
-    // form and, on a retry, overwrite a previously recorded question. The output
-    // contract requires `question` for an escalation — fail loudly, like the
-    // missing-task.id guard above, rather than park an unanswerable escalation.
-    throw new Error("persist-task-escalation: missing question for escalated task");
-  }
-  const draftPr = str(job.variables.pr) ?? null;
-  // Prior-attempt context the escalating agent reported. Persist it so the UI
-  // and any later resume/debugging keep the task's summary instead of NULL.
-  const summary = str(job.variables.summary) ?? null;
-  const ts = new Date().toISOString();
-
-  const escTable = planEscalations(app.data);
-  const existing = (await escTable.find({ corr_key: corrKey, status: "open" }))
-    .sort((a, b) => b.id - a.id)[0];
-  let escalationId: number;
-  if (existing) {
-    await escTable.update(existing.id, {
-      question,
-      draft_pr_key: draftPr ?? existing.draft_pr_key,
-    });
-    escalationId = existing.id;
-  } else {
-    escalationId = Number(
-      await escTable.insert({
-        plan_key: planKey,
-        task_id: taskId,
-        corr_key: corrKey,
-        question,
-        draft_pr_key: draftPr,
-        status: "open",
-        asked_at: ts,
-      }),
-    );
-  }
-
-  for (const t of await planTasks(app.data).find({ plan_key: planKey, task_id: taskId })) {
-    await planTasks(app.data).update(t.id, {
-      status: "escalated",
-      open_question: question,
-      // Clear any answer from a prior (already-answered) escalation so the task
-      // row stays aligned with the currently-open question — otherwise a
-      // re-escalated task would show a stale answer next to the new question.
-      answer: null,
-      draft_pr_key: draftPr ?? t.draft_pr_key,
-      summary: summary ?? t.summary,
-      corr_key: corrKey,
-      updated_at: ts,
-    });
-  }
-
-  await refreshOpenTaskEscalation(app.data, planKey);
-  // Emit the correlation key as a single scalar so the downstream
-  // `feature-escalation-answered` catch subscribes on `=escalationCorrKey`
-  // (freshly set, in scope) rather than re-deriving `=planKey + ":" + task.id`.
-  // The concatenation form errored to an empty, unmatchable key whenever `task`
-  // was not a Map at subscription-open, parking the token forever (see the
-  // engine incident fix). The value is identical to `featureCorrKey(planKey,
-  // taskId)`, so the app's answer-publish path still matches.
-  return { escalationId, escalationCorrKey: corrKey };
-};
-
-export default handler;