@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/goals/loop.test.mjs

@@ -1,845 +0,0 @@
-/**
- * lib/goals/loop.test.mjs — the reconciliation loop, end to end, with every
- * seam injected: clock, mandate cache, sensors, capability manifest, peers,
- * planner, budget, and all five collaboration primitives.
- *
- * Nothing here touches the network or a real agent repo beyond a scratch tmpdir.
- *
- * The negative cases are the point:
- *   - no mandate at all / corrupt mandate           → refuses, records drift
- *   - proposed-but-not-adopted objectives           → measures nothing, creates nothing
- *   - a self-adopted objective (the Goodhart hole)  → excluded
- *   - an `llm`-sourced sample                       → advisory, creates NO work
- *   - a capability the manifest says is unreachable → drift, never a fabricated 0
- *   - no budget left                                → refused at the rung gate
- *   - an unreachable server                         → fails open, work still queued
- *   - a stale mandate cache                         → OUTCOME work suspended
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  runGoalSteward,
-  renderQueueItems,
-  appendBacklogItems,
-  openItemsFor,
-  journalRealizedDeltas,
-  defaultProposeCandidates,
-  GOALS_QUEUE_REL,
-  PROPOSED_REL,
-} from "./loop.mjs";
-import { parseQueueItems } from "../backlog.mjs";
-import { readInterventions } from "../kpi.mjs";
-
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-
-const NOW = Date.parse("2026-08-11T09:00:00.000Z");
-const SELF = "mem_self";
-const BOSS = "mem_boss";
-const PEER = "mem_peer";
-
-function makeRoot() {
-  const root = mkdtempSync(join(tmpdir(), "goal-loop-"));
-  mkdirSync(join(root, "state", "kpi"), { recursive: true });
-  mkdirSync(join(root, "state", "queues"), { recursive: true });
-  return root;
-}
-
-/** A structurally valid, freshly-fetched, properly-adopted mandate. */
-function mandate(overrides = {}) {
-  const objectives = overrides.objectives || [
-    {
-      key: "revenue",
-      kind: "PILLAR",
-      state: "active",
-      text: "Own the revenue line",
-      charterSectionId: "cs_12",
-      adoptedById: BOSS,
-    },
-    {
-      key: "pipeline-coverage",
-      kind: "OBJECTIVE",
-      parentKey: "revenue",
-      state: "active",
-      metric: "pipeline_coverage_x",
-      unit: "x",
-      target: 3,
-      direction: "up",
-      tolerance: 0.2,
-      cadence: "weekly",
-      sensor: { capability: "crm_list_deals", source: "method", params: { stage: "open" } },
-      adoptedById: BOSS,
-    },
-  ];
-  return {
-    version: 4,
-    checksum: "sha256:test",
-    source: "hq",
-    // Fresh by default: staleness ladder gives OUTCOME work "full".
-    fetchedAt: new Date(NOW - 3600_000).toISOString(),
-    body: { memberId: SELF, objectives },
-    ...(overrides.record || {}),
-  };
-}
-
-/** Seed a measurement series so the loop has history (and a trend) to read. */
-function seedSeries(root, objectiveKey, rows) {
-  const p = join(root, "state", "kpi", "measurements.jsonl");
-  const body = rows.map((r) => JSON.stringify({ objectiveKey, ...r })).join("\n");
-  writeFileSync(p, body + "\n", "utf-8");
-}
-
-/** Collect every primitive call so a test can assert on routing, not mocks. */
-function spyDeps(extra = {}) {
-  const calls = { board: [], handoff: [], approval: [], lease: [], rpc: [], samples: [] };
-  return {
-    calls,
-    deps: {
-      memberId: SELF,
-      now: () => NOW,
-      log: () => {},
-      reachable: new Set(["crm_list_deals"]),
-      remainingCents: 10_000,
-      createItem: async (payload) => {
-        calls.board.push(payload);
-        return { ok: true, result: { id: `bi_${calls.board.length}` } };
-      },
-      sendHandoff: async (o) => {
-        calls.handoff.push(o);
-        return { sent: true, runId: "run_1", transport: { reason: "offered" } };
-      },
-      requestApproval: async (o) => {
-        calls.approval.push(o);
-        return { requested: true, id: "appr_1" };
-      },
-      claimLease: async (scope, resourceId) => {
-        calls.lease.push({ scope, resourceId });
-        return { held: true, leaseToken: "lease_1" };
-      },
-      callImpl: async (method, params) => {
-        calls.rpc.push({ method, params });
-        return { ok: true, result: { id: "x_1" } };
-      },
-      mirrorSample: async (s) => { calls.samples.push(s); },
-      ...extra,
-    },
-  };
-}
-
-/** A sensor registry that returns a fixed reading. */
-function sensors(value) {
-  return { crm_list_deals: async () => ({ value, rowCount: 12 }) };
-}
-
-function cleanup(root) {
-  try { rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ }
-}
-
-// ---------------------------------------------------------------------------
-// Pure helpers
-// ---------------------------------------------------------------------------
-
-test("renderQueueItems round-trips through the parser the daemon actually uses", () => {
-  const rendered = renderQueueItems([
-    {
-      id: "goal-pipeline-coverage-2026-W33-1",
-      title: 'Close the gap: raise "coverage" from 1.5 to 3',
-      status: "open",
-      priority: "high",
-      next_action: "Book 6 discovery calls",
-      advances: ["pipeline-coverage"],
-      expected_delta: 0.75,
-      obligation_key: "outcome.pipeline-coverage",
-      disposition: "SELF",
-      rung: 3,
-      why: { reason: "kpi-gap" },
-      created: "2026-08-11",
-    },
-  ]);
-  const parsed = parseQueueItems(`queue: goals\nitems:\n${rendered}\n`, "goals.yaml");
-  assert.equal(parsed.length, 1);
-  const item = parsed[0];
-  // The id extraction is what makes the claim subsystem work at all.
-  assert.equal(item.id, "goal-pipeline-coverage-2026-W33-1");
-  assert.equal(item.priority, "high");
-  // The D3 provenance fields must survive the round trip, or the daemon's
-  // gap-weighted ranking is dead code.
-  assert.deepEqual(item.advances, ["pipeline-coverage"]);
-  assert.equal(item.expected_delta, 0.75);
-  assert.equal(item.obligation_key, "outcome.pipeline-coverage");
-  assert.equal(item.disposition, "SELF");
-});
-
-test("openItemsFor only counts open work on the named objective", () => {
-  const root = makeRoot();
-  try {
-    appendBacklogItems(root, [
-      { id: "a", title: "A", status: "open", advances: ["obj-1"], created: "2026-08-11" },
-      { id: "b", title: "B", status: "done", advances: ["obj-1"], created: "2026-08-11" },
-      { id: "c", title: "C", status: "open", advances: ["obj-2"], created: "2026-08-11" },
-    ]);
-    assert.equal(openItemsFor(root, "obj-1").length, 1);
-    assert.equal(openItemsFor(root, "obj-2").length, 1);
-    assert.equal(openItemsFor(root, "obj-3").length, 0);
-  } finally { cleanup(root); }
-});
-
-test("appendBacklogItems is a no-op for an empty list and never throws on a bad root", () => {
-  const r = appendBacklogItems("/nonexistent/path/that/cannot/exist", [], {});
-  assert.equal(r.written, 0);
-  assert.equal(r.ok, true);
-});
-
-test("the default planner aims at half the gap and marks a repeat failure open-ended", () => {
-  const a = defaultProposeCandidates({
-    objective: { key: "k", metric: "m", direction: "up", target: 3, cadence: "weekly" },
-    gap: { gap: 1.5, value: 1.5, target: 3, trend: "flat" },
-    interventions: [],
-  });
-  assert.equal(a[0].expectedDelta, 0.75);
-  assert.equal(a[0].need.openEnded, false);
-
-  const b = defaultProposeCandidates({
-    objective: { key: "k", metric: "m", direction: "up", target: 3 },
-    gap: { gap: 1.5, value: 1.5, target: 3, trend: "flat" },
-    // A prior intervention that went backwards must change the plan, not repeat it.
-    interventions: [{ realizedDelta: -0.2 }],
-  });
-  assert.equal(b[0].need.openEnded, true);
-  assert.equal(b[0].why.priorFailedInterventions, 1);
-});
-
-// ---------------------------------------------------------------------------
-// Loop: refusal paths (nothing to steward)
-// ---------------------------------------------------------------------------
-
-test("no mandate cache: the loop refuses, records drift, and creates nothing", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps();
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: null, enforcement: "active" });
-    assert.equal(r.ok, false);
-    assert.match(r.skipped, /never fetched an adopted mandate/);
-    assert.equal(r.drift[0].kind, "mandate_stale");
-    assert.equal(r.created, 0);
-    assert.equal(existsSync(join(root, GOALS_QUEUE_REL)), false);
-  } finally { cleanup(root); }
-});
-
-test("corrupt mandate cache is reported as corrupt, not treated as empty", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps();
-    const r = await runGoalSteward({
-      ...deps, agentRoot: root, enforcement: "active",
-      cacheRecord: { corrupt: true, reason: "Unexpected token }", body: {} },
-    });
-    assert.equal(r.ok, false);
-    assert.match(r.skipped, /corrupt/);
-    assert.equal(r.created, 0);
-  } finally { cleanup(root); }
-});
-
-test("PROPOSED objectives drive no work at all — no measurement, no backlog", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.0) });
-    const record = mandate({
-      objectives: [
-        { key: "revenue", kind: "PILLAR", state: "active", charterSectionId: "cs_1", adoptedById: BOSS },
-        {
-          key: "pipeline-coverage", kind: "OBJECTIVE", parentKey: "revenue",
-          // Proposed, never adopted by a human.
-          state: "proposed",
-          metric: "pipeline_coverage_x", target: 3, direction: "up", cadence: "weekly",
-          sensor: { capability: "crm_list_deals", source: "method" },
-        },
-      ],
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-    assert.equal(r.skipped, "no adopted objectives");
-    assert.equal(r.measured.length, 0);
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-  } finally { cleanup(root); }
-});
-
-test("a SELF-ADOPTED objective is excluded — a seat cannot grade its own number", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({ sensors: sensors(1.0) });
-    const record = mandate({
-      objectives: [
-        { key: "revenue", kind: "PILLAR", state: "active", charterSectionId: "cs_1", adoptedById: BOSS },
-        {
-          key: "pipeline-coverage", kind: "OBJECTIVE", parentKey: "revenue", state: "active",
-          metric: "pipeline_coverage_x", target: 3, direction: "up", cadence: "weekly",
-          sensor: { capability: "crm_list_deals", source: "method" },
-          // The Goodhart hole: adopted by the very seat it grades.
-          adoptedById: SELF,
-        },
-      ],
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-    assert.equal(r.skipped, "no adopted objectives");
-    assert.ok(
-      r.validation.errors.some((e) => /self-adopted/.test(e)),
-      "the self-adoption must be reported as a validation error, not silently dropped"
-    );
-  } finally { cleanup(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Loop: the happy path and the observe-only default
-// ---------------------------------------------------------------------------
-
-test("observe-only (the default): a real gap produces candidates and ZERO tasks", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5) });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate() });
-
-    assert.equal(r.enforcement, "observe");
-    assert.equal(r.measured[0].value, 1.5);
-    assert.equal(r.measured[0].source, "method");
-    assert.equal(r.admitted.length, 1);
-    assert.equal(r.admitted[0].observed, true);
-    // The whole point of the observe window.
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0, "observe-only must not create a board item");
-    assert.equal(existsSync(join(root, GOALS_QUEUE_REL)), false);
-    // …but the proposal IS recorded, so a human can review what it would do.
-    const proposed = readFileSync(join(root, PROPOSED_REL), "utf-8").trim().split("\n").map(JSON.parse);
-    assert.equal(proposed.length, 1);
-    assert.equal(proposed[0].item.objectiveKey, "pipeline-coverage");
-    assert.equal(proposed[0].provenance.clause, "cs_12");
-  } finally { cleanup(root); }
-});
-
-test("enforcement:active turns a measured gap into a routed, provenance-linked backlog item", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5) });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.created, 1);
-    assert.equal(r.admitted.length, 1);
-    assert.equal(r.routed[0].routed, "SELF");
-    assert.equal(r.routed[0].ok, true);
-
-    // The sample was mirrored to hq.
-    assert.equal(calls.samples.length, 1);
-    assert.equal(calls.samples[0].window, "2026-W33");
-
-    // The board item carries the full causal chain — this is what makes a
-    // machine-created task legible to a human.
-    assert.equal(calls.board.length, 1);
-    const why = calls.board[0].why;
-    assert.equal(why.reason, "kpi-gap");
-    assert.equal(why.clause, "cs_12");
-    // hq's `why` block is CLOSED ({reason, options, clause, wouldChange}); the
-    // keys it has no column for ride in `detail` rather than being sent and
-    // silently dropped — or, as before this fix, rejected BAD_REQUEST wholesale.
-    const detail = calls.board[0].detail;
-    assert.match(detail, /Advances objective: pipeline-coverage/);
-    assert.match(detail, /Obligation: outcome\.pipeline-coverage/);
-    assert.equal(calls.board[0].assigneeId, SELF);
-
-    // And the local queue item the backlog-executor will sweep.
-    const parsed = parseQueueItems(readFileSync(join(root, GOALS_QUEUE_REL), "utf-8"), "goals.yaml");
-    assert.equal(parsed.length, 1);
-    assert.deepEqual(parsed[0].advances, ["pipeline-coverage"]);
-    assert.equal(parsed[0].obligation_key, "outcome.pipeline-coverage");
-
-    // Every decision is on the audit ledger.
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    const decisions = audit.map((a) => a.decision);
-    for (const d of ["measured", "gap", "disposition", "execution_rung", "routed", "candidate_admitted"]) {
-      assert.ok(decisions.includes(d), `audit must carry a "${d}" line; got ${decisions.join(",")}`);
-    }
-  } finally { cleanup(root); }
-});
-
-test("a gap within tolerance creates nothing", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(2.9) }); // target 3, tolerance 0.2
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.decisions[0].action, "none");
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-  } finally { cleanup(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Loop: the negative cases the spec calls out by name
-// ---------------------------------------------------------------------------
-
-test("MISSING CAPABILITY: an unreachable sensor is drift, never a fabricated zero", async () => {
-  const root = makeRoot();
-  try {
-    // The manifest knows about nothing — so `crm_list_deals` is unreachable.
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5), reachable: new Set() });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.measured[0].ok, false);
-    assert.equal(r.measured[0].reason, "unreachable-capability");
-    assert.ok(r.drift.some((d) => d.kind === "unreachable_capability"));
-    // No measurement means no gap means no work — and critically, no "0".
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-    assert.equal(existsSync(join(root, "state", "kpi", "measurements.jsonl")), false);
-  } finally { cleanup(root); }
-});
-
-test("MISSING CAPABILITY: no sensor implementation registered is reported, not swallowed", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({ sensors: {} });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.measured[0].ok, false);
-    assert.equal(r.measured[0].reason, "no-implementation");
-    assert.equal(r.created, 0);
-  } finally { cleanup(root); }
-});
-
-test("HONESTY GATE: an llm-sourced sample is advisory — it can never create work", async () => {
-  const root = makeRoot();
-  try {
-    // A pre-existing series whose only sample the agent guessed at.
-    seedSeries(root, "pipeline-coverage", [
-      { value: 1.5, window: "2026-W33", at: new Date(NOW - 3600_000).toISOString(), source: "llm" },
-    ]);
-    // No sensor to run, so the loop falls back on the existing series.
-    const { deps, calls } = spyDeps({ sensors: {} });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    // The gap is real and exceeds tolerance…
-    assert.equal(r.gaps[0].withinTolerance, false);
-    assert.equal(r.decisions[0].action, "create");
-    // …but the honesty gate refuses to build work on a self-reported number.
-    assert.equal(r.admitted.length, 0);
-    assert.equal(r.rejected[0].gate, "honesty");
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-  } finally { cleanup(root); }
-});
-
-test("NO BUDGET: an over-envelope candidate is refused at the rung gate and audited", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({
-      sensors: sensors(1.5),
-      // Less than the candidate's estimate: the envelope is exhausted.
-      remainingCents: 5,
-      proposeCandidates: () => [
-        {
-          title: "An expensive move",
-          advances: ["pipeline-coverage"],
-          expectedDelta: 0.75,
-          estCents: 5000,
-          why: { reason: "kpi-gap" },
-          need: { steps: 8 },
-        },
-      ],
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0, "a refused candidate must not create a board item");
-    const budgetRejection = r.rejected.find((x) => x.gate === "budget");
-    assert.ok(budgetRejection, `expected a budget rejection; got ${JSON.stringify(r.rejected)}`);
-
-    // The admission gate catches the over-spend before the rung router does, so
-    // the line is `candidate_rejected` with gate=budget. Either way the refusal
-    // is ON THE RECORD — silent downgrades are the bug class this system keeps
-    // hitting, so assert the audit line exists rather than which stage caught it.
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    assert.ok(
-      audit.some((a) => (a.decision === "budget_refused" || a.decision === "candidate_rejected") && a.detail && a.detail.gate === "budget"),
-      `a budget refusal must leave an audit line; got ${audit.map((a) => a.decision).join(",")}`
-    );
-  } finally { cleanup(root); }
-});
-
-test("NO BUDGET: the rung router's own budget gate enqueues rather than silently downgrading", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({
-      sensors: sensors(1.5),
-      remainingCents: 100,
-      proposeCandidates: () => [
-        {
-          title: "A move that passes admission but not the rung envelope",
-          advances: ["pipeline-coverage"],
-          expectedDelta: 0.75,
-          // Admission compares candidate.estCents; the router is handed a
-          // separately-estimated cost via ctx.estCents. Omitting estCents here
-          // clears admission and lands the refusal on the router's gate.
-          why: { reason: "kpi-gap" },
-          need: { steps: 8 },
-        },
-      ],
-      // DEFAULT_EST_CENTS (50) is used when the candidate names no estimate…
-    });
-    // …so squeeze the envelope below it to exercise the router's gate.
-    const r = await runGoalSteward({ ...deps, agentRoot: root, remainingCents: 10, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    assert.ok(audit.some((a) => a.decision === "budget_refused"), "the router's budget refusal must be audited");
-  } finally { cleanup(root); }
-});
-
-test("SERVER UNREACHABLE: routing fails open — the work is still queued locally", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({
-      sensors: sensors(1.5),
-      // Every org write throws, exactly as a partitioned laptop would see.
-      createItem: async () => { throw new Error("ECONNREFUSED 127.0.0.1:3000"); },
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.routed[0].ok, false);
-    assert.equal(r.routed[0].reason, "board-create-threw");
-    // The partition must not lose the work.
-    assert.equal(r.created, 1);
-    const parsed = parseQueueItems(readFileSync(join(root, GOALS_QUEUE_REL), "utf-8"), "goals.yaml");
-    assert.equal(parsed.length, 1);
-
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    assert.ok(audit.some((a) => a.decision === "route_failed"), "the failed route must be audited, not swallowed");
-  } finally { cleanup(root); }
-});
-
-test("SERVER UNREACHABLE: a failed sample mirror never aborts the local pass", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({
-      sensors: sensors(1.5),
-      mirrorSample: async () => { throw new Error("502 Bad Gateway"); },
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.measured[0].value, 1.5, "the local measurement stands even when hq refuses it");
-    assert.equal(r.created, 1);
-  } finally { cleanup(root); }
-});
-
-test("STALE MANDATE: >72h suspends OUTCOME work while measurement continues", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5) });
-    const record = mandate();
-    record.fetchedAt = new Date(NOW - 5 * 24 * 3600 * 1000).toISOString(); // 5 days
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-
-    assert.equal(r.staleness.tier, "stale");
-    assert.equal(r.staleness.outcome, "suspended");
-    // Still measured — an agent must keep telling the truth about its numbers…
-    assert.equal(r.measured[0].value, 1.5);
-    // …but must not invent new work off a mandate nobody has confirmed in days.
-    assert.equal(r.created, 0);
-    assert.equal(calls.board.length, 0);
-    assert.ok(r.rejected.some((x) => x.gate === "freshness"));
-  } finally { cleanup(root); }
-});
-
-test("a planner that throws is contained to its objective and audited", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({
-      sensors: sensors(1.5),
-      proposeCandidates: () => { throw new Error("sub-session died"); },
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.ok, true);
-    assert.equal(r.created, 0);
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    assert.ok(audit.some((a) => a.detail && a.detail.gate === "planner"));
-  } finally { cleanup(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Loop: the four dispositions route through the EXISTING primitives
-// ---------------------------------------------------------------------------
-
-test("HANDOFF: a DOER collaborator gets a handoff envelope, not a new mechanism", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5) });
-    const record = mandate();
-    record.body.objectives[1].collaborators = [{ memberId: PEER, role: "DOER" }];
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-
-    assert.equal(r.admitted[0].disposition, "HANDOFF");
-    assert.equal(calls.handoff.length, 1);
-    assert.equal(calls.handoff[0].to, PEER);
-    assert.equal(calls.handoff[0].payload.objectiveKey, "pipeline-coverage");
-    assert.equal(calls.handoff[0].payload.obligationKey, "outcome.pipeline-coverage");
-  } finally { cleanup(root); }
-});
-
-test("COLLABORATE: a contributor makes the loop claim the work-claim LEASE first", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({ sensors: sensors(1.5) });
-    const record = mandate();
-    record.body.objectives[1].collaborators = [{ memberId: PEER, role: "CONTRIBUTOR" }];
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-
-    assert.equal(r.admitted[0].disposition, "COLLABORATE");
-    assert.equal(calls.lease.length, 1);
-    assert.equal(calls.lease[0].scope, "work-claim");
-    assert.match(calls.lease[0].resourceId, /^objective:pipeline-coverage:/);
-  } finally { cleanup(root); }
-});
-
-test("COLLABORATE: losing the lease means standing down — no duplicate item, no queue row", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({
-      sensors: sensors(1.5),
-      claimLease: async () => ({ held: false, reason: "held-by-peer" }),
-    });
-    const record = mandate();
-    record.body.objectives[1].collaborators = [{ memberId: PEER, role: "CONTRIBUTOR" }];
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: record, enforcement: "active" });
-
-    assert.equal(calls.board.length, 0, "a peer owns the work — do not create a second item for it");
-    assert.equal(r.created, 0);
-    assert.ok(r.rejected.some((x) => x.gate === "lease"));
-  } finally { cleanup(root); }
-});
-
-test("NEEDS_REVIEW: a gated action class goes through approval.request BEFORE it executes", async () => {
-  const root = makeRoot();
-  try {
-    const { deps, calls } = spyDeps({
-      sensors: sensors(1.5),
-      proposeCandidates: ({ objective }) => [
-        {
-          title: "Wire the money",
-          advances: [objective.key],
-          expectedDelta: 0.5,
-          estCents: 10,
-          actionClasses: ["financial"],
-          why: { reason: "kpi-gap" },
-          need: { steps: 2 },
-        },
-      ],
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.admitted[0].disposition, "NEEDS_REVIEW");
-    assert.equal(calls.approval.length, 1);
-    assert.deepEqual(calls.approval[0].classification, ["financial"]);
-    assert.equal(r.routed[0].primitive, "approval.request");
-
-    const audit = readFileSync(join(root, "state", "mandate", "audit.jsonl"), "utf-8")
-      .trim().split("\n").map(JSON.parse);
-    assert.ok(audit.some((a) => a.decision === "approval_gate"), "the approval gate must be audited");
-  } finally { cleanup(root); }
-});
-
-test("NEEDS_REVIEW: an approval that cannot be requested leaves the item BLOCKED, not executed", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({
-      sensors: sensors(1.5),
-      requestApproval: async () => ({ requested: false, id: null }),
-      proposeCandidates: ({ objective }) => [
-        {
-          title: "Send the external announcement",
-          advances: [objective.key], expectedDelta: 0.5, estCents: 10,
-          actionClasses: ["external"], why: { reason: "kpi-gap" }, need: { steps: 2 },
-        },
-      ],
-    });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-    assert.equal(r.routed[0].blocked, true);
-    assert.equal(r.routed[0].ok, false);
-  } finally { cleanup(root); }
-});
-
-test("ESCALATE not pile-on: a flat gap with work already in flight asks a question", async () => {
-  const root = makeRoot();
-  try {
-    // Three periods of a stubbornly flat gap.
-    const at = (d) => new Date(NOW - d * 24 * 3600 * 1000).toISOString();
-    seedSeries(root, "pipeline-coverage", [
-      { value: 1.5, window: "2026-W31", at: at(14), source: "method" },
-      { value: 1.5, window: "2026-W32", at: at(7), source: "method" },
-      { value: 1.5, window: "2026-W33", at: at(0.1), source: "method" },
-    ]);
-    // Something is already in flight against the objective.
-    appendBacklogItems(makeRootInto(root), [
-      { id: "existing", title: "Already working it", status: "open", advances: ["pipeline-coverage"], created: "2026-08-04" },
-    ]);
-
-    const { deps, calls } = spyDeps({ sensors: {} });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.decisions[0].action, "escalate");
-    assert.equal(r.escalations.length, 1);
-    // The escalation carries real options, not prose.
-    const esc = calls.rpc.find((c) => /^escalation\./.test(c.method));
-    assert.ok(esc, `expected an escalation RPC; got ${calls.rpc.map((c) => c.method).join(",")}`);
-    assert.ok(esc.params.options.length >= 2, "an escalation must offer concrete options");
-    // And it did NOT create more tasks on top of the ones already failing.
-    assert.equal(calls.board.length, 0);
-    assert.equal(r.created, 0);
-  } finally { cleanup(root); }
-});
-
-/** Helper: appendBacklogItems takes the root directly; kept for readability above. */
-function makeRootInto(root) { return root; }
-
-test("WIP cap: a second run does not pile more work onto the same objective", async () => {
-  const root = makeRoot();
-  try {
-    const { deps } = spyDeps({ sensors: sensors(1.5) });
-    const cacheRecord = mandate();
-    const first = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord, enforcement: "active" });
-    assert.equal(first.created, 1);
-
-    // Second pass: an item is now open, the gap is unchanged and the trend is
-    // not yet established, so the decision table says "wait", not "create more".
-    const second = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord, enforcement: "active" });
-    assert.equal(second.created, 0);
-    assert.notEqual(second.decisions[0].action, "create");
-  } finally { cleanup(root); }
-});
-
-// ---------------------------------------------------------------------------
-// THE LEARNING SIGNAL — recordIntervention had zero callers
-// ---------------------------------------------------------------------------
-
-test("openItemsFor carries the expected delta and obligation an intervention is scored against", () => {
-  const root = makeRoot();
-  try {
-    appendBacklogItems(root, [{
-      id: "goal-1", title: "Close the gap", status: "open", priority: "high",
-      next_action: "Close the gap", advances: ["pipeline-coverage"],
-      expected_delta: 0.75, obligation_key: "outcome.pipeline-coverage",
-      disposition: "SELF", rung: 3, why: { reason: "kpi-gap" }, created: "2026-08-11",
-    }]);
-    const [item] = openItemsFor(root, "pipeline-coverage");
-    assert.equal(item.id, "goal-1");
-    assert.equal(item.expectedDelta, 0.75);
-    assert.equal(item.obligationKey, "outcome.pipeline-coverage");
-  } finally { cleanup(root); }
-});
-
-test("a new sample SCORES the work in flight — the realized delta lands in the ledger", () => {
-  const root = makeRoot();
-  try {
-    const objective = { key: "pipeline-coverage", target: 3, direction: "up", tolerance: 0.2, cadence: "weekly" };
-    const before = [{ window: "2026-W32", value: 1.5, source: "method", at: "2026-08-04T09:00:00.000Z" }];
-    const after = [...before, { window: "2026-W33", value: 2.5, source: "method", at: "2026-08-11T09:00:00.000Z" }];
-    const openItems = [{ id: "goal-1", expectedDelta: 0.75, obligationKey: "outcome.pipeline-coverage" }];
-
-    const r = journalRealizedDeltas(
-      { agentRoot: root, objective, seriesBefore: before, seriesAfter: after, window: "2026-W33", openItems },
-      { now: () => NOW },
-    );
-    assert.equal(r.recorded, 1);
-    // gap 1.5 → 0.5: the gap CLOSED by 1.0, whatever way the metric points.
-    assert.equal(r.rows[0].realizedDelta, 1);
-    assert.equal(r.rows[0].expectedDelta, 0.75);
-    assert.equal(r.rows[0].taskId, "goal-1");
-    assert.equal(r.rows[0].window, "2026-W33");
-
-    // Idempotent on (taskId, window): a second pass in the same window re-scores nothing.
-    const again = journalRealizedDeltas(
-      { agentRoot: root, objective, seriesBefore: before, seriesAfter: after, window: "2026-W33", openItems },
-      { now: () => NOW },
-    );
-    assert.equal(again.recorded, 0);
-    assert.equal(readInterventions(root, "pipeline-coverage", 0).length, 1);
-  } finally { cleanup(root); }
-});
-
-test("an intervention that made the number WORSE is recorded as a negative delta", () => {
-  const root = makeRoot();
-  try {
-    const objective = { key: "pipeline-coverage", target: 3, direction: "up", tolerance: 0.2, cadence: "weekly" };
-    const r = journalRealizedDeltas(
-      {
-        agentRoot: root, objective,
-        seriesBefore: [{ window: "2026-W32", value: 2.5, source: "method", at: "2026-08-04T09:00:00.000Z" }],
-        seriesAfter: [{ window: "2026-W32", value: 2.5, source: "method", at: "2026-08-04T09:00:00.000Z" },
-                      { window: "2026-W33", value: 1.5, source: "method", at: "2026-08-11T09:00:00.000Z" }],
-        window: "2026-W33",
-        openItems: [{ id: "goal-1", expectedDelta: 0.75 }],
-      },
-      { now: () => NOW },
-    );
-    assert.equal(r.rows[0].realizedDelta, -1);
-    // …and the planner sees it, which is the whole point of the ledger.
-    const priors = readInterventions(root, "pipeline-coverage", 3);
-    const candidates = defaultProposeCandidates({ objective, gap: { gap: 1.5, trend: "worsening", value: 1.5, target: 3 }, interventions: priors });
-    assert.equal(candidates[0].why.priorFailedInterventions, 1);
-    assert.equal(candidates[0].need.openEnded, true, "a repeat failure must stop being planned as a one-shot");
-  } finally { cleanup(root); }
-});
-
-test("the FIRST data point scores nothing — there is no prior gap, and that is not a failure", () => {
-  const root = makeRoot();
-  const logs = [];
-  try {
-    const r = journalRealizedDeltas(
-      {
-        agentRoot: root,
-        objective: { key: "pipeline-coverage", target: 3, direction: "up", cadence: "weekly" },
-        seriesBefore: [],
-        seriesAfter: [{ window: "2026-W33", value: 1.5, source: "method", at: "2026-08-11T09:00:00.000Z" }],
-        window: "2026-W33",
-        openItems: [{ id: "goal-1", expectedDelta: 0.75 }],
-      },
-      { now: () => NOW, log: (l, m) => logs.push(`${l}:${m}`) },
-    );
-    assert.equal(r.recorded, 0);
-    assert.equal(r.reason, "no prior gap");
-    assert.ok(logs.some((l) => /first data point, not a failure/.test(l)), "the skip must be logged, not silent");
-    assert.equal(readInterventions(root, "pipeline-coverage", 0).length, 0);
-  } finally { cleanup(root); }
-});
-
-test("the loop journals interventions on its own — end to end through runGoalSteward", async () => {
-  const root = makeRoot();
-  try {
-    seedSeries(root, "pipeline-coverage", [
-      { window: "2026-W32", value: 1.5, source: "method", at: "2026-08-04T09:00:00.000Z" },
-    ]);
-    appendBacklogItems(root, [{
-      id: "goal-prior", title: "A prior intervention", status: "open", priority: "normal",
-      next_action: "…", advances: ["pipeline-coverage"], expected_delta: 0.75,
-      obligation_key: "outcome.pipeline-coverage", disposition: "SELF", rung: 3,
-      why: { reason: "kpi-gap" }, created: "2026-08-04",
-    }]);
-
-    const { deps } = spyDeps({ sensors: sensors(2.5) });
-    const r = await runGoalSteward({ ...deps, agentRoot: root, cacheRecord: mandate(), enforcement: "active" });
-
-    assert.equal(r.interventions.length, 1);
-    assert.equal(r.interventions[0].recorded, 1);
-    const rows = readInterventions(root, "pipeline-coverage", 0);
-    assert.equal(rows.length, 1);
-    assert.equal(rows[0].taskId, "goal-prior");
-    assert.equal(rows[0].realizedDelta, 1);
-  } finally { cleanup(root); }
-});