@cohortapp/agent-sdk 2.16.0 → 2.18.4

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

@@ -1,234 +0,0 @@
-/**
- * identity.test.mjs — Cohort-driven setup pull in the identity section.
- *
- * Focuses on the pull seam added for Cohort-driven setup: when COHORT_API_KEY +
- * COHORT_ORG_ID are present, prompt()/apply() PULL the agent's record and merge
- * it into config/agent.json so the prompts CONFIRM (rather than start blank); a
- * locally-customised value is protected unless --force; absent vars leave the
- * manual path unchanged. The real client.fetchSelfProfile is exercised via an
- * injected global fetch (no network).
- *
- * Run: node --test lib/setup/sections/identity.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import identity from "./identity.mjs";
-import { readAgentJson } from "../sot.mjs";
-import * as io from "../io.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-identity-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function ctxFor(root, answers = {}) {
-  return { agentRoot: root, maestroRoot: MAESTRO_ROOT, flags: { headless: true }, answers, io };
-}
-function writeAgent(root, obj) {
-  writeFileSync(join(root, "config", "agent.json"), JSON.stringify(obj, null, 2) + "\n");
-}
-
-const PROFILE = {
-  slug: "robin", kind: "agent", displayName: "Robin Vega", firstName: "Robin", lastName: "Vega",
-  title: "VP Eng", team: "Platform", role: "engineering-lead", agentEmail: "robin@example.com",
-  supervisor: { displayName: "Layla Al-Masri", title: "CTO", email: "layla@example.com" },
-};
-
-function withCohortEnv(vars, fn) {
-  const keys = ["COHORT_API_KEY", "COHORT_ORG_ID", "COHORT_AGENT_ID", "COHORT_BASE"];
-  const saved = Object.fromEntries(keys.map((k) => [k, process.env[k]]));
-  for (const k of keys) delete process.env[k];
-  Object.assign(process.env, vars);
-  return Promise.resolve().then(fn).finally(() => {
-    for (const k of keys) { if (saved[k] === undefined) delete process.env[k]; else process.env[k] = saved[k]; }
-  });
-}
-
-function withFetch(impl, fn) {
-  const saved = globalThis.fetch;
-  globalThis.fetch = impl;
-  return Promise.resolve().then(fn).finally(() => { globalThis.fetch = saved; });
-}
-
-const okFetch = (sink) => async (url) => {
-  if (sink) sink.push(String(url));
-  return { ok: true, status: 200, headers: { get: () => undefined }, json: async () => PROFILE };
-};
-
-test("section shape: id/order=10/hooks", () => {
-  assert.equal(identity.id, "identity");
-  assert.equal(identity.order, 10);
-  for (const h of ["detect", "prompt", "apply", "verify"]) assert.equal(typeof identity[h], "function");
-});
-
-test("prompt: with COHORT_* env, pulls the profile into config/agent.json", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { firstName: "UNCONFIGURED" });
-  const urls = [];
-  await withCohortEnv(
-    { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin", COHORT_BASE: "https://cohort.example" },
-    () => withFetch(okFetch(urls), async () => {
-      const ctx = ctxFor(root);
-      await identity.prompt(ctx);
-      // Headless prompt resolves the answers from the (now pulled) config defaults.
-      assert.equal(ctx.answers.identity.firstName, "Robin");
-      assert.equal(ctx.answers.identity.email, "robin@example.com");
-    })
-  );
-  assert.ok(urls.some((u) => u.includes("/api/v1/org/members/robin")), "members endpoint hit");
-  const id = readAgentJson(root);
-  assert.equal(id.firstName, "Robin", "placeholder overwritten by pull");
-  assert.equal(id.function, "technical-leader");
-});
-
-test("COHORT_AGENT_ID selects /org/members/<id>; absent selects whoami", async () => {
-  const root = tmpRoot();
-  const urls = [];
-  await withCohortEnv(
-    { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_BASE: "https://cohort.example" },
-    () => withFetch(okFetch(urls), async () => {
-      await identity.prompt(ctxFor(root));
-    })
-  );
-  assert.ok(urls.some((u) => u.includes("/api/v1/org/whoami?orgId=acme")), "whoami endpoint hit when no agent id (org sent as the tenant pin, not a member slug)");
-});
-
-test("a local override is NOT clobbered by the pull (without --force)", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { title: "My Custom Title", firstName: "" });
-  await withCohortEnv(
-    { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin", COHORT_BASE: "https://cohort.example" },
-    () => withFetch(okFetch(), async () => {
-      await identity.prompt(ctxFor(root));
-    })
-  );
-  const id = readAgentJson(root);
-  assert.equal(id.title, "My Custom Title", "operator title preserved");
-  assert.equal(id.firstName, "Robin", "empty field still filled from org");
-});
-
-test("absent COHORT_* env → no pull (manual path unchanged)", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { firstName: "UNCONFIGURED" });
-  let fetched = false;
-  await withCohortEnv({}, () => withFetch(async () => { fetched = true; return { ok: true, status: 200, headers: { get: () => undefined }, json: async () => PROFILE }; }, async () => {
-    await identity.prompt(ctxFor(root));
-  }));
-  assert.equal(fetched, false, "no network call without the pull env");
-  assert.equal(readAgentJson(root).firstName, "UNCONFIGURED", "config unchanged");
-});
-
-test("pull is fail-open: a fetch error leaves config untouched", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { firstName: "UNCONFIGURED" });
-  await withCohortEnv(
-    { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin", COHORT_BASE: "https://cohort.example" },
-    () => withFetch(async () => { throw new Error("network down"); }, async () => {
-      await identity.prompt(ctxFor(root)); // must not throw
-    })
-  );
-  assert.equal(readAgentJson(root).firstName, "UNCONFIGURED");
-});
-
-// ---------------------------------------------------------------------------
-// ARCHETYPE AXES (the fatal apply() regression).
-//
-// The wizard used to offer `people-leader` and `compliance-leader`, neither of
-// which has an archetype file on disk. Picking either resolved to nothing and
-// made apply() throw — and because the whole init pipeline downstream
-// (capability pack -> cadences -> plan compiler) keys off this value, a bad axis
-// poisons everything after it. These assert the invariant against the real
-// filesystem, so adding an archetype without offering it (or offering one that
-// does not exist) fails here rather than in a user's setup run.
-// ---------------------------------------------------------------------------
-
-import { FUNCTIONS, ALTITUDES } from "./identity.mjs";
-import { listFunctions, listAltitudes, resolveArchetype } from "../../archetype.mjs";
-import { FUNCTIONS as ENROLL_FUNCTIONS, ALTITUDES as ENROLL_ALTITUDES, deriveFunction, deriveAltitude } from "../enroll-from-cohort.mjs";
-import { loadSections } from "../runner.mjs";
-
-test("every function the wizard offers has an archetype file on disk", () => {
-  const onDisk = listFunctions();
-  for (const f of FUNCTIONS) {
-    assert.ok(onDisk.includes(f.value), `wizard offers "${f.value}" but archetypes/functions/${f.value}.yaml does not exist`);
-  }
-});
-
-test("every archetype on disk is offered by the wizard (no orphaned archetype)", () => {
-  const offered = new Set(FUNCTIONS.map((f) => f.value));
-  for (const f of listFunctions()) {
-    assert.ok(offered.has(f), `archetypes/functions/${f}.yaml exists but the wizard never offers it`);
-  }
-});
-
-test("every altitude the wizard offers has an archetype file, and vice versa", () => {
-  const onDisk = listAltitudes();
-  for (const a of ALTITUDES) assert.ok(onDisk.includes(a.value), `wizard offers altitude "${a.value}" with no archetypes/altitudes/${a.value}.yaml`);
-  const offered = new Set(ALTITUDES.map((a) => a.value));
-  for (const a of onDisk) assert.ok(offered.has(a), `archetypes/altitudes/${a}.yaml exists but the wizard never offers it`);
-});
-
-test("`founder` is reachable from the wizard (it owns runway + investor cadences)", () => {
-  assert.ok(ALTITUDES.some((a) => a.value === "founder"), "founder altitude is offered");
-});
-
-test("the pull path can only derive an axis the wizard can render", () => {
-  // enroll-from-cohort writes function/altitude straight into config/agent.json,
-  // so a value it can derive but the wizard cannot render is an un-resolvable seat.
-  const offeredFns = new Set(FUNCTIONS.map((f) => f.value));
-  for (const f of ENROLL_FUNCTIONS) assert.ok(offeredFns.has(f), `enroll can derive "${f}" which the wizard cannot render`);
-  const offeredAlts = new Set(ALTITUDES.map((a) => a.value));
-  for (const a of ENROLL_ALTITUDES) assert.ok(offeredAlts.has(a), `enroll can derive altitude "${a}" which the wizard cannot render`);
-});
-
-test("the retired axes are gone from BOTH lists", () => {
-  for (const dead of ["people-leader", "compliance-leader"]) {
-    assert.ok(!FUNCTIONS.some((f) => f.value === dead), `wizard still offers the non-existent "${dead}"`);
-    assert.ok(!ENROLL_FUNCTIONS.includes(dead), `enroll can still derive the non-existent "${dead}"`);
-  }
-});
-
-test("the roles that used to derive a dead axis now derive a real one", () => {
-  assert.equal(deriveFunction({ role: "Head of People", team: "HR" }), "operations-leader");
-  assert.equal(deriveFunction({ role: "general counsel", team: "Legal" }), "compliance-officer");
-  assert.equal(deriveFunction({ role: "Head of Product", team: "Product" }), "product-leader");
-  assert.equal(deriveAltitude({ title: "Co-Founder & CEO" }), "founder");
-});
-
-test("every offered (function, altitude) pair actually resolves to an archetype", async () => {
-  // The real end-to-end guarantee: no combination the wizard can produce throws.
-  for (const f of FUNCTIONS) {
-    for (const a of ALTITUDES) {
-      const arch = await resolveArchetype({ function: f.value, altitude: a.value });
-      assert.ok(arch && typeof arch === "object", `resolveArchetype failed for ${f.value}/${a.value}`);
-    }
-  }
-});
-
-test("every derivable pull result resolves to an archetype too", async () => {
-  for (const f of ENROLL_FUNCTIONS) {
-    for (const a of ENROLL_ALTITUDES) {
-      const arch = await resolveArchetype({ function: f, altitude: a });
-      assert.ok(arch && typeof arch === "object", `resolveArchetype failed for pulled ${f}/${a}`);
-    }
-  }
-});
-
-test("the identity section is registered by the directory glob at order 10", async () => {
-  const sections = await loadSections();
-  const s = sections.find((x) => x.id === "identity");
-  assert.ok(s, "identity is discovered by loadSections()");
-  assert.equal(s.order, 10);
-  assert.equal(s.order, identity.order);
-  // It must run before the capability inventory, which reads its archetype.
-  assert.ok(s.order < sections.find((x) => x.id === "inventory").order);
-});

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

@@ -1,198 +0,0 @@
-/**
- * inventory.test.mjs — the capability-inventory setup section (order 55).
- * Run: node --test lib/setup/sections/inventory.test.mjs
- *
- * Also asserts the REGISTRATION mechanism itself: runner.loadSections() globs
- * this directory, so the section must be discoverable and correctly ordered
- * without any core edit.
- */
-"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 inventory, { archetypeOf, declareCapability } from "./inventory.mjs";
-import { loadSections } from "../runner.mjs";
-import { MANIFEST_REL } from "../../capability/inventory.mjs";
-import * as io from "../io.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-
-/**
- * A tmp agent repo, a tmp HOME and a tmp MAESTRO_ROOT. The framework root is
- * faked deliberately: `repair:true` writes marketplace manifests into the plugin
- * dirs it scans, and a test must never mutate the real repo (or the operator's
- * ~/.claude/settings.json).
- */
-function tmpRoot({ archetype = true } = {}) {
-  const root = mkdtempSync(join(tmpdir(), "maestro-invsec-"));
-  const home = mkdtempSync(join(tmpdir(), "maestro-invhome-"));
-  const fakeMaestro = mkdtempSync(join(tmpdir(), "maestro-invfw-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  writeFileSync(join(root, "config", "agent.json"), JSON.stringify(
-    archetype ? { firstName: "Placeholder", function: "executive-operator", altitude: "c-suite" } : { firstName: "Placeholder" },
-  ));
-  mkdirSync(join(root, "plugins", "agent-skills", "skills"), { recursive: true });
-  writeFileSync(join(root, "plugins", "agent-skills", "skills", "morning-brief.md"), "# morning-brief\n");
-  writeFileSync(join(root, ".mcp.json"), JSON.stringify({ mcpServers: { cohort: { command: "cohort-mcp" } } }));
-  return { root, home, fakeMaestro };
-}
-
-function ctxFor(root, home, answers = {}, extra = {}) {
-  return {
-    agentRoot: root,
-    maestroRoot: extra.maestroRoot || MAESTRO_ROOT,
-    flags: { headless: true },
-    answers,
-    io,
-    capabilityDeps: {
-      homeDir: home,
-      now: () => "2026-08-11T09:00:00.000Z",
-      logImpl: () => {},
-      orgToolsImpl: async () => [
-        { name: "board_ready", access: "read", binding: { kind: "rpc" } },
-        { name: "task_create", access: "write", binding: { kind: "rpc" } },
-      ],
-      orgProbeImpl: async () => ({ ok: true, detail: "round-trip ok", mandateFamily: true }),
-      capabilitySurface: async () => ({ workflows: [{ id: "weekly-operating-review", cadence: "weekly" }] }),
-      wishlistImpl: async () => [],
-      callImpl: async () => ({ ok: true, result: {} }),
-      ...(extra.capabilityDeps || {}),
-    },
-  };
-}
-
-test("REGISTRATION: runner.loadSections() discovers `inventory` at order 55, between tools(50) and operating-model(60)", async () => {
-  const sections = await loadSections();
-  const ids = sections.map((s) => s.id);
-  assert.ok(ids.includes("inventory"), "section is auto-discovered by the directory glob — no dispatcher edit");
-  const idx = ids.indexOf("inventory");
-  assert.equal(sections[idx].order, 55);
-  assert.ok(ids.indexOf("tools") < idx, "runs after tools (50)");
-  assert.ok(ids.indexOf("operating-model") > idx, "runs before operating-model (60)");
-});
-
-test("section shape: id/order/hooks", () => {
-  assert.equal(inventory.id, "inventory");
-  assert.equal(inventory.order, 55);
-  for (const h of ["detect", "prompt", "apply", "verify"]) assert.equal(typeof inventory[h], "function");
-});
-
-test("detect: unconfigured → complete across apply()", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  const before = await inventory.detect(ctxFor(root, home, {}, { maestroRoot: fakeMaestro }));
-  assert.equal(before.status, "unconfigured");
-  assert.deepEqual(before.missing, [MANIFEST_REL]);
-
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro }));
-  const after = await inventory.detect(ctxFor(root, home, {}, { maestroRoot: fakeMaestro }));
-  assert.equal(after.status, "complete");
-  assert.match(after.summary, /capabilities/);
-  assert.ok(existsSync(join(root, MANIFEST_REL)));
-});
-
-test("apply writes a durable, queryable manifest with all four planes", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro }));
-  const m = JSON.parse(readFileSync(join(root, MANIFEST_REL), "utf8"));
-  assert.equal(m.schemaVersion, 1);
-  for (const plane of ["builtin", "skill", "mcp", "org"]) {
-    assert.ok(m.counts[plane] > 0, `${plane} plane inventoried`);
-  }
-  assert.ok(m.entries.some((e) => e.id === "skill:agent-skills:morning-brief"));
-  assert.ok(m.entries.some((e) => e.id === "workflow:weekly-operating-review"));
-  assert.ok(m.entries.some((e) => e.id === "mcp:cohort"));
-  assert.ok(m.entries.some((e) => e.id === "board_ready"));
-});
-
-test("apply is IDEMPOTENT — the checksum is stable across runs", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro }));
-  const a = JSON.parse(readFileSync(join(root, MANIFEST_REL), "utf8")).checksum;
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro }));
-  const b = JSON.parse(readFileSync(join(root, MANIFEST_REL), "utf8")).checksum;
-  assert.equal(a, b);
-});
-
-test("apply with repair registers the marketplace so the skills become reachable", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: true }, { maestroRoot: fakeMaestro }));
-  const m = JSON.parse(readFileSync(join(root, MANIFEST_REL), "utf8"));
-  const skill = m.entries.find((e) => e.id === "skill:agent-skills:morning-brief");
-  assert.equal(skill.reachable, true);
-  assert.ok(existsSync(join(root, "plugins", "agent-skills", ".claude-plugin", "marketplace.json")));
-});
-
-test("verify: hard-fails only on a missing/empty manifest; plane emptiness is a SOFT remedy", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  const bad = await inventory.verify(ctxFor(root, home, {}, { maestroRoot: fakeMaestro }));
-  assert.equal(bad.ok, false);
-
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro }));
-  const good = await inventory.verify(ctxFor(root, home, {}, { maestroRoot: fakeMaestro }));
-  assert.equal(good.ok, true, JSON.stringify(good.checks.filter((c) => !c.ok)));
-  const names = good.checks.map((c) => c.name);
-  assert.ok(names.some((n) => /every entry carries/.test(n)));
-  assert.ok(names.some((n) => /skill plane/.test(n)));
-  // The unregistered-marketplace state is reported (the archetype workflow IS
-  // reachable, the skill file is NOT), and it never hard-fails setup.
-  const skillCheck = good.checks.find((c) => /skill plane/.test(c.name));
-  assert.equal(skillCheck.ok, true);
-  assert.match(skillCheck.name, /skill plane: 1\/2 reachable/);
-  const degCheck = good.checks.find((c) => /degradations recorded/.test(c.name));
-  assert.equal(degCheck.ok, true);
-  assert.match(degCheck.remedy, /capability-manifest\.json/);
-});
-
-test("verify: a plane with ZERO reachable entries surfaces an explicit remedy (never silent)", async () => {
-  const { root, home, fakeMaestro } = tmpRoot();
-  await inventory.apply(ctxFor(root, home, { capabilityRepair: false }, { maestroRoot: fakeMaestro,
-    capabilityDeps: { orgProbeImpl: async () => ({ ok: false, detail: "org.cohort is not enabled", degraded: "org-not-enrolled", mandateFamily: false }) },
-  }));
-  const v = await inventory.verify(ctxFor(root, home, {}, { maestroRoot: fakeMaestro }));
-  const orgCheck = v.checks.find((c) => /org plane/.test(c.name));
-  assert.equal(orgCheck.ok, true, "an un-enrolled agent is a legitimate init state");
-  assert.match(orgCheck.remedy, /nothing on the org plane is reachable/);
-  assert.equal(v.ok, true);
-});
-
-test("archetypeOf reads the SoT and returns null when unset", () => {
-  const { root } = tmpRoot();
-  assert.deepEqual(archetypeOf(root), { function: "executive-operator", altitude: "c-suite" });
-  const { root: bare } = tmpRoot({ archetype: false });
-  assert.equal(archetypeOf(bare), null);
-});
-
-test("declareCapability fails OPEN and LOGS when hq rejects or is absent", async () => {
-  const { root } = tmpRoot();
-  const logs = [];
-  const rejected = await declareCapability(root, { schemaVersion: 1, entries: [] }, {
-    callImpl: async () => ({ ok: false, error: { code: "NOT_FOUND" } }),
-    logImpl: (m) => logs.push(m),
-  });
-  assert.equal(rejected.posted, false);
-  assert.equal(rejected.reason, "NOT_FOUND");
-  assert.ok(logs.some((l) => /kept local only/.test(l)), "the degradation is never silent");
-
-  const threw = await declareCapability(root, { schemaVersion: 1, entries: [] }, {
-    callImpl: async () => { throw new Error("ECONNREFUSED"); },
-    logImpl: (m) => logs.push(m),
-  });
-  assert.equal(threw.posted, false);
-  assert.ok(logs.some((l) => /ECONNREFUSED/.test(l)));
-});
-
-test("declareCapability sends ids + reachability only — never invocation details", async () => {
-  const { root } = tmpRoot();
-  let sent = null;
-  await declareCapability(root, {
-    schemaVersion: 1,
-    entries: [{ id: "board_ready", plane: "org", kind: "method_tool", reachable: true, probedAt: "t", blastRadius: "internal", costHint: "free", invocation: "board_ready", probe: { detail: "secret" } }],
-  }, { callImpl: async (m, p) => { sent = { m, p }; return { ok: true }; }, logImpl: () => {} });
-  assert.equal(sent.m, "mandate.declareCapability");
-  assert.deepEqual(Object.keys(sent.p.body[0]).sort(), ["blastRadius", "costHint", "id", "kind", "plane", "probedAt", "reachable"]);
-});

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

@@ -1,81 +0,0 @@
-/**
- * learning.test.mjs — WS3 setup section (order 80) tests.
- * Run: node --test lib/setup/sections/learning.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, existsSync, readFileSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import learning from "./learning.mjs";
-import * as io from "../io.mjs";
-
-const MAESTRO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-learnsec-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function ctxFor(root, answers = {}) {
-  return { agentRoot: root, maestroRoot: MAESTRO_ROOT, flags: { headless: true }, answers, io };
-}
-
-test("section shape: id/order/hooks", () => {
-  assert.equal(learning.id, "learning");
-  assert.equal(learning.order, 80);
-  for (const h of ["detect", "prompt", "apply", "verify"]) assert.equal(typeof learning[h], "function");
-});
-
-test("detect: unconfigured before apply, complete after", async () => {
-  const root = tmpRoot();
-  const before = await learning.detect(ctxFor(root));
-  assert.equal(before.status, "unconfigured");
-
-  await learning.apply(ctxFor(root, { learningEnabled: true }));
-  // config + counters now exist; hook is NOT wired on a CI machine → partial.
-  const after = await learning.detect(ctxFor(root));
-  assert.ok(["complete", "partial"].includes(after.status));
-  assert.ok(existsSync(join(root, "config", "learning.yaml")));
-  assert.ok(existsSync(join(root, "state", "learning", "counters.json")));
-  // Counters seeded to zero state.
-  const c = JSON.parse(readFileSync(join(root, "state", "learning", "counters.json"), "utf8"));
-  assert.equal(c.tool_uses_since_skill, 0);
-});
-
-test("apply: disabled choice writes enabled:false and skips seeding", async () => {
-  const root = tmpRoot();
-  await learning.apply(ctxFor(root, { learningEnabled: false }));
-  const body = readFileSync(join(root, "config", "learning.yaml"), "utf8");
-  assert.match(body, /enabled:\s*false/);
-  assert.ok(!existsSync(join(root, "state", "learning", "counters.json")), "no counters when disabled");
-  const det = await learning.detect(ctxFor(root));
-  assert.equal(det.status, "complete");
-  assert.match(det.summary, /disabled/);
-});
-
-test("verify: config + counters checks; hook is a soft (non-failing) check", async () => {
-  const root = tmpRoot();
-  await learning.apply(ctxFor(root, { learningEnabled: true }));
-  const v = await learning.verify(ctxFor(root));
-  const names = v.checks.map((c) => c.name);
-  assert.ok(names.some((n) => /config\/learning\.yaml/.test(n)));
-  assert.ok(names.some((n) => /counters seeded/.test(n)));
-  // The hook check never hard-fails verify (so CI / fresh repos stay green).
-  const hookCheck = v.checks.find((c) => /Stop-hook/.test(c.name));
-  assert.equal(hookCheck.ok, true);
-  assert.equal(v.ok, true);
-});
-
-test("apply: idempotent — re-apply does not clobber an existing config", async () => {
-  const root = tmpRoot();
-  // Operator hand-customised config.
-  writeFileSync(join(root, "config", "learning.yaml"), "enabled: true\nminTurns: 9\n# custom\n");
-  await learning.apply(ctxFor(root, { learningEnabled: true }));
-  const body = readFileSync(join(root, "config", "learning.yaml"), "utf8");
-  assert.match(body, /minTurns: 9/, "existing customisation preserved");
-});