@nanobpm/nano-workforce 0.200.8 → 0.200.9

package/resources/prompts/feature.md

@@ -18,6 +18,19 @@ The job payload (stdin JSON) carries:
 
 You have `gh` / git authenticated for the target repository.
 
+## Workspace confinement — work ONLY inside your run workspace
+
+Your run has a private workspace directory (the git repository you start in — the
+clone/worktree the harness checked out for you). **Do all your work there.** Never
+`cd /tmp/<repo>`, clone into a shared path, or edit files outside your workspace:
+that directory is torn down when your run ends, so edits made elsewhere are
+**silently lost** (and can collide with a sibling run sharing the path). If you
+need the repo, use the one you are already in — do not clone a second copy into
+`/tmp`. A completion that leaves no commit on `feat/<task.id>` and no PR is treated
+as a **failed, undelivered attempt** (see the reconcile/escalation behaviour the
+app applies), so your work must land in a pushed commit on your branch, nowhere
+else.
+
 ## Your branch (deterministic — the same across a resume)
 
 Always use the branch **`feat/<task.id>`**. Because a resumed run gets a fresh
@@ -192,7 +205,9 @@ Write a JSON object of **result variables** to the file named by the
 
 Rules:
 
-- `status` — one of:
+- `status` — one of EXACTLY these four tokens (any other value — e.g.
+  `completed`, `done`, `success` — is **off-vocabulary**: the app cannot route on
+  it and will treat your slice as **not delivered**, so never invent one):
   - `opened` — a PR was created (ready for review). Set `pr`.
   - `escalated` — you need a human decision; set `question`, and set `pr` to the
     **draft** PR you opened to preserve your work (if you managed to open one).

package/workers/reconcile-implement/worker.test.ts

@@ -28,7 +28,7 @@ test("adopts an open PR on the branch: emits reconciled + status=opened + pr", a
       { jobKey: "j1", variables: { subjectKey: "owner/repo#801", task: { id: "issue-801" }, status: null } } as never,
       fakeApp,
     );
-    assertEquals(out, { reconciled: true, status: "opened", pr: "owner/repo#801" });
+    assertEquals(out, { reconciled: true, status: "opened", pr: "owner/repo#801", retry: false, retryNudge: null, retried: false, deliveryVerified: true });
   } finally {
     globalThis.fetch = prevFetch;
     if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
@@ -54,7 +54,7 @@ test("wires baseBranch through: a wrong-base open PR is NOT adopted → escalate
       { jobKey: "j3", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null, baseBranch: "epic/feat-x" } } as never,
       fakeApp,
     );
-    assertEquals(out, { reconciled: false, status: null, pr: null });
+    assertEquals(out, { reconciled: false, status: null, pr: null, retry: false, retryNudge: null, retried: false, deliveryVerified: true });
   } finally {
     globalThis.fetch = prevFetch;
     if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
@@ -76,7 +76,35 @@ test("no open PR on the branch: falls through to escalate (reconciled=false)", a
       { jobKey: "j2", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null } } as never,
       fakeApp,
     );
-    assertEquals(out, { reconciled: false, status: null, pr: null });
+    assertEquals(out, { reconciled: false, status: null, pr: null, retry: false, retryNudge: null, retried: false, deliveryVerified: true });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});
+
+test("claimed-completion (off-vocabulary status) + no PR → auto-retry once with a nudge (issue #865)", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  globalThis.fetch = (async () => new Response(JSON.stringify([]), { status: 200 })) as typeof fetch;
+  try {
+    const out = await handler(
+      {
+        jobKey: "j4",
+        variables: { subjectKey: "owner/repo#41", task: { id: "issue-41" }, status: "completed" },
+      } as never,
+      fakeApp,
+    );
+    assertEquals(out.reconciled, false);
+    assertEquals(out.retry, true);
+    assertEquals(out.retried, true);
+    assertEquals(typeof out.retryNudge === "string" && out.retryNudge.length > 0, true);
   } finally {
     globalThis.fetch = prevFetch;
     if (prevToken === undefined) delete process.env.GITHUB_TOKEN;

package/workers/reconcile-implement/worker.ts

@@ -28,6 +28,8 @@ interface In extends Record<string, unknown> {
   status?: unknown;
   pr?: unknown;
   baseBranch?: unknown;
+  question?: unknown;
+  implementRetried?: unknown;
 }
 
 /** The cell's deterministic branch is `feat/<task.id>`; `task` is the implement-cell's slice object.
@@ -45,6 +47,8 @@ const handler: AppJobHandler<In, ReconcileImplementResult> = async (job, app) =>
       taskId: taskId(job.variables.task),
       pr: job.variables.pr,
       baseBranch: job.variables.baseBranch,
+      question: job.variables.question,
+      retried: job.variables.implementRetried,
     },
     listPrsForHead,
     process.env.GITHUB_TOKEN ?? "",
@@ -52,6 +56,7 @@ const handler: AppJobHandler<In, ReconcileImplementResult> = async (job, app) =>
   app.log.info("reconcile-implement", {
     subjectKey: job.variables.subjectKey ?? null,
     reconciled: res.reconciled,
+    retry: res.retry,
     pr: res.pr,
   });
   return res;

package/workers/record-feature-escalation/worker.test.ts

@@ -97,14 +97,43 @@ test("no-result: a missing status/question synthesises the #360 answerable quest
   assertEquals(app.stores.feature_escalations[0].question, NO_RESULT_QUESTION);
 });
 
-test("blank-question escalated: still synthesises the #360 question (never a dead-end task)", async () => {
+test("blank-question escalated: synthesises an ACCURATE reported-status reason, not the false no-result text (#865 review)", async () => {
+  // A reported `escalated` with a blank question reaches the builder. It must name the reported status
+  // accurately — never the false "no status was reported" (no-result) diagnosis — and never dead-end.
   const app = fakeApp([]);
   const out = await handler(
     { jobKey: "job-b", variables: { subjectKey: "owner/repo#2", status: "escalated", question: "   " } } as never,
     app,
   );
-  assertEquals(out, { question: NO_RESULT_QUESTION });
-  assertEquals(app.stores.feature_escalations[0].question, NO_RESULT_QUESTION);
+  assertEquals(out.question.includes('reported status "escalated"'), true);
+  assertEquals(out.question.includes("gave no answerable question"), true);
+  assertEquals(out.question.includes("without a machine-readable result"), false);
+  assertEquals(app.stores.feature_escalations[0].question, out.question);
+});
+
+test("escalated with a question + summary + transcript: preserves ALL context, not just the question (#865 review)", async () => {
+  // The #865-review defect: an `escalated` result carrying a question, summary, and transcript persisted
+  // ONLY the question, leaving pollUserTasks without the supporting decision context.
+  const rows = [{ feature_key: "owner/repo#9", status: "running" }];
+  const app = fakeApp(rows);
+  const out = await handler(
+    {
+      jobKey: "job-9",
+      variables: {
+        subjectKey: "owner/repo#9",
+        status: "escalated",
+        question: "Should I target the epic base or main?",
+        summary: "drafted the migration but the base is ambiguous",
+        transcriptUrl: "http://merlin.local:3000/t?stream=job%3A777",
+      },
+    } as never,
+    app,
+  );
+  assertEquals(out.question.startsWith("Should I target the epic base or main?"), true);
+  assertEquals(out.question.includes('The agent\'s own summary: "drafted the migration but the base is ambiguous".'), true);
+  assertEquals(out.question.includes("Transcript: http://merlin.local:3000/t?stream=job%3A777"), true);
+  assertEquals(rows[0].status, "escalated");
+  assertEquals(app.stores.feature_escalations[0].question, out.question);
 });
 
 test("fails fast (incident) when subjectKey is absent — never appends a corrupt undefined-keyed audit row", async () => {
@@ -132,3 +161,29 @@ test("a retried job (same jobKey) reuses its audit row, never duplicating", asyn
   assertEquals(app.stores.feature_escalations.length, 1, "the retry reuses the row, no duplicate append");
   assertEquals(app.stores.feature_escalations[0].job_key, "job-retry");
 });
+
+test("claimed-completion (off-vocabulary status) with no question: accurate reason, not the false no-result text (issue #865)", async () => {
+  // The #865 defect reproduction: the agent reported `status: "completed"` with a summary but no PR.
+  // The synthesised reason must name the reported status + fold in the summary and transcript link —
+  // never the false "no status was reported" diagnosis.
+  const rows = [{ feature_key: "owner/repo#41", status: "running" }];
+  const app = fakeApp(rows);
+  const out = await handler(
+    {
+      jobKey: "job-41",
+      variables: {
+        subjectKey: "owner/repo#41",
+        status: "completed",
+        summary: "implemented src/pin.rs and supporting changes",
+        transcriptUrl: "http://merlin.local:3000/t?stream=job%3A215572",
+      },
+    } as never,
+    app,
+  );
+  assertEquals(out.question.includes('reported status "completed"'), true);
+  assertEquals(out.question.includes("without a machine-readable result"), false);
+  assertEquals(out.question.includes('The agent\'s own summary: "implemented src/pin.rs and supporting changes".'), true);
+  assertEquals(out.question.includes("Transcript: http://merlin.local:3000/t?stream=job%3A215572"), true);
+  assertEquals(rows[0].status, "escalated");
+  assertEquals(app.stores.feature_escalations[0].question, out.question);
+});

package/workers/record-feature-escalation/worker.ts

@@ -25,6 +25,7 @@
 import type { AppJobHandler } from "@nanobpm/urban";
 import { classifyEscalation } from "../../app/escalationTaxonomy.ts";
 import { featureRuns, recordFeatureEscalation } from "../../app/feature.ts";
+import { implementEscalationQuestion, NO_RESULT_QUESTION } from "../../app/implementEscalationReason.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
 // Input typed off the model data envelope (`RecordEscalationIn` in implement-cell.bpmn) — ADR 0040.
@@ -36,12 +37,6 @@ interface Out extends Record<string, unknown> {
 const str = (v: unknown): string | undefined =>
   typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
 
-// The answerable prompt synthesised when the agent left no usable question — the implement-stage
-// analogue of record-trial-merge's synthesised trial-merge question. It names the recoverable work (a
-// PR may exist on the slice's branch) and the two answers the cell's `ic_gw_answer` gateway routes on.
-const NO_RESULT_QUESTION =
-  'The implementation agent finished without a machine-readable result (no status was reported), so we cannot tell whether the slice succeeded. It may still have opened a PR (check for a branch targeting the epic base). Choose "Answer" and give guidance to re-run the slice — or choose "Abandon" to skip it and continue.';
-
 const handler: AppJobHandler<In, Out> = async (job, app) => {
   const subjectKey = job.variables.subjectKey;
   // Fail fast rather than keying the `feature_escalations` audit log (and the guarded `feature_runs`
@@ -61,11 +56,30 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   // so the parked task is never a dead end. Route through the single canonical taxonomy so this net can
   // never drift from the tier logic every other raise site uses. A "task"-kind escalation is
   // `decision-required` only when the agent left an answerable question, so this already covers the
-  // blank-question case; the extra `&& rawQuestion` is the type narrowing that lets us hand the string
-  // through without an assertion.
+  // blank-question case.
   const agentEscalated = classifyEscalation({ kind: "task", status: job.variables.status, question: rawQuestion }) ===
     "decision-required";
-  const question = agentEscalated && rawQuestion ? rawQuestion : NO_RESULT_QUESTION;
+  // Build the escalation question through the single canonical builder (issue #865), ALWAYS — including
+  // when the agent raised its own answerable question. Passing the agent's `question` lets the builder
+  // lead with it AND fold in the agent's `summary` + transcript as supporting context (#865 review —
+  // otherwise an `escalated` result's summary/transcript were dropped and only the bare question
+  // survived). With no answerable question it synthesises an accurate reason — distinguishing a true
+  // no-result (blank status) from a claimed-completion-without-delivery (an affirmative-completion alias
+  // such as `completed`) and from a reported non-completion status — never the false "no status was
+  // reported" diagnosis for a reported `escalated`/`failed` (#865 review). The reason can never drift
+  // from the reconcile step because both read the same canonical builder.
+  const question = implementEscalationQuestion({
+    status: job.variables.status,
+    question: rawQuestion,
+    summary: job.variables.summary,
+    transcriptUrl: job.variables.transcriptUrl,
+    // Delivery EVIDENCE (#865 review): the preserved PR (an `escalated`/`failed` with a blank question
+    // retains it — never claim "opened no pull request") and whether the reconcile step's GitHub lookup
+    // actually CONFIRMED the delivery state (only then may the reason say "none was found"). Both are
+    // process variables the upstream `reconcile-implement` step emits into scope.
+    pr: job.variables.pr,
+    deliveryVerified: job.variables.deliveryVerified,
+  });
 
   // Append to the canonical `feature_escalations` audit log (the surviving table `pollUserTasks` reads),
   // keyed by `subjectKey` — the feature run's `feature_key`, or the epic's `plan_key` for a wave slice.
@@ -79,7 +93,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     await runs.update(subjectKey, { status: "escalated", updated_at: new Date().toISOString() });
   }
 
-  app.log.info("record-escalation", { subjectKey, synthesised: question === NO_RESULT_QUESTION });
+  app.log.info("record-escalation", { subjectKey, synthesised: !(agentEscalated && rawQuestion) });
 
   // Re-emit the resolved question so the `feature-escalation` form (and the answer loop) see it.
   return { question };