@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/plan/adoption-e2e.test.mjs

@@ -1,366 +0,0 @@
-/**
- * lib/plan/adoption-e2e.test.mjs — the SDK half of THE ADOPTION PROOF.
- *
- * The state this exists to end: seat A016 compiled 28 obligations — 24 SCHEDULE,
- * 4 REACT, **0 OUTCOME** — because 0 of its 35 objectives were adopted. With no
- * OUTCOME obligation there is no measured KPI, with no measured KPI there is no
- * gap, and `lib/goals/admission.mjs` refuses every candidate at the `adoption`
- * gate before the honesty gate is even reached. D3 (self-directed work) was
- * structurally incapable of producing anything, and the whole ladder was inert.
- *
- * The input here is NOT a hand-written fixture. `MANDATE_BODY` is the byte
- * output of hq's real `mandate.adopt` handler — see
- * `~/hq/src/server/methods/mandate/adoption-e2e.test.ts`, which writes it to
- * `$MANDATE_ADOPTION_OUT`. Set `MANDATE_ADOPTION_IN` to that file to re-run this
- * against a freshly-published body; otherwise the committed copy below is used,
- * so the proof survives in CI without a cross-repo dependency. Each repo
- * agreeing with itself proves nothing; the number crossing the boundary does.
- *
- * The four things proven, in order:
- *   1. an ADOPTED objective compiles an OUTCOME obligation (it used not to
- *      exist at all, because nothing was ever adopted);
- *   2. a real METHOD sensor measures it and the sample is `source:"method"`;
- *   3. the gap admits a proactive backlog item, and every gate that passed it
- *      is named;
- *   4. the counterfactuals: the SAME objective left `proposed`, or SELF-adopted,
- *      compiles nothing and admits nothing.
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, existsSync } from "node:fs";
-import yaml from "js-yaml";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { compilePlan } from "./compile.mjs";
-import { writeCache } from "../mandate/cache.mjs";
-import { runGoalSteward, GOALS_QUEUE_REL } from "../goals/loop.mjs";
-import { admit } from "../goals/admission.mjs";
-import { gapFor, readSeries } from "../kpi.mjs";
-
-// ---------------------------------------------------------------------------
-// The body hq published (mandate.adopt → MandateSnapshot v1)
-// ---------------------------------------------------------------------------
-
-/**
- * Committed copy of hq's published body, captured from a real
- * `MANDATE_ADOPTION_OUT` run. Point `$MANDATE_ADOPTION_IN` at a fresh one to
- * re-prove the joint against today's handler.
- *
- * `checksum` is carried verbatim as hq stamped it and is NOT re-verified here:
- * `adoptedAt` comes off the server clock, so a fresh publish legitimately
- * produces a different digest for the same governance facts. What this file
- * pins is the SHAPE and the LAW, not one particular second.
- */
-const COMMITTED = {
-  version: 1,
-  checksum: "7c427ccc6dbe17283ca0a91cbd644407f793924cdc8f224f66c803c617d4255a",
-  source: "server",
-  body: {
-    contractVersion: 1,
-    memberId: "member_2",
-    objectives: [
-      {
-        id: "obj_1",
-        key: "pipeline-coverage",
-        kind: "OBJECTIVE",
-        state: "active",
-        text: "Hold pipeline coverage at 3x of the quarter's target",
-        memberId: "member_2",
-        parentId: null,
-        parentKey: null,
-        charterSectionId: "sec_pillar",
-        workstreamId: null,
-        metric: "pipeline_coverage_x",
-        unit: "x",
-        direction: "up",
-        baseline: 1.6,
-        target: 3,
-        value: null,
-        tolerance: 0.2,
-        weight: 1,
-        progress: 0,
-        cadence: "weekly",
-        dueAt: null,
-        sensor: { capability: "crm_list_deals", params: {}, source: "method" },
-        budgetCentsPerPeriod: 25000,
-        collaborators: [
-          { memberId: "agent_1", role: "APPROVER", source: "objective.adoptedById" },
-        ],
-        version: 2,
-        proposedById: "agent_2",
-        // NOT the owner (`member_2`) — hq's `resolveAdoptionAuthority` refused
-        // the owner outright and refused a peer seat holding `mandate.write`;
-        // this is the supervisor's principal.
-        adoptedById: "agent_1",
-        adoptedAt: "2026-08-12T00:00:00.000Z",
-        createdAt: "2026-08-11T00:00:00.000Z",
-        updatedAt: "2026-08-11T00:00:00.000Z",
-      },
-    ],
-    proposed: [],
-    budgetCentsPerPeriod: null,
-    seatBudgetCents: 25000,
-    budgetPeriod: "monthly",
-    budgetSource: "employee.payBasis.meteredBudget",
-    collaborators: [
-      { memberId: "member_1", role: "REVIEWER", source: "workforceMember.supervisorId" },
-    ],
-    reactsTo: [],
-    degradations: [],
-    generatedAt: "2026-08-11T00:00:00.000Z",
-  },
-};
-
-const SNAPSHOT = (() => {
-  const p = process.env.MANDATE_ADOPTION_IN;
-  if (p && existsSync(p)) return JSON.parse(readFileSync(p, "utf-8"));
-  return COMMITTED;
-})();
-
-const OWNER = SNAPSHOT.body.memberId;
-const KEY = SNAPSHOT.body.objectives[0].key;
-
-const MANIFEST = {
-  schemaVersion: 1,
-  entries: [
-    { id: "crm_list_deals", plane: "protocol", kind: "method", reachable: true, blastRadius: "internal" },
-    { id: "board_ready", plane: "protocol", kind: "method", reachable: true, blastRadius: "internal" },
-    { id: "board_claim", plane: "protocol", kind: "method", reachable: true, blastRadius: "internal" },
-    { id: "task_update", plane: "protocol", kind: "method", reachable: true, blastRadius: "internal" },
-  ],
-};
-
-const STANDARD = [
-  { id: "cadence-bus-heartbeat", mode: "inline", interval: 300 },
-  { id: "inbox-processor", mode: "guarded", calendar: { hour: 9 } },
-];
-
-/** Deep clone with one objective field overridden. */
-function withObjective(over) {
-  const body = JSON.parse(JSON.stringify(SNAPSHOT.body));
-  Object.assign(body.objectives[0], over);
-  return body;
-}
-
-function compile(body, log = () => {}) {
-  return compilePlan({
-    mandate: body,
-    manifest: MANIFEST,
-    standardCadences: STANDARD,
-    mandateVersion: SNAPSHOT.version,
-    log,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// 1. an ADOPTED objective compiles an OUTCOME obligation
-// ---------------------------------------------------------------------------
-
-test("an adopted objective compiles an OUTCOME obligation — the rung D3 needs", () => {
-  const plan = compile(SNAPSHOT.body);
-
-  const outcome = plan.obligations.find((o) => o.key === `outcome.${KEY}`);
-  assert.ok(outcome, `expected outcome.${KEY}; got ${plan.obligations.map((o) => o.key).join(", ")}`);
-  assert.equal(outcome.kind, "OUTCOME");
-  assert.equal(outcome.status, "active");
-  assert.equal(outcome.target, 3);
-  assert.equal(outcome.tolerance, 0.2);
-  assert.equal(outcome.cadence, "weekly");
-  assert.equal(outcome.sensor.capability, "crm_list_deals");
-  assert.equal(outcome.sensor.source, "method");
-  // The provenance edge hq now enforces at adopt time rides all the way here.
-  assert.equal(outcome.source.charter_section, "sec_pillar");
-  // Funded from `Employee.payBasis.meteredBudget`, apportioned by weight.
-  assert.equal(outcome.budget_cents_per_period, 25000);
-
-  // Its measure cadence comes with it — an OUTCOME nobody reads is decoration.
-  const measure = plan.obligations.find((o) => o.key === `schedule.measure.${KEY}`);
-  assert.ok(measure);
-  assert.equal(measure.guard_module, "lib/goals/loop.mjs");
-  assert.deepEqual(measure.uses, ["crm_list_deals"]);
-
-  assert.equal(plan.counts.OUTCOME, 1);
-  assert.equal(plan.counts.adoptedObjectives, 1);
-});
-
-// ---------------------------------------------------------------------------
-// 2+3. measure through a real sensor, then admit a proactive backlog item
-// ---------------------------------------------------------------------------
-
-test("a method-sensor measurement opens a gap that ADMITS a proactive backlog item", async () => {
-  const root = mkdtempSync(join(tmpdir(), "maestro-adopt-e2e-"));
-  mkdirSync(join(root, "state"), { recursive: true });
-  writeCache(root, SNAPSHOT, { now: () => "2026-08-12T08:00:00.000Z" });
-
-  const NOW = Date.parse("2026-08-12T09:00:00.000Z");
-  const log = [];
-  let sensorCalls = 0;
-
-  const report = await runGoalSteward({
-    agentRoot: root,
-    memberId: OWNER,
-    now: () => NOW,
-    log: (level, msg) => log.push(`${level} ${msg}`),
-    reachable: new Set(["crm_list_deals", "board_ready", "board_claim", "task_update"]),
-    // A REAL sensor: the same shape `lib/kpi-sensors.mjs` registers, reducing a
-    // protocol read to one number. Stubbed at the transport, not at the sample —
-    // the point is that the value arrives as `source:"method"` because the agent
-    // WENT AND LOOKED, which is exactly what the honesty gate turns on.
-    sensors: {
-      crm_list_deals: async ({ params, objective }) => {
-        sensorCalls += 1;
-        assert.equal(objective.key, KEY);
-        assert.deepEqual(params, {});
-        return { value: 1.6, rowCount: 41, detail: { metric: "open_pipeline_coverage", deals: 41 } };
-      },
-    },
-    remainingCents: 25000,
-    // ACTIVE, not observe: the claim is that a backlog ITEM gets created, and
-    // an observe-only run would only record that one would have been.
-    enforcement: "active",
-  });
-
-  // --- measured, through the sensor, as `method` ----------------------------
-  assert.equal(sensorCalls, 1, "the sensor actually ran");
-  assert.equal(report.measured.length, 1);
-  assert.deepEqual(
-    { ...report.measured[0], recorded: undefined },
-    { objectiveKey: KEY, value: 1.6, window: "2026-W33", source: "method", recorded: undefined }
-  );
-
-  // --- the gap ---------------------------------------------------------------
-  const gap = report.gaps[0];
-  assert.equal(gap.objectiveKey, KEY);
-  assert.equal(gap.value, 1.6);
-  assert.equal(gap.target, 3);
-  assert.equal(+gap.gap.toFixed(6), 1.4);
-  assert.equal(gap.withinTolerance, false);
-  assert.equal(gap.source, "method");
-
-  // --- the decision + the admission -----------------------------------------
-  assert.deepEqual(report.decisions[0], {
-    objectiveKey: KEY,
-    action: "create",
-    reason: "gap exceeds tolerance and nothing is in flight",
-    coverage: 0,
-  });
-  assert.equal(report.admitted.length, 1, `expected one admitted item; rejected: ${JSON.stringify(report.rejected)}`);
-  const admitted = report.admitted[0];
-  assert.equal(admitted.objectiveKey, KEY);
-  assert.match(admitted.title, /pipeline_coverage_x/);
-  assert.equal(report.created, 1, "a real backlog item was written, not merely contemplated");
-
-  // --- the item on the queue, with its provenance ---------------------------
-  const queue = yaml.load(readFileSync(join(root, GOALS_QUEUE_REL), "utf-8"));
-  assert.equal(queue.items.length, 1);
-  const item = queue.items[0];
-  assert.deepEqual(item.advances, [KEY]);
-  assert.equal(item.obligation_key, `outcome.${KEY}`);
-  assert.equal(item.why, "kpi-gap");
-  assert.equal(+Number(item.gap).toFixed(6), 1.4);
-  // The provenance an operator needs to answer "why did the agent do that?"
-  // offline: the charter clause it advances and who stood behind the number.
-  assert.equal(item.charter_clause, "sec_pillar");
-  assert.equal(item.adopted_by, "agent_1");
-  assert.notEqual(item.adopted_by, OWNER, "and the adopter is never the owner");
-
-  // --- and the gates that passed it, named ----------------------------------
-  // Re-run `admit` over the same inputs so the proof carries the gate ledger,
-  // not just the verdict. A candidate admitted for a reason nobody can read is
-  // the same failure as one rejected for a reason nobody can read.
-  const series = readSeries(root, KEY);
-  const verdict = admit(
-    {
-      title: item.title,
-      advances: [KEY],
-      why: { reason: "kpi-gap" },
-      estCents: 50,
-    },
-    {
-      objective: SNAPSHOT.body.objectives[0],
-      gap: gapFor(SNAPSHOT.body.objectives[0], series, { now: () => NOW }),
-      latestSample: series[series.length - 1],
-      openItems: [],
-      admittedThisRun: 0,
-      remainingCents: 25000,
-      staleness: { outcome: "full" },
-    }
-  );
-  assert.equal(verdict.admitted, true, `${verdict.gate}: ${verdict.reason}`);
-  assert.deepEqual(
-    verdict.checks.map((c) => c.gate),
-    ["freshness", "adoption", "honesty", "provenance", "dedupe", "trend", "wip", "budget"]
-  );
-  assert.ok(verdict.checks.every((c) => c.ok));
-  assert.match(verdict.checks.find((c) => c.gate === "honesty").detail, /method-sourced/);
-  assert.match(verdict.checks.find((c) => c.gate === "adoption").detail, /is active/);
-});
-
-// ---------------------------------------------------------------------------
-// 4. the counterfactuals — what "0 of 35 adopted" actually produced
-// ---------------------------------------------------------------------------
-
-test("the SAME objective left PROPOSED compiles no OUTCOME and admits nothing", async () => {
-  const body = withObjective({ state: "proposed", adoptedById: null, adoptedAt: null });
-  const plan = compile(body);
-  assert.equal(plan.counts.OUTCOME, 0, "a proposal is a request, not a mandate");
-  assert.equal(plan.obligations.some((o) => o.key.startsWith("outcome.")), false);
-
-  const root = mkdtempSync(join(tmpdir(), "maestro-adopt-e2e-prop-"));
-  writeCache(root, { ...SNAPSHOT, body }, { now: () => "2026-08-12T08:00:00.000Z" });
-  const report = await runGoalSteward({
-    agentRoot: root,
-    memberId: OWNER,
-    now: () => Date.parse("2026-08-12T09:00:00.000Z"),
-    log: () => {},
-    reachable: new Set(["crm_list_deals"]),
-    sensors: { crm_list_deals: async () => ({ value: 1.6 }) },
-  });
-  assert.equal(report.admitted.length, 0);
-  assert.equal(report.skipped, "no adopted objectives");
-});
-
-test("a SELF-ADOPTED objective compiles nothing and is reported as drift, not silently dropped", () => {
-  // The offline half of the anti-Goodhart law. hq refuses self-adoption at the
-  // handler, but a partitioned agent replaying a cached body — or a hand-edited
-  // state file — must not be able to grade itself either. Before this, the
-  // compiler trusted `state === "active"` and nothing about who set it.
-  const body = withObjective({ adoptedById: OWNER });
-  const notes = [];
-  const plan = compile(body, (level, msg) => notes.push(`${level} ${msg}`));
-
-  assert.equal(plan.counts.OUTCOME, 0);
-  const drift = plan.drift.find((d) => d.kind === "self_adopted");
-  assert.ok(drift, `expected self_adopted drift; got ${JSON.stringify(plan.drift.map((d) => d.kind))}`);
-  assert.equal(drift.key, `outcome.${KEY}`);
-  // FAIL-OPEN IS FINE; SILENT IS NOT.
-  assert.ok(notes.some((n) => /compiles NOTHING/.test(n) && /a seat cannot define, measure and be graded/.test(n)));
-});
-
-test("an objective with NO adoptedById compiles nothing either — the law fails CLOSED", () => {
-  // The cheaper tamper, and the one that used to work. The stated threat model is
-  // "an agent handed a hand-edited state file"; forging a plausible supervisor id
-  // is work, DELETING the field is one keystroke — and `isSelfAdopted` returned
-  // false for a missing field, so the row compiled a live graded OUTCOME with
-  // nobody on record as having handed the seat the number.
-  const withProvenance = withObjective({ adoptedById: "M-SUPERVISOR" });
-  const objs = withProvenance.objectives.map((o) => {
-    if (o.kind === "PILLAR") return o;
-    const { adoptedById, ...rest } = o;
-    return rest;
-  });
-  const notes = [];
-  const plan = compile({ ...withProvenance, objectives: objs }, (level, msg) => notes.push(`${level} ${msg}`));
-
-  assert.equal(plan.counts.OUTCOME, 0);
-  const drift = plan.drift.find((d) => d.kind === "missing_adoption_provenance");
-  assert.ok(drift, `expected missing_adoption_provenance drift; got ${JSON.stringify(plan.drift.map((d) => d.kind))}`);
-  assert.ok(notes.some((n) => /compiles NOTHING/.test(n) && /NO adoptedById/.test(n)));
-
-  // Control: the SAME body with the column present compiles the obligation.
-  assert.equal(compile(withProvenance, () => {}).counts.OUTCOME, 1);
-});