@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/plan/compile.test.mjs

@@ -1,382 +0,0 @@
-/**
- * compile.test.mjs — the plan compiler + obligation schema (SPEC §5.6).
- * Run: node --test lib/plan/compile.test.mjs
- *
- * The compiler is PURE, so these tests are pure too: fixture mandate, fixture
- * manifest, fixture cadence list. No fs, no network, no clock.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { compilePlan, solveSlot, busyWindows, allowedToolsFor, actionClassesFor, toolNameFor, STANDARD_REACTS, COMPILER_VERSION } from "./compile.mjs";
-import { validatePlan, validateObligation } from "./schema.mjs";
-import { deriveMandate, toMandateBody, pickSensor, slug } from "../mandate/derive.mjs";
-
-/** A small, explicit capability manifest. */
-function manifest(ids = ["board_ready", "task_create", "task_update", "board_claim", "board_complete", "crm_list_deals", "messaging_send", "knowledge_search", "email_inbox", "email_triage", "messaging_history"], unreachable = []) {
-  return {
-    schemaVersion: 1,
-    checksum: "fixture",
-    entries: [
-      ...ids.map((id) => ({ id, plane: "org", kind: "method_tool", reachable: true, blastRadius: id === "messaging_send" ? "external" : id.endsWith("_create") ? "irreversible" : "internal" })),
-      ...unreachable.map((id) => ({ id, plane: "org", kind: "method_tool", reachable: false, blastRadius: "internal" })),
-      { id: "builtin:Read", plane: "builtin", kind: "tool", reachable: true, blastRadius: "internal" },
-    ],
-  };
-}
-
-const STANDARD = [
-  { id: "inbox-processor", scope: "standard", mode: "guarded", interval: 300, prompt: "schedules/triggers/inbox-processor.md" },
-  { id: "daily-morning-brief", scope: "standard", mode: "escalate", calendar: { hour: 6, minute: 30 }, prompt: "schedules/triggers/daily-morning-brief.md" },
-  { id: "nightly-cost-reconcile", scope: "standard", mode: "inline", calendar: { hour: 3, minute: 30 } },
-];
-
-const ARCHETYPE = [
-  { id: "weekly-operating-review", scope: "function", mode: "escalate", cadence: "weekly", calendar: { weekday: 2, hour: 10, minute: 0 }, prompt: "schedules/triggers/weekly-operating-review.md", purpose: "Run the leadership operating review" },
-];
-
-function objective(over = {}) {
-  return {
-    key: "pipeline-coverage", kind: "OBJECTIVE", text: "Pipeline coverage", state: "active",
-    metric: "pipeline_coverage_x", unit: "x", direction: "up", target: 3, tolerance: 0.2,
-    weight: 1, cadence: "weekly", sensor: { capability: "crm_list_deals", params: { stage: "open" }, source: "method" },
-    // `adoptedById` is part of the fixture because it is part of the LAW: an
-    // active objective with no adopter on record compiles nothing (see
-    // lib/mandate/model.adoptionDefect). It must differ from the body's memberId.
-    collaborators: [], id: "obj_7Kx", charterSectionId: "cs_12", adoptedById: "M-SUPERVISOR", ...over,
-  };
-}
-
-test("standard cadences compile to SCHEDULE obligations with VERBATIM triggers", () => {
-  const p = compilePlan({ mandate: {}, manifest: manifest(), standardCadences: STANDARD });
-  const inbox = p.obligations.find((o) => o.key === "schedule.inbox-processor");
-  assert.equal(inbox.kind, "SCHEDULE");
-  assert.deepEqual(inbox.schedule, { interval: 300 });
-  assert.equal(inbox.source.origin, "standard");
-  assert.equal(inbox.scope, "standard");
-  const brief = p.obligations.find((o) => o.key === "schedule.daily-morning-brief");
-  assert.deepEqual(brief.schedule, { calendar: { hour: 6, minute: 30 } }, "trigger copied byte-for-byte so plists do not churn");
-});
-
-test("PROPOSED objectives compile NOTHING — the schedule only grows on human adoption", () => {
-  const proposed = { objectives: [objective({ state: "proposed" })] };
-  const p = compilePlan({ mandate: proposed, manifest: manifest(), standardCadences: STANDARD });
-  assert.equal(p.counts.OUTCOME, 0);
-  assert.equal(p.counts.proposedObjectives, 1);
-  assert.ok(!p.obligations.some((o) => o.key.startsWith("schedule.measure.")));
-});
-
-test("an ADOPTED objective compiles measure + outcome, provenance-linked to the objective and charter clause", () => {
-  const p = compilePlan({ mandate: { objectives: [objective()] }, manifest: manifest(), standardCadences: STANDARD });
-  const measure = p.obligations.find((o) => o.key === "schedule.measure.pipeline-coverage");
-  const outcome = p.obligations.find((o) => o.key === "outcome.pipeline-coverage");
-  assert.ok(measure && outcome);
-  assert.equal(measure.cadence_id, "measure-pipeline-coverage");
-  assert.equal(outcome.objective_id, "obj_7Kx");
-  assert.equal(outcome.source.charter_section, "cs_12");
-  assert.equal(outcome.sensor.capability, "crm_list_deals");
-  assert.equal(outcome.target, 3);
-  // This is what makes it "not a generic cron list":
-  assert.equal(measure.source.origin, "mandate");
-  assert.deepEqual(measure.uses, ["crm_list_deals"]);
-});
-
-test("a REVIEWER collaborator compiles a review cadence", () => {
-  const obj = objective({ collaborators: [{ member_id: "mem_A03", role: "REVIEWER" }] });
-  const p = compilePlan({ mandate: { objectives: [obj] }, manifest: manifest(), standardCadences: [] });
-  const review = p.obligations.find((o) => o.key === "schedule.review.pipeline-coverage");
-  assert.ok(review, "review obligation emitted");
-  assert.equal(review.cadence_id, "review-pipeline-coverage");
-  assert.equal(review.mode, "escalate");
-});
-
-test("an objective whose sensor is UNREACHABLE emits no OUTCOME and opens drift", () => {
-  const p = compilePlan({ mandate: { objectives: [objective()] }, manifest: manifest(["board_ready"], ["crm_list_deals"]), standardCadences: [] });
-  assert.equal(p.counts.OUTCOME, 0);
-  const d = p.drift.find((x) => x.kind === "unreachable_capability");
-  assert.ok(d, `expected unreachable_capability drift, got ${JSON.stringify(p.drift)}`);
-  assert.equal(d.detail.sensor, "crm_list_deals");
-});
-
-test("an objective with a HUMAN sensor emits no OUTCOME and opens stale_sensor drift", () => {
-  const obj = objective({ sensor: { capability: null, params: {}, source: "human" } });
-  const p = compilePlan({ mandate: { objectives: [obj] }, manifest: manifest(), standardCadences: [] });
-  assert.equal(p.counts.OUTCOME, 0);
-  assert.ok(p.drift.some((d) => d.kind === "stale_sensor"));
-});
-
-test("uses[] is filtered against the manifest and every drop is recorded as drift", () => {
-  const p = compilePlan({ mandate: {}, manifest: manifest(["email_inbox"]), standardCadences: STANDARD });
-  const inbox = p.obligations.find((o) => o.key === "schedule.inbox-processor");
-  assert.deepEqual(inbox.uses, ["email_inbox"], "unreachable capabilities are dropped, not cited");
-  assert.ok(p.drift.filter((d) => d.kind === "unreachable_capability" && d.key === "schedule.inbox-processor").length >= 2);
-});
-
-test("allowed_tools is COMPUTED from uses[] — a session-spawning cadence can never be unscoped", () => {
-  const p = compilePlan({ mandate: {}, manifest: manifest(), standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-  for (const ob of p.obligations.filter((o) => o.kind === "SCHEDULE" && o.mode !== "inline")) {
-    assert.ok(ob.allowed_tools.length > 0, `${ob.key} must carry a tool scope`);
-    assert.ok(ob.allowed_tools.includes("Read"), "baseline read primitives present");
-  }
-  const inline = p.obligations.find((o) => o.key === "schedule.nightly-cost-reconcile");
-  assert.deepEqual(inline.allowed_tools, [], "an inline cadence spawns no session and needs no scope");
-});
-
-test("action_classes are derived from the manifest's blast radii", () => {
-  assert.deepEqual(actionClassesFor(["messaging_send", "board_ready"], manifest()), ["external"]);
-  assert.deepEqual(actionClassesFor(["board_ready"], manifest()), []);
-});
-
-test("toolNameFor maps every plane onto a session tool name", () => {
-  assert.equal(toolNameFor("builtin:Read"), "Read");
-  assert.equal(toolNameFor("skill:agent-skills:morning-brief"), "Skill");
-  assert.equal(toolNameFor("workflow:weekly-operating-review"), "Task");
-  assert.equal(toolNameFor("mcp:notion"), "mcp__notion__*");
-  assert.equal(toolNameFor("board_ready"), "board_ready");
-  assert.deepEqual(allowedToolsFor(["board_ready", "builtin:Read"]), ["Glob", "Grep", "LS", "Read", "board_ready"]);
-});
-
-test("the four standard REACT obligations always compile", () => {
-  const p = compilePlan({ mandate: {}, manifest: manifest(["email_message", "email_thread", "email_send", "board_ready", "board_claim", "task_update", "approval_wait", "decision_list"]), standardCadences: [] });
-  for (const r of STANDARD_REACTS) assert.ok(p.obligations.some((o) => o.key === r.key), `${r.key} missing`);
-  assert.equal(p.counts.REACT, STANDARD_REACTS.length);
-});
-
-test("mandate reactsTo[] adds REACT obligations bound to an objective", () => {
-  const mandate = { objectives: [], reactsTo: [{ key: "react.mandate.deal-stalled", topic: "task", kind: "stalled", uses: ["crm_list_deals"], objectiveId: "obj_7Kx", offlineSafe: true }] };
-  const p = compilePlan({ mandate, manifest: manifest(), standardCadences: [] });
-  const r = p.obligations.find((o) => o.key === "react.mandate.deal-stalled");
-  assert.equal(r.kind, "REACT");
-  assert.equal(r.objective_id, "obj_7Kx");
-  assert.equal(r.offline_safe, true);
-  assert.equal(r.source.origin, "mandate");
-});
-
-test("DETERMINISM: identical inputs → identical obligationsHash; a changed mandate changes it", () => {
-  const a = compilePlan({ mandate: { objectives: [objective()] }, manifest: manifest(), standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-  const b = compilePlan({ mandate: { objectives: [objective()] }, manifest: manifest(), standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-  assert.equal(a.obligationsHash, b.obligationsHash);
-  assert.equal(a.inputsHash, b.inputsHash);
-  const c = compilePlan({ mandate: { objectives: [objective({ target: 4 })] }, manifest: manifest(), standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-  assert.notEqual(a.inputsHash, c.inputsHash, "a different mandate is a different plan input");
-});
-
-test("DETERMINISM: objective input ORDER does not change the emitted schedule", () => {
-  const o1 = objective();
-  const o2 = objective({ key: "decision-latency", id: "obj_2", metric: "decision_days", cadence: "monthly", weight: 1 });
-  const a = compilePlan({ mandate: { objectives: [o1, o2] }, manifest: manifest(), standardCadences: [] });
-  const b = compilePlan({ mandate: { objectives: [o2, o1] }, manifest: manifest(), standardCadences: [] });
-  assert.equal(a.obligationsHash, b.obligationsHash);
-});
-
-test("slot solver: deterministic, avoids the principal's busy hours, respects the concurrency cap", () => {
-  const busy = busyWindows([{ weekday: 1, hour: 9 }, { weekday: 1, hour: 10 }]);
-  const state = { busy, taken: new Map(), concurrency: 1 };
-  const a = solveSlot("schedule.measure.alpha", "weekly", state);
-  const b = solveSlot("schedule.measure.beta", "weekly", state);
-  assert.notDeepEqual(a.calendar, b.calendar, "the cap forces distinct slots");
-  for (const s of [a, b]) assert.ok(!busy.has(`${s.calendar.weekday}:${s.calendar.hour}`), "never lands in a busy window");
-  // Same key, fresh state → same slot, forever.
-  const again = solveSlot("schedule.measure.alpha", "weekly", { busy, taken: new Map(), concurrency: 1 });
-  assert.deepEqual(again.calendar, a.calendar);
-});
-
-test("budget envelope: objectives past the envelope are SUSPENDED with a breach record, never dropped", () => {
-  const objs = [
-    objective({ key: "a", id: "a", weight: 3 }),
-    objective({ key: "b", id: "b", weight: 2 }),
-    objective({ key: "c", id: "c", weight: 1 }),
-  ];
-  const p = compilePlan({ mandate: { objectives: objs, budgetCentsPerPeriod: 500 }, manifest: manifest(), standardCadences: [], seatBudgetCents: 1000 });
-  const suspended = p.obligations.filter((o) => o.status === "suspended");
-  assert.ok(suspended.length > 0, "the third objective exceeds the envelope");
-  assert.ok(p.drift.some((d) => d.kind === "budget_breach"));
-  assert.equal(p.obligations.filter((o) => o.kind === "OUTCOME").length, 3, "all three still exist — suspended, not dropped");
-});
-
-// ---------------------------------------------------------------------------
-// THE MANDATE BODY JOINT — no invented money, ever
-// ---------------------------------------------------------------------------
-
-test("THE BUG: a mandate with no budget compiles UNMETERED, never 500", () => {
-  // This is the exact failure. hq sent no `budgetCentsPerPeriod`, the compiler
-  // read `undefined`, `Number.isFinite(undefined)` was false, and every single
-  // obligation in the fleet silently took 500c against a 10000c envelope that
-  // no column anywhere produced. Nothing errored, so nothing was ever noticed.
-  const logs = [];
-  const p = compilePlan({
-    mandate: { objectives: [objective()] },
-    manifest: manifest(),
-    standardCadences: STANDARD,
-    log: (level, msg) => logs.push([level, msg]),
-  });
-
-  for (const ob of p.obligations) {
-    assert.equal(ob.budget_cents_per_period, null, `${ob.key} must be unmetered, not a made-up number`);
-    assert.notEqual(ob.budget_cents_per_period, 500, `${ob.key} must never be 500`);
-  }
-  // Unmetered means NO ceiling is invented either — nothing is suspended for
-  // breaching a 10000c envelope that never existed.
-  assert.equal(p.obligations.filter((o) => o.status === "suspended").length, 0);
-  assert.ok(!p.drift.some((d) => d.kind === "budget_breach"));
-  // FAIL-OPEN IS FINE; SILENT IS NOT.
-  assert.ok(logs.length > 0, "the degradation is announced");
-  assert.ok(logs.some(([l]) => l === "error"), "a pre-contract body is an error-level event");
-  assert.equal(p.contract.ok, false);
-  assert.equal(p.contract.unmetered, true);
-  assert.ok(p.warnings.length > 0);
-});
-
-test("a funded hq body puts the MANDATE's number on each obligation", () => {
-  const objs = [
-    objective({ key: "a", id: "a", weight: 3, budgetCentsPerPeriod: 18_750 }),
-    objective({ key: "b", id: "b", weight: 1, budgetCentsPerPeriod: 6_250 }),
-  ];
-  const p = compilePlan({
-    mandate: {
-      contractVersion: 1, memberId: "mem_self", objectives: objs, proposed: [],
-      budgetCentsPerPeriod: null, seatBudgetCents: 25_000, budgetPeriod: "monthly",
-      budgetSource: "employee.payBasis.meteredBudget", collaborators: [], reactsTo: [],
-      degradations: [], generatedAt: "2026-08-11T00:00:00.000Z",
-    },
-    manifest: manifest(), standardCadences: [], log: () => {},
-  });
-  assert.equal(p.contract.ok, true);
-  assert.equal(p.contract.unmetered, false);
-  const byKey = Object.fromEntries(p.obligations.filter((o) => o.kind === "OUTCOME").map((o) => [o.key, o.budget_cents_per_period]));
-  assert.equal(byKey["outcome.a"], 18_750);
-  assert.equal(byKey["outcome.b"], 6_250);
-  // Obligations with no objective behind them stay unmetered — hq holds no
-  // per-obligation column, and `budgetCentsPerPeriod:null` says exactly that.
-  for (const ob of p.obligations.filter((o) => o.kind === "REACT")) {
-    assert.equal(ob.budget_cents_per_period, null);
-  }
-});
-
-test("budgets are NOT part of obligationsHash — funding a seat must not churn every plist", () => {
-  const base = { objectives: [objective({ key: "a", id: "a" })] };
-  const unfunded = compilePlan({ mandate: base, manifest: manifest(), standardCadences: STANDARD, log: () => {} });
-  const funded = compilePlan({
-    mandate: { ...base, objectives: [objective({ key: "a", id: "a", budgetCentsPerPeriod: 9_000 })], seatBudgetCents: 9_000 },
-    manifest: manifest(), standardCadences: STANDARD, log: () => {},
-  });
-  assert.equal(funded.obligationsHash, unfunded.obligationsHash, "funding changes money, not identity");
-});
-
-test("an explicit figure in a MALFORMED body is still used — only invention is forbidden", () => {
-  // The contract failing does not license throwing away a number the caller
-  // actually stated. It licenses refusing to make one up.
-  const logs = [];
-  const p = compilePlan({
-    mandate: { objectives: [objective({ key: "a", id: "a" })], budgetCentsPerPeriod: 700 },
-    manifest: manifest(), standardCadences: [], log: (l, m) => logs.push([l, m]),
-  });
-  assert.equal(p.contract.ok, false, "still a pre-contract body");
-  assert.ok(logs.some(([l]) => l === "error"), "and still loud about it");
-  assert.equal(p.obligations.find((o) => o.kind === "OUTCOME").budget_cents_per_period, 700);
-});
-
-test("validatePlan is FAIL-CLOSED on an unreachable citation and on an llm-sourced OUTCOME", () => {
-  const reachable = new Set(["board_ready"]);
-  const bad = {
-    obligations: [{
-      key: "outcome.x", kind: "OUTCOME", source: { origin: "mandate", ref: "x" }, status: "active",
-      uses: ["ghost_tool"], allowed_tools: ["Read"], action_classes: [], offline_safe: true,
-      objective_id: "obj", sensor: { source: "llm", capability: null },
-    }],
-  };
-  const v = validatePlan(bad, { reachable });
-  assert.equal(v.ok, false);
-  assert.ok(v.errors.some((e) => /not reachable:true/.test(e)));
-  assert.ok(v.errors.some((e) => /"llm" cannot back an OUTCOME/.test(e)));
-});
-
-test("validateObligation rejects a session-spawning SCHEDULE with no tool scope", () => {
-  const errs = validateObligation({
-    key: "schedule.x", kind: "SCHEDULE", source: { origin: "archetype", ref: "x" }, status: "active",
-    mode: "escalate", schedule: { interval: 600 }, uses: [], allowed_tools: [], action_classes: [], offline_safe: false,
-  });
-  assert.ok(errs.some((e) => /non-empty allowed_tools/.test(e)));
-});
-
-test("a full compiled plan validates against the manifest", () => {
-  const m = manifest();
-  const p = compilePlan({ mandate: { objectives: [objective()] }, manifest: m, standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-  const v = validatePlan(p, { manifest: m });
-  assert.equal(v.ok, true, v.errors.join("; "));
-  assert.equal(p.compilerVersion, COMPILER_VERSION);
-});
-
-// ── derivation (the "per-agent and justified, not a static list" property) ───
-
-test("deriveMandate: charter pillars become PILLARs, KPI categories become OBJECTIVEs parented to them", () => {
-  const d = deriveMandate({
-    charterSections: [
-      { kind: "PILLAR", order: 0, body: "1) Own the agent-platform substrate — runtime, memory, tools." },
-      { kind: "PILLAR", order: 1, body: "2) Make the fleet governable: every capability observable." },
-    ],
-    kpiCategories: [
-      { id: "execution", name: "Fleet execution & follow-through", examples: ["Commitment-closure rate"] },
-      // Overlaps neither pillar's words. It is CARRIED but left unplaced —
-      // the old deriver silently parented it onto pillar #1.
-      { id: "warehouse-latency", name: "Warehouse latency", examples: ["p95 ms"] },
-    ],
-    manifest: manifest(),
-  });
-  assert.equal(d.counts.pillars, 2);
-  assert.equal(d.counts.objectives, 2);
-  const exec = d.objectives.find((o) => o.key === "execution");
-  assert.equal(exec.kind, "OBJECTIVE");
-  assert.ok(exec.parentKey, "every PLACEABLE objective hangs off a pillar (provenance)");
-  assert.ok(exec.charterSectionId !== undefined);
-  const orphan = d.objectives.find((o) => o.key === "warehouse-latency");
-  assert.equal(orphan.parentKey, null, "no fabricated pillar edge");
-  assert.ok(d.degradations.some((x) => x.kind === "no_pillar_trace" && x.key === "warehouse-latency"));
-  assert.equal(exec.state, "proposed", "NOTHING is adopted by the agent");
-  assert.equal(exec.sensor.source, "method");
-  assert.equal(exec.sensor.capability, "board_ready", "bound to a REACHABLE capability");
-});
-
-test("deriveMandate: two different agents (different charters/KPIs) get different mandates", () => {
-  const a = deriveMandate({ charterSections: [{ kind: "PILLAR", order: 0, body: "Own revenue growth" }], kpiCategories: [{ id: "pipeline", name: "Pipeline coverage" }], manifest: manifest() });
-  const b = deriveMandate({ charterSections: [{ kind: "PILLAR", order: 0, body: "Own compliance posture" }], kpiCategories: [{ id: "audit", name: "Audit findings closed" }], manifest: manifest() });
-  assert.notDeepEqual(a.objectives.map((o) => o.key), b.objectives.map((o) => o.key));
-});
-
-test("deriveMandate: a metric with no REACHABLE sensor is proposed source:human AND flagged", () => {
-  const d = deriveMandate({ kpiCategories: [{ id: "pipeline", name: "Pipeline coverage", examples: ["Pipeline coverage x"] }], manifest: manifest(["board_ready"]) });
-  const o = d.objectives[0];
-  assert.equal(o.sensor.source, "human");
-  assert.ok(d.degradations.some((x) => x.kind === "no_reachable_sensor"));
-});
-
-test("deriveMandate is deterministic and slug keys are stable", () => {
-  const input = { charterSections: [{ kind: "PILLAR", order: 0, body: "3) Scale the platform with the roster, not after it." }], kpiCategories: [], manifest: manifest() };
-  assert.deepEqual(deriveMandate(input).objectives, deriveMandate(input).objectives);
-  assert.equal(slug("3) Scale the platform with the roster, not after it."), "scale-the-platform-with-the-roster-not-after-it");
-});
-
-test("pickSensor prefers the most specific reachable capability", () => {
-  assert.equal(pickSensor("weekly pipeline coverage", new Set(["crm_list_deals"])).capability, "crm_list_deals");
-  assert.equal(pickSensor("decision cycle time", new Set(["decision_list"])).capability, "decision_list");
-  assert.equal(pickSensor("something unmodelled", new Set(["board_ready"])).source, "human");
-});
-
-test("end to end: derive → compile produces a plan whose obligations trace back to the charter", () => {
-  const d = deriveMandate({
-    charterSections: [{ kind: "PILLAR", order: 0, id: "cs_1", body: "Own execution follow-through" }],
-    kpiCategories: [{ id: "execution", name: "Execution & Follow-Through", examples: ["Commitment-closure rate"] }],
-    manifest: manifest(),
-  });
-  // Simulate the human adoption step in hq.
-  // Simulating hq's adopt handler means simulating ALL of it — including the
-  // `adoptedById` column it stamps. Without one the compiler refuses the row.
-  const adopted = d.objectives.map((o) => (o.kind === "OBJECTIVE" ? { ...o, state: "active", target: 0.95, id: `obj_${o.key}`, adoptedById: "M-SUPERVISOR" } : o));
-  const p = compilePlan({ mandate: toMandateBody({ objectives: adopted }), manifest: manifest(), standardCadences: STANDARD });
-  const outcome = p.obligations.find((o) => o.kind === "OUTCOME");
-  assert.ok(outcome, "adoption turns the proposal into a real obligation");
-  assert.equal(outcome.target, 0.95);
-  assert.equal(validatePlan(p, { manifest: manifest() }).ok, true);
-});

package/lib/plan/emit.test.mjs

@@ -1,269 +0,0 @@
-/**
- * emit.test.mjs — obligations → the files the runtime already reads (SPEC §5.7).
- * Run: node --test lib/plan/emit.test.mjs
- *
- * The contract under test is compatibility: cadences.yaml, .cadence-registry.json
- * and .cadence-plists.tsv must keep the EXACT shapes their existing consumers
- * (cadence-handlers.mjs, session-permissions.mjs, generate-plists.sh) already
- * parse — new producer, unchanged formats.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import yaml from "js-yaml";
-
-import { emitPlan, toCadenceEntries, toRegistry, toTsvLines, scheduleXml, readLock, PLAN_REL, CADENCES_REL, REGISTRY_REL, TSV_REL, LOCK_REL } from "./emit.mjs";
-import { compilePlan } from "./compile.mjs";
-
-const AT = "2026-08-11T09:00:00.000Z";
-
-function manifest() {
-  return {
-    schemaVersion: 1,
-    checksum: "fixture",
-    entries: ["board_ready", "task_create", "task_update", "board_claim", "board_complete", "crm_list_deals", "knowledge_search", "email_inbox", "email_triage", "messaging_history", "messaging_send", "email_message", "email_thread", "email_send", "approval_wait", "decision_list"]
-      .map((id) => ({ id, plane: "org", kind: "method_tool", reachable: true, blastRadius: "internal" })),
-  };
-}
-
-const STANDARD = [
-  { id: "inbox-processor", scope: "standard", mode: "guarded", interval: 300, prompt: "schedules/triggers/inbox-processor.md" },
-  { id: "daily-morning-brief", scope: "standard", mode: "escalate", calendar: { hour: 6, minute: 30 }, prompt: "schedules/triggers/daily-morning-brief.md" },
-];
-const ARCHETYPE = [
-  { id: "weekly-operating-review", scope: "function", mode: "escalate", cadence: "weekly", calendar: { weekday: 2, hour: 10, minute: 0 }, prompt: "schedules/triggers/weekly-operating-review.md", purpose: "Operating review" },
-  { id: "org-cost-sync-fn", scope: "function", mode: "inline", interval: 3600 },
-];
-
-function adoptedObjective() {
-  return {
-    key: "pipeline-coverage", kind: "OBJECTIVE", text: "Pipeline coverage", state: "active", id: "obj_7Kx",
-    adoptedById: "M-SUPERVISOR",
-    metric: "pipeline_coverage_x", direction: "up", target: 3, tolerance: 0.2, weight: 1, cadence: "weekly",
-    sensor: { capability: "crm_list_deals", params: { stage: "open" }, source: "method" }, collaborators: [],
-  };
-}
-
-function planWith(objectives = []) {
-  return compilePlan({ mandate: { objectives }, manifest: manifest(), standardCadences: STANDARD, archetypeCadences: ARCHETYPE });
-}
-
-function tmpRoot() { return mkdtempSync(join(tmpdir(), "maestro-emit-")); }
-
-test("emitPlan writes all five artefacts", async () => {
-  const root = tmpRoot();
-  const r = await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), archetype: "executive-operator@c-suite", at: AT });
-  assert.equal(r.ok, true, r.errors.join("; "));
-  for (const rel of [PLAN_REL, CADENCES_REL, REGISTRY_REL, TSV_REL, LOCK_REL]) {
-    assert.ok(existsSync(join(root, rel)), `${rel} written`);
-  }
-});
-
-test("config/cadences.yaml keeps the shape cadence-handlers already parses", async () => {
-  const root = tmpRoot();
-  await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), archetype: "executive-operator@c-suite", at: AT });
-  const doc = yaml.load(readFileSync(join(root, CADENCES_REL), "utf8"));
-  assert.equal(doc.archetype, "executive-operator@c-suite");
-  const inbox = doc.cadences.find((c) => c.id === "inbox-processor");
-  assert.equal(inbox.interval, 300);
-  assert.equal(inbox.mode, "guarded");
-  assert.equal(inbox.prompt, "schedules/triggers/inbox-processor.md");
-  assert.equal(inbox.scope, "standard");
-  // the plan-derived measure cadence is a first-class cadence id
-  assert.ok(doc.cadences.some((c) => c.id === "measure-pipeline-coverage"));
-});
-
-test(".cadence-registry.json carries the EXTENDED shape session-permissions can scope on", async () => {
-  const root = tmpRoot();
-  await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), at: AT });
-  const reg = JSON.parse(readFileSync(join(root, REGISTRY_REL), "utf8"));
-  const m = reg["measure-pipeline-coverage"];
-  assert.equal(m.mode, "guarded");
-  assert.equal(m.guardModule, "lib/goals/loop.mjs");
-  assert.equal(m.obligationKey, "schedule.measure.pipeline-coverage");
-  // PRESENT, and null when the mandate funded nothing — `planWith` builds from a
-  // mandate with no budget, so null is the honest reading. The key must exist
-  // either way: `getCadenceDef` branches on Number.isFinite, and an ABSENT key
-  // and a null one both mean "no cap" while only one of them can be logged.
-  assert.ok(Object.prototype.hasOwnProperty.call(m, "budgetCents"));
-  assert.equal(m.budgetCents, null);
-  assert.ok(Array.isArray(m.allowedTools) && m.allowedTools.includes("crm_list_deals"));
-  // Back-compat: {mode, prompt} still present for every entry.
-  for (const [id, def] of Object.entries(reg)) {
-    assert.ok(def.mode, `${id} has a mode`);
-    assert.ok(def.prompt, `${id} has a prompt`);
-  }
-});
-
-test(".cadence-plists.tsv is pipe-delimited, EXCLUDES standard cadences, and decodes to launchd XML", async () => {
-  const root = tmpRoot();
-  await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), at: AT });
-  const lines = readFileSync(join(root, TSV_REL), "utf8").trim().split("\n");
-  assert.ok(lines.length > 0);
-  assert.ok(!lines.some((l) => l.startsWith("inbox-processor|")), "generate-plists.sh emits the standard set itself");
-  const interval = lines.find((l) => l.startsWith("org-cost-sync-fn|"));
-  assert.equal(interval, "org-cost-sync-fn|3600|");
-  const cal = lines.find((l) => l.startsWith("weekly-operating-review|"));
-  const [, empty, b64] = cal.split("|");
-  assert.equal(empty, "");
-  const xml = Buffer.from(b64, "base64").toString("utf8");
-  assert.match(xml, /<key>Weekday<\/key>\n\s+<integer>2<\/integer>/);
-  assert.match(xml, /<key>Hour<\/key>\n\s+<integer>10<\/integer>/);
-  // the derived measure cadence becomes a REAL launchd job
-  assert.ok(lines.some((l) => l.startsWith("measure-pipeline-coverage||")));
-});
-
-test("scheduleXml output is byte-identical to the legacy generator's shape", () => {
-  assert.equal(
-    scheduleXml({ weekday: 2, hour: 10, minute: 0 }),
-    "        <key>Weekday</key>\n        <integer>2</integer>\n        <key>Hour</key>\n        <integer>10</integer>\n        <key>Minute</key>\n        <integer>0</integer>",
-  );
-});
-
-test("IDEMPOTENT: re-emitting an unchanged plan produces byte-identical files (no plist churn)", async () => {
-  const root = tmpRoot();
-  const plan = planWith([adoptedObjective()]);
-  await emitPlan({ agentRoot: root, plan, manifest: manifest(), at: AT });
-  const before = [CADENCES_REL, REGISTRY_REL, TSV_REL].map((r) => readFileSync(join(root, r), "utf8"));
-  await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), at: AT });
-  const after = [CADENCES_REL, REGISTRY_REL, TSV_REL].map((r) => readFileSync(join(root, r), "utf8"));
-  assert.deepEqual(after, before);
-});
-
-test("FAIL-CLOSED: an invalid plan writes NOTHING", async () => {
-  const root = tmpRoot();
-  const bad = {
-    compilerVersion: 1, mandateVersion: 0, inputsHash: "x", obligationsHash: "y", counts: {},
-    obligations: [{
-      key: "schedule.ghost", kind: "SCHEDULE", source: { origin: "archetype", ref: "ghost" }, status: "active",
-      mode: "escalate", schedule: { interval: 600 }, cadence_id: "ghost",
-      uses: ["ghost_tool"], allowed_tools: ["Read"], action_classes: [], offline_safe: false,
-    }],
-  };
-  const r = await emitPlan({ agentRoot: root, plan: bad, manifest: manifest(), at: AT });
-  assert.equal(r.ok, false);
-  assert.ok(r.errors.some((e) => /not reachable:true/.test(e)));
-  for (const rel of [PLAN_REL, CADENCES_REL, REGISTRY_REL, TSV_REL, LOCK_REL]) {
-    assert.equal(existsSync(join(root, rel)), false, `${rel} must NOT exist after a failed validation`);
-  }
-});
-
-test("compile.lock carries the hashes verify() checks", async () => {
-  const root = tmpRoot();
-  const plan = planWith([adoptedObjective()]);
-  await emitPlan({ agentRoot: root, plan, manifest: manifest(), at: AT });
-  const lock = readLock(root);
-  assert.equal(lock.obligationsHash, plan.obligationsHash);
-  assert.equal(lock.inputsHash, plan.inputsHash);
-  assert.equal(lock.compilerVersion, plan.compilerVersion);
-  assert.equal(lock.at, AT);
-});
-
-test("config/plan.yaml is the reviewable obligation set (provenance + sensor + tool scope)", async () => {
-  const root = tmpRoot();
-  await emitPlan({ agentRoot: root, plan: planWith([adoptedObjective()]), manifest: manifest(), enforcement: "observe-only", at: AT });
-  const doc = yaml.load(readFileSync(join(root, PLAN_REL), "utf8"));
-  assert.equal(doc.enforcement, "observe-only");
-  const outcome = doc.obligations.find((o) => o.key === "outcome.pipeline-coverage");
-  assert.equal(outcome.objective_id, "obj_7Kx");
-  assert.equal(outcome.sensor.capability, "crm_list_deals");
-  assert.equal(outcome.source.origin, "mandate");
-  assert.ok(Array.isArray(outcome.allowed_tools));
-});
-
-test("SUSPENDED obligations are in plan.yaml but never in the schedule artefacts", () => {
-  const obs = [
-    { key: "schedule.a", kind: "SCHEDULE", cadence_id: "a", scope: "mandate", mode: "guarded", prompt: "p.md", schedule: { interval: 60 }, status: "suspended", uses: [], allowed_tools: ["Read"], action_classes: [], offline_safe: true, source: { origin: "mandate", ref: "a" }, budget_cents_per_period: 100 },
-    { key: "schedule.b", kind: "SCHEDULE", cadence_id: "b", scope: "mandate", mode: "guarded", prompt: "p.md", schedule: { interval: 60 }, status: "active", uses: [], allowed_tools: ["Read"], action_classes: [], offline_safe: true, source: { origin: "mandate", ref: "b" }, budget_cents_per_period: 100 },
-  ];
-  assert.deepEqual(toCadenceEntries(obs).map((c) => c.id), ["b"]);
-  assert.deepEqual(Object.keys(toRegistry(obs)), ["b"]);
-  assert.deepEqual(toTsvLines(obs), ["b|60|"]);
-});
-
-test("the registry carries the provenance the RUNTIME budget gate needs", () => {
-  const obs = [
-    { key: "schedule.measure.gm", kind: "SCHEDULE", cadence_id: "measure-gm", scope: "mandate", objective_id: "obj_7Kx", mode: "guarded", prompt: "p.md", schedule: { interval: 60 }, status: "active", uses: [], allowed_tools: ["Read"], action_classes: [], offline_safe: true, source: { origin: "mandate", ref: "gm" }, budget_cents_per_period: 100 },
-    { key: "schedule.cadence-bus-heartbeat", kind: "SCHEDULE", cadence_id: "cadence-bus-heartbeat", scope: "standard", mode: "inline", prompt: "p.md", schedule: { interval: 300 }, status: "active", uses: [], allowed_tools: [], action_classes: [], offline_safe: false, source: { origin: "standard", ref: "cadence-bus-heartbeat" }, budget_cents_per_period: null },
-  ];
-  const reg = toRegistry(obs);
-  // Without these three the consumer cannot tell a funded objective's cadence
-  // from the seat's own heartbeat, so a budget breach would suspend either
-  // everything or nothing.
-  assert.equal(reg["measure-gm"].scope, "mandate");
-  assert.equal(reg["measure-gm"].objectiveId, "obj_7Kx");
-  assert.equal(reg["measure-gm"].offlineSafe, true);
-  assert.equal(reg["cadence-bus-heartbeat"].scope, "standard");
-  assert.equal(reg["cadence-bus-heartbeat"].objectiveId, null);
-  assert.equal(reg["cadence-bus-heartbeat"].offlineSafe, false);
-});
-
-// ---------------------------------------------------------------------------
-// The no-op guard (SPEC §6.4: "if obligationsHash is unchanged, nothing on disk
-// moves"). config/plan.yaml is TRACKED, so a recompile that changes nothing must
-// not rewrite it — otherwise the one artefact meant to make a schedule change
-// legible in a PR diff churns on every org-pulse tick and proves nothing.
-// ---------------------------------------------------------------------------
-
-test("a re-emit with identical inputs moves NOTHING on disk", async () => {
-  const root = tmpRoot();
-  const opts = { agentRoot: root, manifest: manifest(), archetype: "executive-operator@c-suite" };
-
-  const first = await emitPlan({ ...opts, plan: planWith([adoptedObjective()]), at: AT });
-  assert.equal(first.ok, true);
-  assert.equal(first.files.length, 5);
-  const before = [PLAN_REL, CADENCES_REL, REGISTRY_REL, TSV_REL].map((rel) => readFileSync(join(root, rel), "utf-8"));
-
-  // Same inputs, LATER wall clock — the only thing that would otherwise differ.
-  const second = await emitPlan({ ...opts, plan: planWith([adoptedObjective()]), at: "2026-09-01T12:00:00.000Z" });
-  assert.equal(second.ok, true);
-  assert.equal(second.unchanged, true, "the re-emit is reported as a no-op");
-  assert.deepEqual(second.files, [], "no file was rewritten");
-
-  const after = [PLAN_REL, CADENCES_REL, REGISTRY_REL, TSV_REL].map((rel) => readFileSync(join(root, rel), "utf-8"));
-  assert.deepEqual(after, before, "every artefact is byte-identical");
-  // The derived views are still returned, so a caller can report on them.
-  assert.ok(second.cadences.length > 0 && Object.keys(second.registry).length > 0);
-});
-
-test("a CHANGED mandate still re-emits (the guard is not a freeze)", async () => {
-  const root = tmpRoot();
-  const opts = { agentRoot: root, manifest: manifest(), archetype: "executive-operator@c-suite", at: AT };
-
-  await emitPlan({ ...opts, plan: planWith([]) });
-  const beforeTsv = readFileSync(join(root, TSV_REL), "utf-8");
-
-  // Adopting an objective adds measure/outcome obligations → new hashes.
-  const changed = await emitPlan({ ...opts, plan: planWith([adoptedObjective()]) });
-  assert.equal(changed.unchanged, undefined, "a real change is not a no-op");
-  assert.equal(changed.files.length, 5);
-  assert.notEqual(readFileSync(join(root, TSV_REL), "utf-8"), beforeTsv, "the launchd TSV was updated");
-  assert.equal(readLock(root).obligationsHash, planWith([adoptedObjective()]).obligationsHash);
-});
-
-test("the guard re-emits when a tracked artefact was deleted underneath it", async () => {
-  const root = tmpRoot();
-  const opts = { agentRoot: root, manifest: manifest(), at: AT };
-  await emitPlan({ ...opts, plan: planWith([adoptedObjective()]) });
-
-  // Hashes still match, but the file is gone — a missing launchd TSV must be
-  // rebuilt, not skipped because the lock looks satisfied.
-  const { rmSync } = await import("node:fs");
-  rmSync(join(root, TSV_REL));
-  const res = await emitPlan({ ...opts, plan: planWith([adoptedObjective()]) });
-  assert.equal(res.unchanged, undefined);
-  assert.ok(existsSync(join(root, TSV_REL)), "the deleted artefact is restored");
-});
-
-test("force:true overrides the guard", async () => {
-  const root = tmpRoot();
-  const opts = { agentRoot: root, manifest: manifest(), at: AT };
-  await emitPlan({ ...opts, plan: planWith([adoptedObjective()]) });
-  const res = await emitPlan({ ...opts, plan: planWith([adoptedObjective()]), force: true });
-  assert.equal(res.unchanged, undefined);
-  assert.equal(res.files.length, 5);
-});