@nanobpm/nano-workforce 0.99.1 → 0.100.0

package/operations/acknowledgeBlocked.test.ts

@@ -1,111 +0,0 @@
-// Tests for the POST /app/api/actions/acknowledge-blocked operation `acknowledgeBlocked` (issue #220).
-// The nwf UI's completion affordance for a blocked feature run parked at `feature-blocked`: it routes
-// through the canonical attributed completer (completeBlockedAsHuman → completeUserTaskAttributed),
-// resuming the process (→ pr.record-blocked-ack) exactly as the task inbox would, and immediately
-// clears the denormalised completable-task pointer so the affordance stops rendering. Mirrors the
-// escalation twin (operations/answerFeatureEscalation.ts).
-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 "./acknowledgeBlocked.ts";
-
-function memApp(openTasks: { userTaskKey: string; elementId?: string }[]): {
-  app: AppApi;
-  stores: Record<string, any[]>;
-  completed: { userTaskKey: string; variables: Record<string, unknown> }[];
-} {
-  const stores: Record<string, any[]> = {};
-  const completed: { userTaskKey: string; variables: Record<string, unknown> }[] = [];
-  function tbl(name: string, pk: string) {
-    const rows = (stores[name] ??= [] as any[]);
-    return {
-      async insert(row: any) {
-        rows.push({ ...row });
-        return rows.length;
-      },
-      async get(id: any) {
-        return rows.find((r) => r[pk] === id);
-      },
-      async find(where: any = {}) {
-        return rows.filter((r) => Object.entries(where).every(([k, v]) => r[k] === v));
-      },
-      async delete(id: any) {
-        const i = rows.findIndex((r) => r[pk] === id);
-        if (i >= 0) rows.splice(i, 1);
-      },
-      async update(id: any, patch: any) {
-        const r = rows.find((row) => row[pk] === id);
-        if (r) Object.assign(r, patch);
-      },
-    };
-  }
-  const engine = {
-    searchUserTasks: async () => openTasks,
-    completeUserTask: async (userTaskKey: string, variables: Record<string, unknown>) => {
-      completed.push({ userTaskKey, variables });
-    },
-  };
-  const app = {
-    data: { table: (n: string, pk: string) => tbl(n, pk) },
-    engine,
-    log: noopLog(),
-  } as any as AppApi;
-  return { app, stores, completed };
-}
-
-async function call(app: AppApi, body: unknown) {
-  return (await handler({ req: {} as any, params: {}, query: {}, body } as any, app)) as any;
-}
-
-test("acknowledge-blocked: completes the feature-blocked task, records the note, clears the pointer", async () => {
-  const { app, stores, completed } = memApp([{ userTaskKey: "ut-1", elementId: "feature-blocked" }]);
-  stores.feature_runs = [{ feature_key: "o/r#1", status: "awaiting_operator", blocked_user_task_key: "ut-1" }];
-
-  const res = await call(app, { userTaskKey: "ut-1", note: "reassigned to a human", operator: "alice" });
-
-  assertEquals(res.status, 200);
-  assertEquals(res.body.ok, true);
-  // The task is completed with the typed `note` variable the record-blocked-ack ioMapping reads.
-  assertEquals(completed.length, 1);
-  assertEquals(completed[0].userTaskKey, "ut-1");
-  assertEquals(completed[0].variables, { note: "reassigned to a human" });
-  // The attribution ledger records WHO acknowledged (a human — the authority, not reversible).
-  assertEquals(stores.task_completions.length, 1);
-  assertEquals(stores.task_completions[0].actor_kind, "human");
-  assertEquals(stores.task_completions[0].actor_id, "alice");
-  assertEquals(stores.task_completions[0].reversible, 0);
-  // The operation clears its own action's pointer immediately (status left to record-blocked-ack).
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-});
-
-test("acknowledge-blocked: a blank note omits the variable so the ioMapping fallback fires", async () => {
-  const { app, stores, completed } = memApp([{ userTaskKey: "ut-2", elementId: "feature-blocked" }]);
-  stores.feature_runs = [{ feature_key: "o/r#2", status: "awaiting_operator", blocked_user_task_key: "ut-2" }];
-
-  const res = await call(app, { userTaskKey: "ut-2", note: "   " });
-
-  assertEquals(res.status, 200);
-  assertEquals(completed[0].variables, {});
-});
-
-test("acknowledge-blocked: a missing userTaskKey → 400", async () => {
-  const { app } = memApp([]);
-  const res = await call(app, { note: "x" });
-  assertEquals(res.status, 400);
-  assertEquals(res.body.ok, false);
-});
-
-test("acknowledge-blocked: no matching open task → 404", async () => {
-  const { app } = memApp([]);
-  const res = await call(app, { userTaskKey: "ut-gone" });
-  assertEquals(res.status, 404);
-  assertEquals(res.body.ok, false);
-});
-
-test("acknowledge-blocked: refuses a non-blocked task (an escalation) → 400", async () => {
-  const { app } = memApp([{ userTaskKey: "ut-esc", elementId: "feature-escalation" }]);
-  const res = await call(app, { userTaskKey: "ut-esc" });
-  assertEquals(res.status, 400);
-  assertEquals(res.body.ok, false);
-});

package/operations/acknowledgeBlocked.ts

@@ -1,62 +0,0 @@
-// POST /app/api/actions/acknowledge-blocked → operationId `acknowledgeBlocked` (issue #220).
-// The nwf UI's completion affordance for a BLOCKED single-issue feature run: an operator acknowledges
-// the parked `feature-blocked` user task (with an optional disposition note) directly from the Feature /
-// Overview pages, instead of the run sitting parked forever with no control (the escalation path got
-// this in issue #210; the blocked path did not).
-//
-// It routes through the ONE canonical attributed completer (`completeBlockedAsHuman` →
-// `completeUserTaskAttributed`), so the completion uses the exact same typed `.form` variable (`note`)
-// and engine resume path a human drives from the task inbox — no parallel completion — while recording
-// WHO acknowledged in the `task_completions` ledger. Completing the task fires `pr.record-blocked-ack`,
-// which settles the row to the terminal `blocked` status with the operator's note. The poller then
-// reconciles the completable-task pointer off the row (pollFeatureBlocked) once the task is gone.
-//
-// The runtime validates the body against openapi.yaml (`userTaskKey` required); this delegate narrows
-// the validated shape and builds the typed completion variables the `feature-blocked` form + the
-// `record-blocked-ack` ioMapping expect.
-
-import { completeBlockedAsHuman } from "../app/agentCompletion.ts";
-import { featureRuns } from "../app/feature.ts";
-import { defineOperation } from "../nano-generated/operations.ts";
-
-const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
-
-export default defineOperation("acknowledgeBlocked", async ({ body }, app) => {
-  if (!body || typeof body !== "object") {
-    app.log.warn("acknowledge-blocked rejected: missing request body");
-    return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
-  }
-
-  const userTaskKey = str(body.userTaskKey);
-  if (!userTaskKey) return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
-
-  // The `feature-blocked` form completes with an optional `note`; the `record-blocked-ack` ioMapping
-  // reads it (`if is defined(note) then note else null`) into `delivery_label`. An absent/blank note is
-  // recorded as an "acknowledged" label rather than an empty string — omit the variable entirely so the
-  // ioMapping's `is defined` fallback fires.
-  const note = str(body.note);
-  const variables: Record<string, unknown> = note ? { note } : {};
-
-  // The completing operator, for the attribution ledger. Optional — the UI has no per-operator auth, so
-  // default to a generic handle rather than blocking the acknowledgement.
-  const operatorId = str(body.operator) || "operator";
-
-  const r = await completeBlockedAsHuman(app.data, app.engine, { userTaskKey, operatorId, variables });
-  if (r.ok) {
-    // Reconcile this operation's OWN action immediately: clear the denormalised blocked pointer so the
-    // pages stop offering an acknowledge affordance for a task that is now completed. Leave `status` to
-    // `record-blocked-ack` (which settles it to terminal `blocked`), so we never overwrite the status the
-    // resumed run has advanced to.
-    for (const run of await featureRuns(app.data).find({ blocked_user_task_key: userTaskKey })) {
-      await featureRuns(app.data).update(run.feature_key, {
-        blocked_user_task_key: null,
-        updated_at: new Date().toISOString(),
-      });
-    }
-    app.log.info("operator acknowledged blocked feature run", { userTaskKey, elementId: r.elementId });
-    return { status: 200, body: { ok: true, completionId: r.completionId, elementId: r.elementId } };
-  }
-  const status = r.reason === "no open blocked task" ? 404 : 400;
-  app.log.warn("acknowledge-blocked: not completed", { userTaskKey, reason: r.reason });
-  return { status, body: { ok: false, error: r.reason } };
-});

package/operations/answerFeatureEscalation.ts

@@ -1,68 +0,0 @@
-// POST /app/api/actions/answer-escalation → operationId `answerFeatureEscalation` (issue #210).
-// The nwf UI's answer affordance for a native feature-run escalation: an operator answers the parked
-// `feature-escalation` user task (resolution=answer/abandon + optional guidance) directly from the
-// Feature / Overview pages, instead of only from the generic task inbox.
-//
-// It routes through the ONE canonical attributed completer (`completeEscalationAsHuman` →
-// `completeUserTaskAttributed`), so the completion uses the exact same typed `.form` variables and
-// engine resume path a human drives from the task inbox — no parallel completion — while recording
-// WHO answered in the `task_completions` ledger. The poller then reconciles the run off `escalated`
-// (pollFeatureEscalations) once the task is gone.
-//
-// The runtime validates the body against openapi.yaml (`userTaskKey` + `resolution` required); this
-// delegate narrows the validated shape, enforces the answer/abandon contract, and builds the typed
-// completion variables the `feature-escalation` form + the `w_gw_answer` gateway expect.
-
-import { completeEscalationAsHuman } from "../app/agentCompletion.ts";
-import { featureRuns } from "../app/feature.ts";
-import { defineOperation } from "../nano-generated/operations.ts";
-
-const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
-
-export default defineOperation("answerFeatureEscalation", async ({ body }, app) => {
-  if (!body || typeof body !== "object") {
-    app.log.warn("answer-escalation rejected: missing request body");
-    return { status: 400, body: { ok: false, error: "userTaskKey and resolution are required" } };
-  }
-
-  const userTaskKey = str(body.userTaskKey);
-  if (!userTaskKey) return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
-
-  const resolution = str(body.resolution);
-  if (resolution !== "answer" && resolution !== "abandon") {
-    return { status: 400, body: { ok: false, error: "resolution must be 'answer' or 'abandon'" } };
-  }
-
-  // The `feature-escalation` form completes with `{ resolution, answer }`; the `w_gw_answer` gateway
-  // re-dispatches implement-task with `answer` when resolution=answer, else routes to record-feature.
-  // Guidance is required for an answer (an empty answer re-dispatches the agent with nothing new).
-  const answer = str(body.answer);
-  if (resolution === "answer" && !answer) {
-    return { status: 400, body: { ok: false, error: "answer (guidance) is required when resolution is 'answer'" } };
-  }
-  const variables: Record<string, unknown> = resolution === "answer" ? { resolution, answer } : { resolution };
-
-  // The completing operator, for the attribution ledger. Optional — the UI has no per-operator auth,
-  // so default to a generic handle rather than blocking the answer.
-  const operatorId = str(body.operator) || "operator";
-
-  const r = await completeEscalationAsHuman(app.data, app.engine, { userTaskKey, operatorId, variables });
-  if (r.ok) {
-    // Reconcile this operation's OWN action immediately: clear the denormalised escalation pointer +
-    // question so the pages stop offering an answer affordance for a task that is now completed. Leave
-    // `status` to the poller (escalated → running on the answer loop) / record-feature (terminal on
-    // abandon), so we never overwrite a status the resumed run has already advanced to.
-    for (const run of await featureRuns(app.data).find({ escalation_user_task_key: userTaskKey })) {
-      await featureRuns(app.data).update(run.feature_key, {
-        escalation_question: null,
-        escalation_user_task_key: null,
-        updated_at: new Date().toISOString(),
-      });
-    }
-    app.log.info("operator answered feature escalation", { userTaskKey, resolution, 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;
-  app.log.warn("answer-escalation: not completed", { userTaskKey, reason: r.reason });
-  return { status, body: { ok: false, error: r.reason } };
-});