@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/setup/sections/mandate.test.mjs

@@ -1,388 +0,0 @@
-/**
- * mandate.test.mjs — the schedule-derivation setup section (order 78).
- * Run: node --test lib/setup/sections/mandate.test.mjs
- *
- * Injected fakes throughout: a fake `mandate.get` / `mandate.propose` transport,
- * a fake clock, a fake cadence set, and `skipPlists` so no launchd generator
- * runs. Nothing touches the network or the real machine.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import yaml from "js-yaml";
-
-import mandate, { loadCompilerInputs, resolveMandate, compileAndEmit, readPriorities } from "./mandate.mjs";
-import { loadSections } from "../runner.mjs";
-import { runGenerator } from "../run-generator.mjs";
-import { readCache, stalenessTier, permissionsForTier, staleSeconds, canonical, checksumOf } from "../../mandate/cache.mjs";
-import { writeManifest } from "../../capability/inventory.mjs";
-import { PLAN_REL, LOCK_REL, CADENCES_REL, REGISTRY_REL, TSV_REL } from "../../plan/emit.mjs";
-import * as io from "../io.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-const AT = "2026-08-11T09:00:00.000Z";
-
-const REACHABLE = ["board_ready", "board_claim", "board_complete", "task_create", "task_update", "crm_list_deals", "knowledge_search", "email_inbox", "email_triage", "email_message", "email_thread", "email_send", "messaging_history", "messaging_send", "messaging_channels", "approval_wait", "decision_list", "calendar_list", "calendar_get", "meetings_recap_file", "memory_author", "knowledge_append", "org_snapshot", "org_events_tail"];
-
-const FAKE_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 FAKE_ARCHETYPE_CADENCES = [
-  ...FAKE_STANDARD,
-  { 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" },
-];
-
-/** An agent repo with a charter, an org context, priorities and a manifest. */
-function tmpAgent({ charter = true, manifest = true, orgContext = true } = {}) {
-  const root = mkdtempSync(join(tmpdir(), "maestro-mandsec-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  writeFileSync(join(root, "config", "agent.json"), JSON.stringify({
-    firstName: "Placeholder",
-    function: "executive-operator",
-    altitude: "c-suite",
-    orgProfile: { memberId: "mem_TEST" },
-    ...(charter ? {
-      charter: {
-        sections: [
-          { kind: "PILLAR", order: 0, id: "cs_1", body: "1) Own execution follow-through across the leadership team." },
-          { kind: "PILLAR", order: 1, id: "cs_2", body: "2) Keep the operating cadence healthy and decisions moving." },
-        ],
-      },
-    } : {}),
-  }, null, 2));
-
-  if (orgContext) {
-    writeFileSync(join(root, "config", "org-context.json"), JSON.stringify({
-      strategy: { streams: [{ code: "GTM", title: "Commercial pipeline coverage" }] },
-    }));
-  }
-  writeFileSync(join(root, "config", "priorities.yaml"), yaml.dump({ priorities: [{ id: "p1", title: "Close the decision backlog" }] }));
-
-  if (manifest) {
-    writeManifest(root, {
-      schemaVersion: 1,
-      generatedAt: AT,
-      counts: { reachable: REACHABLE.length },
-      checksum: "fixture",
-      entries: REACHABLE.map((id) => ({ id, plane: "org", kind: "method_tool", reachable: true, probedAt: AT, blastRadius: "internal", costHint: "free" })),
-      degradations: [],
-    });
-  }
-  return root;
-}
-
-function deps(over = {}) {
-  return {
-    now: () => AT,
-    logImpl: () => {},
-    skipPlists: true,
-    callImpl: null, // "not enrolled" → derive locally
-    standardCadences: FAKE_STANDARD,
-    resolveCadencesImpl: async () => FAKE_ARCHETYPE_CADENCES,
-    ...over,
-  };
-}
-
-function ctxFor(root, answers = {}, over = {}) {
-  return { agentRoot: root, maestroRoot: MAESTRO_ROOT, flags: { headless: true }, answers, io, mandateDeps: deps(over) };
-}
-
-test("REGISTRATION: runner.loadSections() discovers `mandate` at order 78, after org(75) and before verify(90)", async () => {
-  const sections = await loadSections();
-  const ids = sections.map((s) => s.id);
-  assert.ok(ids.includes("mandate"), "auto-discovered by the directory glob — no dispatcher edit");
-  const idx = ids.indexOf("mandate");
-  assert.equal(sections[idx].order, 78);
-  assert.ok(ids.indexOf("org") < idx, "runs after org (75), so org-context.json + charter.sections are on disk");
-  assert.ok(ids.indexOf("inventory") < idx, "runs after inventory (55), so every sensor binds to a probed capability");
-  assert.ok(ids.indexOf("verify") > idx, "runs before verify (90)");
-});
-
-test("section shape: id/order/hooks", () => {
-  assert.equal(mandate.id, "mandate");
-  assert.equal(mandate.order, 78);
-  for (const h of ["detect", "prompt", "apply", "verify"]) assert.equal(typeof mandate[h], "function");
-});
-
-test("detect: unconfigured → partial (charter, no plan) → complete (plan compiled)", async () => {
-  const bare = mkdtempSync(join(tmpdir(), "maestro-mandbare-"));
-  mkdirSync(join(bare, "config"), { recursive: true });
-  assert.equal((await mandate.detect({ agentRoot: bare })).status, "unconfigured");
-
-  const root = tmpAgent();
-  assert.equal((await mandate.detect({ agentRoot: root })).status, "partial");
-
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const done = await mandate.detect({ agentRoot: root });
-  assert.equal(done.status, "complete");
-  assert.match(done.summary, /plan [0-9a-f]{12} · mandate v0/);
-});
-
-test("apply derives a PROPOSED mandate and caches it (nothing adopted by the agent)", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const cache = readCache(root);
-  assert.equal(cache.source, "local");
-  assert.ok(cache.body.objectives.length > 0);
-  assert.ok(cache.body.objectives.every((o) => o.state === "proposed"), "the agent NEVER adopts its own objectives");
-  // charter pillars became PILLAR nodes, and a PLACEABLE objective hangs off one
-  assert.equal(cache.body.objectives.filter((o) => o.kind === "PILLAR").length, 2);
-  const placed = cache.body.objectives.filter((o) => o.kind === "OBJECTIVE" && o.parentKey);
-  assert.ok(placed.length > 0, "at least one objective traces to a charter pillar");
-  for (const o of placed) {
-    // The clause id rides on the ROW, not only on its parent — `mandate.propose`
-    // takes `charterSectionId`, and a node carrying provenance only through
-    // `parentKey` reached hq with both provenance columns null.
-    assert.ok(o.charterSectionId, `"${o.key}" must carry the charter clause id it inherited`);
-  }
-  // An objective the deriver could NOT place is carried unplaced and named —
-  // never auto-attached to whichever pillar happened to be first.
-  for (const o of cache.body.objectives.filter((x) => x.kind === "OBJECTIVE" && !x.parentKey)) {
-    assert.equal(o.charterSectionId, null);
-  }
-});
-
-test("apply with only PROPOSED objectives emits EXACTLY today's cadence set — no schedule growth", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const cad = yaml.load(readFileSync(join(root, CADENCES_REL), "utf8"));
-  const ids = cad.cadences.map((c) => c.id).sort();
-  assert.deepEqual(ids, ["daily-morning-brief", "inbox-processor", "weekly-operating-review"]);
-  const doc = yaml.load(readFileSync(join(root, PLAN_REL), "utf8"));
-  assert.equal(doc.counts.OUTCOME, 0, "proposed objectives compile no OUTCOME obligations");
-  assert.ok(doc.counts.proposedObjectives > 0);
-});
-
-test("an ADOPTED objective grows the schedule: a real measure cadence lands in the TSV generate-plists.sh reads", async () => {
-  const root = tmpAgent();
-  // Simulate hq handing back an adopted mandate.
-  const adopted = {
-    ok: true,
-    result: {
-      version: 4,
-      checksum: "abc",
-      body: {
-        memberId: "mem_TEST",
-        budgetCentsPerPeriod: 500,
-        objectives: [{
-          key: "pipeline-coverage", id: "obj_7Kx", kind: "OBJECTIVE", text: "Pipeline coverage", state: "active",
-          metric: "pipeline_coverage_x", direction: "up", target: 3, tolerance: 0.2, weight: 1, cadence: "weekly",
-          charterSectionId: "cs_1", sensor: { capability: "crm_list_deals", params: { stage: "open" }, source: "method" },
-          // hq stamps this on every adopt; the compiler REQUIRES it (an active row
-          // with no adopter on record compiles nothing — the law fails closed).
-          adoptedById: "mem_A03",
-          collaborators: [{ member_id: "mem_A03", role: "REVIEWER" }],
-        }],
-      },
-    },
-  };
-  await mandate.apply(ctxFor(root, { mandatePropose: true }, { callImpl: async (m) => (m === "mandate.get" ? adopted : { ok: true }) }));
-
-  const cache = readCache(root);
-  assert.equal(cache.source, "server");
-  assert.equal(cache.version, 4);
-
-  const tsv = readFileSync(join(root, TSV_REL), "utf8").trim().split("\n");
-  assert.ok(tsv.some((l) => l.startsWith("measure-pipeline-coverage||")), `measure cadence missing from TSV: ${tsv.join(" / ")}`);
-  assert.ok(tsv.some((l) => l.startsWith("review-pipeline-coverage||")), "the REVIEWER collaborator produced a review cadence");
-
-  const reg = JSON.parse(readFileSync(join(root, REGISTRY_REL), "utf8"));
-  assert.equal(reg["measure-pipeline-coverage"].obligationKey, "schedule.measure.pipeline-coverage");
-  assert.ok(reg["measure-pipeline-coverage"].allowedTools.includes("crm_list_deals"));
-
-  const plan = yaml.load(readFileSync(join(root, PLAN_REL), "utf8"));
-  const outcome = plan.obligations.find((o) => o.key === "outcome.pipeline-coverage");
-  assert.equal(outcome.objective_id, "obj_7Kx");
-  assert.equal(outcome.source.charter_section, "cs_1");
-  assert.equal(outcome.target, 3);
-});
-
-test("the schedule is PER-AGENT: a different charter + KPI set yields a different plan hash", async () => {
-  const a = tmpAgent();
-  const b = tmpAgent();
-  writeFileSync(join(b, "config", "agent.json"), JSON.stringify({
-    firstName: "Placeholder", function: "compliance-officer", altitude: "vp",
-    charter: { sections: [{ kind: "PILLAR", order: 0, id: "cs_9", body: "Own the regulatory perimeter." }] },
-  }, null, 2));
-  await mandate.apply(ctxFor(a, { mandatePropose: true }));
-  await mandate.apply(ctxFor(b, { mandatePropose: true }));
-  const ca = readCache(a);
-  const cb = readCache(b);
-  assert.notDeepEqual(ca.body.objectives.map((o) => o.key), cb.body.objectives.map((o) => o.key));
-});
-
-test("apply is IDEMPOTENT: the same inputs re-emit identical artefacts (no plist churn)", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const before = [CADENCES_REL, REGISTRY_REL, TSV_REL, LOCK_REL].map((r) => readFileSync(join(root, r), "utf8"));
-  await mandate.apply(ctxFor(root, { mandatePropose: false }));
-  const after = [CADENCES_REL, REGISTRY_REL, TSV_REL, LOCK_REL].map((r) => readFileSync(join(root, r), "utf8"));
-  assert.deepEqual(after, before);
-});
-
-test("proposals are OFFERED to hq but the agent never adopts; a rejected propose is non-fatal", async () => {
-  const root = tmpAgent();
-  const calls = [];
-  await mandate.apply(ctxFor(root, { mandatePropose: true }, {
-    callImpl: async (m, p) => {
-      calls.push(m);
-      if (m === "mandate.get") return { ok: false, error: { code: "NOT_FOUND" } };
-      if (m === "mandate.propose") return p.key && p.key.length % 2 === 0 ? { ok: true } : { ok: false, error: { code: "RATE_LIMITED" } };
-      return { ok: true };
-    },
-  }));
-  assert.ok(calls.includes("mandate.get"));
-  assert.ok(calls.filter((c) => c === "mandate.propose").length > 0);
-  assert.ok(!calls.includes("mandate.adopt"), "the agent must NEVER call mandate.adopt for itself");
-  // half the proposals were rejected and the plan still compiled from the cache
-  assert.ok(existsSync(join(root, PLAN_REL)));
-});
-
-test("apply is FATAL when the plan cannot validate (fail-closed, nothing half-written)", async () => {
-  const root = tmpAgent();
-  await assert.rejects(
-    () => mandate.apply(ctxFor(root, { mandatePropose: true }, {
-      // A cadence citing a capability that is not in the manifest.
-      standardCadences: [{ id: "ghost", scope: "function", mode: "escalate", interval: 60, prompt: "p.md" }],
-      resolveCadencesImpl: async () => [{ id: "ghost-fn", scope: "function", mode: "escalate", interval: 60, prompt: "p.md" }],
-      manifestOverride: true,
-    })),
-    /plan failed validation|allowed_tools/,
-  ).catch(() => { /* if the fixture happens to validate, the next assertion covers the contract */ });
-  // The contract that matters: the artefacts are either all present or all absent.
-  const present = [PLAN_REL, LOCK_REL].map((r) => existsSync(join(root, r)));
-  assert.ok(present.every((p) => p === present[0]), "artefacts are written atomically as a set");
-});
-
-test("verify: all six checks, and hashes match after apply", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const v = await mandate.verify(ctxFor(root));
-  const names = v.checks.map((c) => c.name);
-  assert.ok(names.some((n) => /plan\.yaml present/.test(n)));
-  assert.ok(names.some((n) => /compile\.lock present/.test(n)));
-  assert.ok(names.some((n) => /obligationsHash matches compile\.lock/.test(n)));
-  assert.ok(names.some((n) => /no obligation cites an unreachable capability/.test(n)));
-  assert.ok(names.some((n) => /zero OUTCOME obligations with an llm sensor/.test(n)));
-  assert.ok(names.some((n) => /mandate cache freshness/.test(n)));
-  const hashCheck = v.checks.find((c) => /obligationsHash matches/.test(c.name));
-  assert.equal(hashCheck.ok, true, "a fresh apply must leave verify green");
-});
-
-test("verify: an un-adopted mandate is reported as a REMEDY, not a failure", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const v = await mandate.verify(ctxFor(root));
-  const adoptCheck = v.checks.find((c) => /objectives: /.test(c.name));
-  assert.match(adoptCheck.name, /0 adopted/);
-  assert.equal(adoptCheck.ok, true);
-  assert.match(adoptCheck.remedy, /until a human adopts/);
-});
-
-test("verify: hand-editing the compiled plan is caught by the hash check", async () => {
-  const root = tmpAgent();
-  await mandate.apply(ctxFor(root, { mandatePropose: true }));
-  const lockPath = join(root, LOCK_REL);
-  const lock = JSON.parse(readFileSync(lockPath, "utf8"));
-  writeFileSync(lockPath, JSON.stringify({ ...lock, obligationsHash: "deadbeef" }, null, 2));
-  const v = await mandate.verify(ctxFor(root));
-  assert.equal(v.ok, false);
-  assert.match(v.checks.find((c) => /obligationsHash/.test(c.name)).remedy, /re-run/);
-});
-
-test("COMPATIBILITY: on an un-adopted agent the plan compiler reproduces generate-cadences.mjs BYTE-FOR-BYTE", async () => {
-  // The migration guarantee: swapping the producer must not move a single
-  // launchd job. Runs the REAL cadence resolver + the REAL legacy generator.
-  const root = tmpAgent();
-  const realDeps = { now: () => AT, logImpl: () => {}, skipPlists: true, callImpl: null };
-  await mandate.apply({ agentRoot: root, maestroRoot: MAESTRO_ROOT, flags: { headless: true }, answers: { mandatePropose: true }, io, mandateDeps: realDeps });
-  const fromPlan = readFileSync(join(root, TSV_REL), "utf8");
-  const planIds = yaml.load(readFileSync(join(root, CADENCES_REL), "utf8")).cadences.map((c) => c.id).sort();
-
-  const r = runGenerator("generate-cadences.mjs", root, { maestroRoot: MAESTRO_ROOT });
-  assert.equal(r.ok, true, r.stderr);
-  const fromLegacy = readFileSync(join(root, TSV_REL), "utf8");
-  const legacyIds = yaml.load(readFileSync(join(root, CADENCES_REL), "utf8")).cadences.map((c) => c.id).sort();
-
-  assert.equal(fromPlan.split("\n").sort().join("\n"), fromLegacy.split("\n").sort().join("\n"), "launchd TSV is byte-identical → zero plist churn");
-  assert.deepEqual(planIds, legacyIds, "the same cadence set, from a new producer");
-});
-
-test("loadCompilerInputs records a degradation for every missing input (never silent)", async () => {
-  const root = mkdtempSync(join(tmpdir(), "maestro-mandin-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  writeFileSync(join(root, "config", "agent.json"), JSON.stringify({ firstName: "Placeholder" }));
-  const inputs = await loadCompilerInputs({ agentRoot: root, maestroRoot: MAESTRO_ROOT });
-  const kinds = inputs.degradations.map((d) => d.kind);
-  assert.ok(kinds.includes("no_archetype"));
-  assert.ok(kinds.includes("no_manifest"));
-  assert.ok(kinds.includes("no_org_context"));
-});
-
-test("readPriorities tolerates a missing/garbage file", async () => {
-  const root = mkdtempSync(join(tmpdir(), "maestro-mandpri-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  assert.deepEqual(await readPriorities(root), []);
-  writeFileSync(join(root, "config", "priorities.yaml"), "::: not yaml :::\n[[[");
-  assert.deepEqual(await readPriorities(root), []);
-});
-
-test("resolveMandate falls back to LOCAL derivation when hq has no adopted snapshot, and logs why", async () => {
-  const root = tmpAgent();
-  const logs = [];
-  const inputs = await loadCompilerInputs({ agentRoot: root, maestroRoot: MAESTRO_ROOT }, deps());
-  const res = await resolveMandate({ agentRoot: root, inputs }, {
-    callImpl: async () => ({ ok: false, error: { code: "NOT_FOUND" } }),
-    logImpl: (m) => logs.push(m),
-    now: () => AT,
-  });
-  assert.equal(res.source, "local");
-  assert.ok(logs.some((l) => /no adopted snapshot|NOT_FOUND/.test(l)), `expected a logged reason, got ${logs.join(" | ")}`);
-});
-
-test("compileAndEmit is reusable by the standalone generator script", async () => {
-  const root = tmpAgent();
-  const inputs = await loadCompilerInputs({ agentRoot: root, maestroRoot: MAESTRO_ROOT }, deps());
-  const res = await resolveMandate({ agentRoot: root, inputs }, { callImpl: null, logImpl: () => {}, now: () => AT });
-  const out = await compileAndEmit({ agentRoot: root, maestroRoot: MAESTRO_ROOT, inputs, record: res.record }, deps());
-  assert.equal(out.ok, true);
-  assert.equal(out.emit.files.length, 5);
-});
-
-// ── the staleness ladder (§6.4) ──────────────────────────────────────────────
-
-test("staleness ladder: fresh → aging → stale → expired, with the right permissions at each rung", () => {
-  const base = Date.parse(AT);
-  const rec = { fetchedAt: AT };
-  assert.equal(stalenessTier(rec, base + 1000), "fresh");
-  assert.equal(stalenessTier(rec, base + 30 * 3600e3), "aging");
-  assert.equal(stalenessTier(rec, base + 100 * 3600e3), "stale");
-  assert.equal(stalenessTier(rec, base + 9 * 24 * 3600e3), "expired");
-  assert.equal(stalenessTier(null, base), "expired");
-
-  assert.deepEqual(permissionsForTier("fresh"), { react: "full", schedule: "full", outcome: "full" });
-  assert.equal(permissionsForTier("aging").outcome, "suspended", "no NEW self-directed work past 24h");
-  assert.equal(permissionsForTier("stale").react, "offline_safe");
-  assert.equal(permissionsForTier("expired").schedule, "none");
-  assert.equal(staleSeconds(null), Infinity);
-});
-
-test("cache: a corrupt file is reported as corrupt, not silently treated as absent", () => {
-  const root = mkdtempSync(join(tmpdir(), "maestro-mandcache-"));
-  mkdirSync(join(root, "state", "mandate"), { recursive: true });
-  writeFileSync(join(root, "state", "mandate", "cache.json"), "{not json");
-  const rec = readCache(root);
-  assert.equal(rec.corrupt, true);
-  assert.ok(rec.reason);
-});
-
-test("canonical/checksumOf are stable under key reordering", () => {
-  assert.equal(canonical({ b: 1, a: [2, { d: 4, c: 3 }] }), canonical({ a: [2, { c: 3, d: 4 }], b: 1 }));
-  assert.equal(checksumOf({ x: 1, y: 2 }), checksumOf({ y: 2, x: 1 }));
-});

package/lib/setup/sections/messaging.test.mjs

@@ -1,127 +0,0 @@
-/**
- * messaging.test.mjs — org messaging+calling setup section (order 76) tests.
- * Non-blocking (headless ctx), additive scope merge, no destructive writes,
- * best-effort verify. Run: node --test lib/setup/sections/messaging.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import yaml from "js-yaml";
-
-import messaging, { buildMessagingConfig, readOrgConfig, MESSAGING_SCOPES } from "./messaging.mjs";
-import * as io from "../io.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-msgsec-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function ctxFor(root, answers = {}) {
-  return { agentRoot: root, maestroRoot: MAESTRO_ROOT, flags: { headless: true }, answers, io };
-}
-function readCfg(root) {
-  return yaml.load(readFileSync(join(root, "config", "org.yaml"), "utf8"));
-}
-function writeOrg(root, cohort) {
-  writeFileSync(join(root, "config", "org.yaml"), yaml.dump({ org: { cohort } }));
-}
-
-test("section shape: id/order=76/hooks; hooks are functions", () => {
-  assert.equal(messaging.id, "messaging");
-  assert.equal(messaging.order, 76);
-  for (const h of ["detect", "prompt", "apply", "verify"]) assert.equal(typeof messaging[h], "function");
-});
-
-test("buildMessagingConfig: ADDITIVE union of existing scopes + messaging scopes, sorted + de-duped", () => {
-  const existing = { org: { cohort: { enabled: true, base: "b", token: "t", scopes: ["org.read", "messaging.read"] } } };
-  const next = buildMessagingConfig(existing, {});
-  const scopes = next.org.cohort.scopes;
-  for (const s of MESSAGING_SCOPES) assert.ok(scopes.includes(s), `${s} present`);
-  assert.ok(scopes.includes("org.read"), "existing scope preserved");
-  // de-duped (messaging.read appeared in both inputs) + sorted (idempotent write)
-  assert.equal(new Set(scopes).size, scopes.length, "no duplicates");
-  assert.deepEqual(scopes, [...scopes].sort(), "stable-sorted");
-  // never drops base/token
-  assert.equal(next.org.cohort.base, "b");
-  assert.equal(next.org.cohort.token, "t");
-});
-
-test("buildMessagingConfig: home channels merge (union) without clobbering", () => {
-  const existing = { org: { cohort: { enabled: true, base: "b", messaging: { homeChannels: ["C1"] } } } };
-  const next = buildMessagingConfig(existing, { homeChannels: ["C2", "C1"] });
-  assert.deepEqual(next.org.cohort.messaging.homeChannels.sort(), ["C1", "C2"]);
-});
-
-test("detect: unconfigured when there is no org.yaml at all", async () => {
-  const root = tmpRoot();
-  const d = await messaging.detect(ctxFor(root));
-  assert.equal(d.status, "unconfigured");
-});
-
-test("detect: partial when org present but not enrolled", async () => {
-  const root = tmpRoot();
-  writeOrg(root, { enabled: false });
-  const d = await messaging.detect(ctxFor(root));
-  assert.equal(d.status, "partial");
-});
-
-test("detect: complete when enrolled AND messaging scopes recorded", async () => {
-  const root = tmpRoot();
-  writeOrg(root, { enabled: true, base: "https://x", token: "t", scopes: [...MESSAGING_SCOPES] });
-  const d = await messaging.detect(ctxFor(root));
-  assert.equal(d.status, "complete");
-});
-
-test("apply: idempotent + additive — records messaging scopes onto an enrolled org without dropping fields", async () => {
-  const root = tmpRoot();
-  writeOrg(root, { enabled: true, base: "https://cohort.example", token: "tok-1", scopes: ["org.read"] });
-  await messaging.apply(ctxFor(root, { homeChannels: ["C-eng"] }));
-  const cfg = readCfg(root);
-  for (const s of MESSAGING_SCOPES) assert.ok(cfg.org.cohort.scopes.includes(s));
-  assert.ok(cfg.org.cohort.scopes.includes("org.read"), "did not clobber existing scope");
-  assert.equal(cfg.org.cohort.base, "https://cohort.example", "did not clobber base");
-  assert.equal(cfg.org.cohort.token, "tok-1", "did not clobber token");
-  assert.deepEqual(cfg.org.cohort.messaging.homeChannels, ["C-eng"]);
-  assert.equal(cfg.org.cohort.enabled, true, "did not flip enabled");
-
-  // Idempotent: a second apply with no new answers leaves the scope set identical.
-  const before = JSON.stringify(readCfg(root).org.cohort.scopes);
-  await messaging.apply(ctxFor(root, {}));
-  assert.equal(JSON.stringify(readCfg(root).org.cohort.scopes), before, "second apply is a no-op on scopes");
-});
-
-test("apply: never blocks — runs under headless ctx with no answers, writes a non-destructive stub", async () => {
-  const root = tmpRoot();
-  // No org.yaml yet — apply must not throw and must not enable anything.
-  await messaging.apply(ctxFor(root, {}));
-  assert.ok(existsSync(join(root, "config", "org.yaml")));
-  const cfg = readCfg(root);
-  // scopes recorded, but enrollment NOT fabricated (no base/token, enabled falsy).
-  for (const s of MESSAGING_SCOPES) assert.ok(cfg.org.cohort.scopes.includes(s));
-  assert.ok(!cfg.org.cohort.enabled, "apply never enables the org by itself");
-});
-
-test("verify: org not enrolled → ok:true (optional/dormant), with scopes-recorded check", async () => {
-  const root = tmpRoot();
-  await messaging.apply(ctxFor(root, {}));
-  const v = await messaging.verify(ctxFor(root));
-  assert.equal(v.ok, true, "dormant messaging never hard-fails setup");
-  assert.ok(v.checks.some((c) => /scopes recorded/.test(c.name) && c.ok));
-});
-
-test("verify: enrolled → best-effort channels probe, never hard-fails on unreachable", async () => {
-  const root = tmpRoot();
-  writeOrg(root, { enabled: true, base: "https://unreachable.invalid", token: "t", scopes: [...MESSAGING_SCOPES] });
-  // Injected fetch that errors → listChannels fails open to []; verify still ok.
-  const ctx = ctxFor(root);
-  ctx.fetchImpl = async () => { throw new Error("unreachable"); };
-  const v = await messaging.verify(ctx);
-  assert.equal(v.ok, true);
-});