muse-crew 0.4.3 → 0.4.4

package/workflows/tests/retry-cap.test.mjs

@@ -0,0 +1,102 @@
+// Focused tests for the dispatcher's explicit retry-cap decision and the
+// rejection budget. The retry policy consumes task.retry.consecutive_failures
+// and task.retry.rejections_since_reset (explicit, dashboard-owned state)
+// via decideRetry — no history projection, no event-message parsing. These
+// tests extract decideRetry from the real crew-dispatch.js source and assert
+// its behavior, plus structural properties of the dispatcher (the LLM history
+// fetch and "[retry-cap]" marker machinery must be gone; parking must go
+// through the atomic parktask action).
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import assert from "node:assert/strict";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const src = readFileSync(join(here, "..", "crew-dispatch.js"), "utf8");
+
+// Extract decideRetry's source and evaluate it in isolation.
+const m = src.match(/function decideRetry\(consecutiveFailures, maxFailures\) \{[\s\S]*?\n\}/);
+assert.ok(m, "decideRetry function not found in crew-dispatch.js");
+const decideRetry = new Function(m[0] + "\nreturn decideRetry;")();
+
+// Behavior: park at the cap, retry below it.
+assert.equal(decideRetry(0, 3), "retry");
+assert.equal(decideRetry(1, 3), "retry");
+assert.equal(decideRetry(2, 3), "retry");
+assert.equal(decideRetry(3, 3), "park");
+assert.equal(decideRetry(4, 3), "park");
+assert.equal(decideRetry(10, 3), "park");
+
+// Behavior: fail open on missing/invalid state — an older dashboard
+// (no retry field) must never strand a task.
+assert.equal(decideRetry(undefined, 3), "retry");
+assert.equal(decideRetry(null, 3), "retry");
+assert.equal(decideRetry("3", 3), "retry");
+assert.equal(decideRetry(NaN, 3), "retry");
+assert.equal(decideRetry(-1, 3), "retry");
+
+// Behavior: cap of 1 parks on the first failure.
+assert.equal(decideRetry(0, 1), "retry");
+assert.equal(decideRetry(1, 1), "park");
+
+// Behavior: a non-positive cap disables the cap entirely — decideRetry
+// owns this, not the caller. (Regression: the old RETRY_CAP_ENABLED gate
+// meant decideRetry(5, 0) wrongly returned "park".)
+assert.equal(decideRetry(0, 0), "retry");
+assert.equal(decideRetry(5, 0), "retry");
+assert.equal(decideRetry(5, -1), "retry");
+assert.equal(decideRetry(100, -10), "retry");
+
+// Structure: the old machinery is gone.
+assert.ok(!src.includes("function countConsecutiveFailures"),
+  "countConsecutiveFailures must be deleted");
+assert.ok(!src.includes("park_after"),
+  "park_after watermark map must be deleted");
+assert.ok(!src.includes("getState"),
+  "LLM-mediated getState history fetch must be deleted");
+assert.ok(!src.includes("RETRY_CAP_ENABLED"),
+  "RETRY_CAP_ENABLED gate must be deleted (decideRetry owns the disabled-cap case)");
+assert.ok(!/\[retry-cap\]/.test(src.replace(/\/\/.*$/gm, "")),
+  "[retry-cap] marker must not be written (comment mentions are fine)");
+
+// Structure: the dispatcher reads the explicit fields.
+assert.ok(src.includes("rc.task.retry"),
+  "dispatcher must read task.retry from getdispatchstate");
+assert.ok(src.includes("consecutive_failures"),
+  "dispatcher must consume consecutive_failures");
+assert.ok(src.includes("rejections_since_reset"),
+  "dispatcher must consume rejections_since_reset");
+assert.ok(src.includes("maxConsecutiveRejections"),
+  "dispatcher must read the maxConsecutiveRejections config key");
+assert.ok(src.includes("rejectionCandidates"),
+  "dispatcher must budget rejection candidates before re-dispatching to rework");
+
+// Structure: parking goes through the atomic parktask action — the park
+// batch must not do the two-step updatetask+logevent dance.
+const parkBatch = src.match(/\/\/ Batch all parks into one agent call[\s\S]*?^}/m);
+assert.ok(parkBatch, "park batch block not found");
+assert.ok(parkBatch[0].includes('action \\"parktask\\"'),
+  "dispatcher park batch must use the atomic parktask action");
+assert.ok(!parkBatch[0].includes('action \\"updatetask\\"') && !parkBatch[0].includes('action \\"logevent\\"'),
+  "dispatcher park batch must not do the two-step updatetask+logevent dance");
+
+// Structure: no workflow authors {status:"blocked"} anymore; each
+// workflow parks through the atomic parktask action with a safety net.
+for (const wf of ["standard.js", "bugfix.js", "chore.js", "docs.js"]) {
+  const wsrc = readFileSync(join(here, "..", wf), "utf8");
+  assert.ok(!wsrc.includes('{ status: "blocked"'),
+    `${wf} must not author {status:"blocked"}`);
+  assert.ok(wsrc.includes("async function parkTask(reason)"),
+    `${wf} must define parkTask`);
+  const parkFn = wsrc.match(/async function parkTask\(reason\) \{[\s\S]*?\n\}/);
+  assert.ok(parkFn, `${wf} parkTask not found`);
+  assert.ok(parkFn[0].includes('action \\"parktask\\"'),
+    `${wf} parkTask must use the atomic parktask action`);
+  assert.ok(!parkFn[0].includes('action \\"logevent\\"') && !parkFn[0].includes('action \\"updatetask\\"'),
+    `${wf} parkTask must not do the two-step logevent+updatetask dance (parktask is atomic)`);
+  assert.ok(/catch \(parkErr\)/.test(parkFn[0]),
+    `${wf} parkTask must catch a throwing park call and report failed, never lose the park silently`);
+}
+
+console.log("retry-cap tests: all assertions passed");

package/workflows/tests/work-agent-failure.test.mjs

@@ -0,0 +1,122 @@
+// Regression tests for honest work-agent failure classification.
+//
+// The workflow records per-attempt evidence (threw vs returned-empty, error
+// text, durations) in the session notes when a work agent yields no usable
+// report. These tests extract describeWorkAgentFailure and
+// buildTransportRetryTrailer from the real workflow sources and assert the
+// classification behavior — the same extract-and-evaluate pattern as
+// retry-cap.test.mjs. All four workflows carrying the logic (standard,
+// bugfix, chore, docs) are tested so the duplicated copies cannot drift.
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import assert from "node:assert/strict";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const files = ["standard.js", "bugfix.js", "chore.js", "docs.js"];
+
+function extract(src, name, params) {
+  // Brace-counting extraction: find "function <name>(<params>) {" and scan
+  // to the matching close brace. Robust against inner blocks; the regex
+  // approach stops at the first inner "};" line.
+  const startRe = new RegExp("[ ]*function " + name + "\\(" + params + "\\) \\{");
+  const m = src.match(startRe);
+  assert.ok(m, name + " function not found");
+  const start = m.index;
+  let depth = 0;
+  let i = start + m[0].length - 1; // at the opening brace
+  for (; i < src.length; i++) {
+    if (src[i] === "{") depth++;
+    else if (src[i] === "}") {
+      depth--;
+      if (depth === 0) return src.slice(start, i + 1);
+    }
+  }
+  assert.fail(name + ": unbalanced braces");
+}
+
+for (const file of files) {
+  const src = readFileSync(join(here, "..", file), "utf8");
+
+  const describeWorkAgentFailure = new Function(
+    extract(src, "describeWorkAgentFailure", "stepName, identity, attempts") +
+      "\nreturn describeWorkAgentFailure;"
+  )();
+
+  // Case 1: agent() threw on every attempt — the runtime discarded the
+  // output. The notes must say the output was discarded (not "produced no
+  // output"), carry the surviving error text, and carry per-attempt
+  // evidence. The old false claim ("preserved in run record") must be gone.
+  {
+    const attempts = [
+      { threw: true, error: "JSON parse failed near '{/*'", outcome: "", ms: 45231 },
+      { threw: true, error: "JSON parse failed near '{/*'", outcome: "", ms: 38900 },
+      { threw: true, error: "JSON parse failed near '{/*'", outcome: "", ms: 51200 },
+    ];
+    const r = describeWorkAgentFailure("Build", "wren", attempts);
+    assert.ok(r.notes.includes("no machine-readable report"), file + ": throw case notes");
+    assert.ok(r.notes.includes("runtime discarded the output"), file + ": throw case says discarded");
+    assert.ok(r.notes.includes("JSON parse failed"), file + ": throw case keeps error text");
+    assert.ok(r.notes.includes("attempt 1/3"), file + ": throw case numbers attempts");
+    assert.ok(r.notes.includes("45231ms"), file + ": throw case records durations");
+    assert.ok(!r.notes.includes("preserved in run record"), file + ": false preservation claim gone from notes");
+    assert.ok(!r.message.includes("preserved in run record"), file + ": false preservation claim gone from message");
+    assert.ok(r.eventMessage.includes("dispatcher will retry"), file + ": throw case stays retryable");
+    assert.ok(r.blockedReason.includes("3 attempts"), file + ": throw case blocked reason counts attempts");
+  }
+
+  // Case 2: agent() returned empty without throwing — the child produced
+  // nothing. The notes must not claim a throw/discarded output; they record
+  // what each attempt returned and how long it took.
+  {
+    const attempts = [
+      { threw: false, error: "", outcome: "blank string", ms: 11000 },
+      { threw: false, error: "", outcome: "null", ms: 9500 },
+      { threw: false, error: "", outcome: "blank string", ms: 10200 },
+    ];
+    const r = describeWorkAgentFailure("Build", "wren", attempts);
+    assert.ok(r.notes.includes("no usable output"), file + ": empty case notes");
+    assert.ok(!r.notes.includes("discarded"), file + ": empty case does not claim discard");
+    assert.ok(r.notes.includes("returned blank string"), file + ": empty case records outcome");
+    assert.ok(r.notes.includes("returned null"), file + ": empty case records null outcome");
+    assert.ok(r.notes.includes("11000ms"), file + ": empty case records durations");
+    assert.ok(r.eventMessage.includes("dispatcher will retry"), file + ": empty case stays retryable");
+  }
+
+  // Case 3: mixed attempts — any throw takes the discarded-output branch,
+  // and the detail covers every attempt.
+  {
+    const attempts = [
+      { threw: true, error: "boom", outcome: "", ms: 5000 },
+      { threw: false, error: "", outcome: "blank string", ms: 11000 },
+    ];
+    const r = describeWorkAgentFailure("QA", "hazel", attempts);
+    assert.ok(r.notes.includes("no machine-readable report"), file + ": mixed case takes throw branch");
+    assert.ok(r.notes.includes("threw 'boom'"), file + ": mixed case detail has the throw");
+    assert.ok(r.notes.includes("returned blank string"), file + ": mixed case detail has the empty");
+    assert.ok(r.notes.includes("attempt 2/2"), file + ": mixed case numbers against total");
+  }
+
+  // Case 4: the trailer names the failure mode of the previous attempt.
+  const buildTransportRetryTrailer = new Function(
+    extract(src, "buildTransportRetryTrailer", "stepName, repoPath, taskId, attempt, reason") +
+      "\nreturn buildTransportRetryTrailer;"
+  )();
+  {
+    const tEmpty = buildTransportRetryTrailer("Build", "/repo", "task-1", 1, "empty");
+    assert.ok(tEmpty.includes("no usable output"), file + ": empty trailer names empty failure");
+    assert.ok(tEmpty.includes("attempt 1 of 2"), file + ": trailer numbers the retry");
+    const tDiscarded = buildTransportRetryTrailer("Build", "/repo", "task-1", 2, "discarded");
+    assert.ok(tDiscarded.includes("could not be machine-read"), file + ": discarded trailer names discard");
+    const tDefault = buildTransportRetryTrailer("Build", "/repo", "task-1", 1);
+    assert.ok(tDefault.includes("could not be machine-read"), file + ": trailer defaults to discard wording");
+  }
+
+  // Source-level: the old vocabulary is gone everywhere.
+  assert.ok(!src.includes("preserved in run record"), file + ": no false preservation claim in source");
+  assert.ok(!src.includes("workerTransportError"), file + ": single-error variable replaced by attempts array");
+  assert.ok(!src.includes("Work agent failed with no output"), file + ": undifferentiated message gone");
+}
+
+console.log("work-agent-failure: all assertions passed for " + files.join(", "));