@cohortapp/agent-sdk 2.16.0 → 2.18.4

package/lib/setup/enroll-from-cohort.test.mjs

@@ -1,300 +0,0 @@
-/**
- * enroll-from-cohort.test.mjs — pull-and-map a Cohort MemberProfileDTO into
- * the config/agent.json subset, with local-customisation protection + diff.
- * Run: node --test lib/setup/enroll-from-cohort.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 } from "node:path";
-
-import {
-  mapProfileToAgentConfig,
-  mergeProfilePatch,
-  diffPatch,
-  deriveFunction,
-  deriveAltitude,
-  cohortPullEnv,
-  pullAndPlan,
-  FUNCTIONS,
-  ALTITUDES,
-} from "./enroll-from-cohort.mjs";
-import { readAgentJson } from "./sot.mjs";
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-enroll-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function writeAgent(root, obj) {
-  writeFileSync(join(root, "config", "agent.json"), JSON.stringify(obj, null, 2) + "\n");
-}
-
-// A representative MemberProfileDTO from the org-data API.
-const PROFILE = {
-  slug: "robin",
-  kind: "agent",
-  displayName: "Robin Vega",
-  firstName: "Robin",
-  lastName: "Vega",
-  title: "VP of Engineering",
-  team: "Platform Engineering",
-  role: "engineering-lead",
-  agentEmail: "robin@example.com",
-  supervisor: { displayName: "Layla Al-Masri", title: "CTO", email: "layla@example.com" },
-  profileSections: [
-    { id: "operating-principles", content: "- Ship small\n- Default to autonomy\n- Escalate blockers fast" },
-    { id: "responsibilities", items: ["Own CI/CD", "Run platform on-call"] },
-    { id: "communication", content: "Direct, technical, low-ceremony." },
-  ],
-};
-
-// The shape the LIVE org-data API actually returns: role/team are objects, and
-// the supervisor nests its title the same way. The flat PROFILE above is the
-// legacy/wizard shape — both must map identically. Regression fixture for the
-// enrolment that shipped an agent with title:"", altitude:"c-suite" and a
-// principal with no title, because every field below was read one level too high.
-const NESTED_PROFILE = {
-  slug: "A016",
-  kind: "AI_AGENT",
-  status: "ACTIVE",
-  displayName: "Agent One",
-  firstName: "Agent",
-  lastName: "One",
-  team: { slug: "ai-systems-agent-platform", name: "AI Systems & Agent Platform", shortLabel: "AI Systems" },
-  role: { title: "SVP AI Systems & Agent Platform", level: "SVP", status: "ACTIVE" },
-  agentEmail: "agent-one@example.test",
-  supervisor: {
-    slug: "A002",
-    displayName: "Samir Al Sulaiti",
-    role: { title: "Chief Product & Technology Officer", level: "C_SUITE", status: "ACTIVE" },
-    team: { slug: "product-technology-platform", name: "Product, Technology & Platform" },
-  },
-};
-
-test("mapProfileToAgentConfig reads the nested (live) DTO shape", () => {
-  const patch = mapProfileToAgentConfig(NESTED_PROFILE);
-  assert.equal(patch.title, "SVP AI Systems & Agent Platform", "title comes from role.title");
-  assert.equal(patch.function, "technical-leader", "derived from the platform/AI-systems team");
-  assert.equal(patch.altitude, "svp", "role.level beats keyword-guessing the title");
-  assert.equal(patch.principal.fullName, "Samir Al Sulaiti");
-  assert.equal(patch.principal.title, "Chief Product & Technology Officer", "supervisor title comes from role.title");
-});
-
-test("an object leaf never stringifies into a derivation", () => {
-  // `String({})` is the truthy "[object Object]"; letting it through made every
-  // derivation silently fall back to its default instead of reporting no signal.
-  assert.equal(mapProfileToAgentConfig({ role: {}, team: {} }).function, undefined, "no axis signal → no axis emitted");
-  assert.equal(deriveFunction({ role: { title: "Staff Engineer" } }), "technical-leader");
-  assert.equal(deriveAltitude({ role: { level: "SENIOR_MANAGER" } }), "senior-manager");
-});
-
-test("mapProfileToAgentConfig maps the authoritative fields", () => {
-  const patch = mapProfileToAgentConfig(PROFILE);
-  assert.equal(patch.firstName, "Robin");
-  assert.equal(patch.lastName, "Vega");
-  assert.equal(patch.fullName, "Robin Vega");
-  assert.equal(patch.title, "VP of Engineering");
-  assert.equal(patch.email, "robin@example.com");
-  assert.equal(patch.function, "technical-leader");
-  assert.equal(patch.altitude, "vp");
-  assert.equal(patch.principal.fullName, "Layla Al-Masri");
-  assert.equal(patch.principal.title, "CTO");
-  assert.equal(patch.principal.email, "layla@example.com");
-  assert.deepEqual(patch.operatingPrinciples, ["Ship small", "Default to autonomy", "Escalate blockers fast"]);
-  assert.deepEqual(patch.responsibilities, ["Own CI/CD", "Run platform on-call"]);
-  assert.equal(patch.communication.defaultTone, "Direct, technical, low-ceremony.");
-});
-
-test("mapProfileToAgentConfig is fail-open on a null/empty profile", () => {
-  assert.deepEqual(mapProfileToAgentConfig(null), {});
-  assert.deepEqual(mapProfileToAgentConfig({}), {});
-  // A bare role signal IS enough to derive an axis.
-  assert.equal(mapProfileToAgentConfig({ role: "engineer" }).function, "technical-leader");
-});
-
-// A MemberProfileDTO carrying the Cohort-authored charter + the authoritative
-// operating fields the mapper previously DROPPED.
-const PROFILE_FULL = {
-  ...PROFILE,
-  autonomyLevel: "high",
-  escalationPath: "CTO, then CEO for irreversible decisions",
-  operatingChannel: "#platform",
-  skills: ["ci-cd", "incident-response"],
-  reports: [{ member: { slug: "kai", displayName: "Kai Tan" }, style: "SOLID" }],
-  governance: [{ type: "ADVISES", direction: "out", counterpart: { slug: "secops" }, theme: "security" }],
-  charter: {
-    approvedByLine: "Approved by Layla Al-Masri, CTO — 2026-06-01",
-    gatesText: "All irreversible spend > $10k escalates.",
-    sections: [
-      { kind: "purpose", order: 1, title: "Purpose & Mandate", body: "Own platform reliability and developer velocity." },
-      { kind: "decision_rights", order: 2, title: null, body: "Owns deploy cadence; recommends headcount." },
-    ],
-  },
-};
-
-test("mapProfileToAgentConfig captures the Cohort-authored charter (SoT)", () => {
-  const patch = mapProfileToAgentConfig(PROFILE_FULL);
-  assert.ok(patch.charter, "charter present in patch");
-  assert.equal(patch.charter.approvedByLine, "Approved by Layla Al-Masri, CTO — 2026-06-01");
-  assert.equal(patch.charter.gatesText, "All irreversible spend > $10k escalates.");
-  assert.equal(patch.charter.sections.length, 2);
-  assert.equal(patch.charter.sections[0].title, "Purpose & Mandate");
-  assert.equal(patch.charter.sections[1].title, null);
-  assert.match(patch.charter.sections[1].body, /Owns deploy cadence/);
-});
-
-test("mapProfileToAgentConfig persists the authoritative org operating fields", () => {
-  const patch = mapProfileToAgentConfig(PROFILE_FULL);
-  assert.ok(patch.orgProfile, "orgProfile present in patch");
-  assert.equal(patch.orgProfile.autonomyLevel, "high");
-  assert.match(patch.orgProfile.escalationPath, /CTO/);
-  assert.equal(patch.orgProfile.operatingChannel, "#platform");
-  assert.deepEqual(patch.orgProfile.skills, ["ci-cd", "incident-response"]);
-  assert.equal(patch.orgProfile.reports[0].member.slug, "kai");
-  assert.equal(patch.orgProfile.governance[0].type, "ADVISES");
-});
-
-test("charter/orgProfile absent → no charter/orgProfile keys (empty patch stays empty)", () => {
-  const patch = mapProfileToAgentConfig(PROFILE); // base fixture has neither
-  assert.equal(patch.charter, undefined);
-  assert.equal(patch.orgProfile, undefined);
-  // A charter with no real content is also dropped.
-  const noContent = mapProfileToAgentConfig({ charter: { approvedByLine: "", gatesText: "", sections: [] } });
-  assert.equal(noContent.charter, undefined);
-});
-
-test("deriveFunction + deriveAltitude resolve to valid axes (safe default)", () => {
-  assert.ok(FUNCTIONS.includes(deriveFunction({ role: "sales lead", team: "Revenue" })));
-  assert.equal(deriveFunction({ role: "sales lead", team: "Revenue" }), "commercial-leader");
-  // `compliance-leader` resolves to no archetype on disk; the rule map returns
-  // the archetype that does exist. The expectation, not the code, was stale.
-  assert.equal(deriveFunction({ role: "general counsel", team: "Legal" }), "compliance-officer");
-  assert.equal(deriveFunction({ role: "weird-unknown-role" }), "executive-operator");
-  assert.ok(ALTITUDES.includes(deriveAltitude({ title: "Chief Technology Officer" })));
-  assert.equal(deriveAltitude({ title: "Chief Technology Officer" }), "c-suite");
-  assert.equal(deriveAltitude({ title: "Senior Manager, Ops" }), "senior-manager");
-  assert.equal(deriveAltitude({ title: "Mystery" }), "c-suite");
-});
-
-test("mergeProfilePatch protects a locally-customised value unless --force", () => {
-  const current = { firstName: "Robin", title: "Custom Title The Operator Set", email: "" };
-  const patch = mapProfileToAgentConfig(PROFILE);
-  const reduced = mergeProfilePatch(current, patch, { force: false });
-  // title is locally set → dropped; email is empty → kept; firstName equals → still set is fine
-  assert.equal(reduced.title, undefined, "local title is NOT clobbered");
-  assert.equal(reduced.email, "robin@example.com", "empty local value gets filled");
-  // With --force, the org value wins.
-  const forced = mergeProfilePatch(current, patch, { force: true });
-  assert.equal(forced.title, "VP of Engineering");
-});
-
-test("mergeProfilePatch reduces nested objects leaf-by-leaf", () => {
-  const current = { principal: { fullName: "Existing Boss", title: "" } };
-  const patch = mapProfileToAgentConfig(PROFILE);
-  const reduced = mergeProfilePatch(current, patch, { force: false });
-  assert.equal(reduced.principal.fullName, undefined, "local principal.fullName kept");
-  assert.equal(reduced.principal.title, "CTO", "empty principal.title filled");
-});
-
-test("mergeProfilePatch treats a placeholder string as unset", () => {
-  const current = { title: "UNCONFIGURED" };
-  const reduced = mergeProfilePatch(current, { title: "VP of Engineering" }, { force: false });
-  assert.equal(reduced.title, "VP of Engineering");
-});
-
-test("diffPatch reports leaf-level changes including nested + array", () => {
-  const before = { title: "Old", principal: { title: "Old VP" } };
-  const patch = { title: "VP of Engineering", principal: { title: "CTO" }, responsibilities: ["a", "b"] };
-  const diff = diffPatch(before, patch);
-  const byPath = Object.fromEntries(diff.map((d) => [d.path, d]));
-  assert.equal(byPath["title"].from, "Old");
-  assert.equal(byPath["title"].to, "VP of Engineering");
-  assert.equal(byPath["principal.title"].to, "CTO");
-  assert.ok(byPath["responsibilities"], "array change is reported");
-});
-
-test("cohortPullEnv gates on api key + org id; agent id optional", () => {
-  assert.equal(cohortPullEnv({}).enabled, false);
-  assert.equal(cohortPullEnv({ COHORT_API_KEY: "k" }).enabled, false);
-  const e = cohortPullEnv({ COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin" });
-  assert.equal(e.enabled, true);
-  assert.equal(e.apiKey, "k");
-  assert.equal(e.orgId, "acme");
-  assert.equal(e.agentId, "robin");
-});
-
-test("pullAndPlan: with env + mocked profile, plans a patch and a diff", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { firstName: "UNCONFIGURED" });
-  const plan = await pullAndPlan({
-    agentRoot: root,
-    env: { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin" },
-    fetchSelfProfileImpl: async () => ({ ok: true, result: PROFILE }),
-  });
-  assert.equal(plan.pulled, true);
-  assert.equal(plan.patch.firstName, "Robin", "placeholder firstName overwritten");
-  assert.equal(plan.patch.email, "robin@example.com");
-  assert.ok(plan.changes.length > 0);
-});
-
-test("pullAndPlan: absent env → not pulled (manual path stands)", async () => {
-  const root = tmpRoot();
-  const plan = await pullAndPlan({
-    agentRoot: root,
-    env: {},
-    fetchSelfProfileImpl: async () => ({ ok: true, result: PROFILE }),
-  });
-  assert.equal(plan.pulled, false);
-  assert.deepEqual(plan.patch, {});
-  assert.deepEqual(plan.changes, []);
-});
-
-test("pullAndPlan: fetch failure → fail-open, not pulled", async () => {
-  const root = tmpRoot();
-  const plan = await pullAndPlan({
-    agentRoot: root,
-    env: { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme" },
-    fetchSelfProfileImpl: async () => ({ ok: false, error: { code: "INTERNAL", message: "down" } }),
-  });
-  assert.equal(plan.pulled, false);
-  assert.deepEqual(plan.patch, {});
-});
-
-test("pullAndPlan: a local override is NOT clobbered without --force", async () => {
-  const root = tmpRoot();
-  writeAgent(root, { title: "My Custom Title" });
-  const env = { COHORT_API_KEY: "k", COHORT_ORG_ID: "acme", COHORT_AGENT_ID: "robin" };
-  const noForce = await pullAndPlan({ agentRoot: root, env, fetchSelfProfileImpl: async () => ({ ok: true, result: PROFILE }) });
-  assert.equal(noForce.patch.title, undefined, "custom title protected");
-  const forced = await pullAndPlan({ agentRoot: root, env, force: true, fetchSelfProfileImpl: async () => ({ ok: true, result: PROFILE }) });
-  assert.equal(forced.patch.title, "VP of Engineering", "--force overwrites");
-});
-
-test("persona falls back to the SUMMARY section and then the top-level bio", () => {
-  // A live Cohort seat had its prose in a section named SUMMARY and in the
-  // DTO's top-level `bio` — neither of which the original name list matched.
-  // The result was an empty persona, an unresolved {{agent.persona}} in
-  // CLAUDE.md, and no Background line in the prompt: exactly the generic-seat
-  // failure this mapping exists to prevent.
-  const fromSummary = mapProfileToAgentConfig({
-    profileSections: [{ kind: "SUMMARY", body: "I build the agent substrate." }],
-  });
-  assert.equal(fromSummary.persona, "I build the agent substrate.");
-
-  const fromBio = mapProfileToAgentConfig({ bio: "I run platform engineering." });
-  assert.equal(fromBio.persona, "I run platform engineering.");
-
-  // An explicitly authored section still wins over the terser bio.
-  const both = mapProfileToAgentConfig({
-    bio: "short bio",
-    profileSections: [{ kind: "background", body: "the long authored version" }],
-  });
-  assert.equal(both.persona, "the long authored version");
-
-  // Nothing to say stays empty — we never synthesise a persona.
-  assert.equal(mapProfileToAgentConfig({}).persona, undefined);
-});

package/lib/setup/integration.test.mjs

@@ -1,162 +0,0 @@
-/**
- * integration.test.mjs — end-to-end `maestro setup` acceptance (WS1 done-bar).
- *
- * Creates a temp agent repo seeded from scaffold/config, runs the runner in
- * --headless with a fixture answers file (maestroRoot = the real repo so the
- * deterministic generators run for real), and asserts:
- *   1. a GREEN completeness gate after the run,
- *   2. config/agent.ts is a thin SoT wrapper,
- *   3. re-running is a no-op (operating-model + identity skipped).
- *
- * The `claude --print` enrichment spawn is INJECTED (fake) so the test is
- * hermetic — no network. Generators that only template from agent.json run real.
- *
- * Run: `node --test lib/setup/integration.test.mjs`
- * @module lib/setup/integration.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, copyFileSync, readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { runSetup, loadSections } from "./runner.mjs";
-import { assertComplete } from "./completeness.mjs";
-import { isWrapper } from "./sot.mjs";
-import { loadProgress } from "./state.mjs";
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const MAESTRO_ROOT = resolve(HERE, "..", "..");
-
-/** A fixture answers file: everything the headless sections need. */
-const ANSWERS = {
-  firstName: "Jacob", lastName: "Chen", title: "VP, Engineering", email: "jacob@acme.com",
-  function: "technical-leader", altitude: "vp",
-  principalName: "Dana Reyes", principalTitle: "CEO", principalEmail: "dana@acme.com",
-  companyName: "Acme", companyWebsite: "https://acme.com", companyDomain: "acme.com",
-  companyIndustry: "Developer tooling", companyStage: "Series B", companyTagline: "Ship faster",
-  provider: "subscription",
-  channels: ["slack", "gmail"],
-};
-
-/** Fake enrichment spawn — returns valid JSON for whatever keys are requested. */
-function fakeEnrichSpawn(prompt) {
-  // The system prompt lists the keys as JSON; pick a sensible filler per key.
-  const m = prompt.system.match(/ONLY these keys:\s*(\[[^\]]*\])/);
-  let keys = [];
-  try { keys = m ? JSON.parse(m[1]) : []; } catch { keys = []; }
-  const out = {};
-  for (const k of keys) {
-    if (k === "responsibilities" || k === "operatingPrinciples") {
-      out[k] = ["Own platform reliability and delivery confidence", "Keep the engineering org unblocked and accountable"];
-    } else if (k === "persona") {
-      out[k] = "A pragmatic engineering leader who keeps delivery honest and the team focused on outcomes.";
-    } else if (k === "description") {
-      out[k] = "Acme builds developer tooling that helps fintechs ship faster with confidence.";
-    } else {
-      out[k] = "Concrete, company-specific copy that reads like a colleague wrote it.";
-    }
-  }
-  return Promise.resolve(JSON.stringify(out));
-}
-
-function seedAgentRepo() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-int-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  // Seed agent.json from the scaffold (placeholder identity) + agent.ts standalone literal.
-  copyFileSync(join(MAESTRO_ROOT, "scaffold", "config", "agent.json"), join(root, "config", "agent.json"));
-  copyFileSync(join(MAESTRO_ROOT, "scaffold", "config", "agent.ts"), join(root, "config", "agent.ts"));
-  copyFileSync(join(MAESTRO_ROOT, "scaffold", "config", "company.json"), join(root, "config", "company.json"));
-  writeFileSync(join(root, "README.md"), "# Acme agent\nAutonomous engineering leader for Acme.\n");
-  writeFileSync(join(root, ".env"), "");
-  return root;
-}
-
-test("maestro setup --headless produces a green operating model + wrapper, re-run is a no-op", async () => {
-  const root = seedAgentRepo();
-  const sections = await loadSections();
-
-  // First run.
-  const res = await runSetup({
-    agentRoot: root,
-    maestroRoot: MAESTRO_ROOT,
-    sections,
-    flags: { resume: false, from: null, only: null, status: false, headless: true, answersFile: null, noEnrich: false, dryRun: false, verbose: false, help: false },
-    answers: ANSWERS,
-    enrichSpawn: fakeEnrichSpawn,
-  });
-
-  // identity + company + operating-model all ran.
-  assert.ok(res.ran.includes("identity"), "identity ran");
-  assert.ok(res.ran.includes("operating-model"), "operating-model ran");
-
-  // 1. Green completeness gate.
-  const gate = await assertComplete(root);
-  assert.equal(gate.ok, true, "completeness gate green; missing: " + JSON.stringify(gate.missing));
-
-  // 2. agent.ts is the thin wrapper (born unified).
-  assert.ok(isWrapper(readFileSync(join(root, "config", "agent.ts"), "utf-8")), "agent.ts is a SoT wrapper");
-
-  // identity was actually written.
-  const id = JSON.parse(readFileSync(join(root, "config", "agent.json"), "utf-8"));
-  assert.equal(id.firstName, "Jacob");
-  assert.equal(id.function, "technical-leader");
-  assert.equal(id.altitude, "vp");
-  // enriched prose landed.
-  assert.ok(Array.isArray(id.responsibilities) && id.responsibilities.length >= 1, "responsibilities enriched");
-
-  // verify section produced a result and it is ok (no hard failures).
-  assert.ok(res.verify, "verify ran");
-
-  // 3. Re-run is a no-op for the heavy sections.
-  const res2 = await runSetup({
-    agentRoot: root,
-    maestroRoot: MAESTRO_ROOT,
-    sections,
-    flags: { resume: true, from: null, only: null, status: false, headless: true, answersFile: null, noEnrich: false, dryRun: false, verbose: false, help: false },
-    answers: ANSWERS,
-    enrichSpawn: fakeEnrichSpawn,
-  });
-  assert.ok(res2.skipped.includes("identity"), "identity skipped on re-run");
-  assert.ok(res2.skipped.includes("operating-model"), "operating-model skipped on re-run");
-  assert.ok(res2.skipped.includes("company"), "company skipped on re-run");
-
-  // checkpoint recorded the completed sections.
-  const prog = loadProgress(root);
-  assert.equal(prog.sections["operating-model"].status, "complete");
-});
-
-test("maestro setup --status runs detect on every section without writing", async () => {
-  const root = seedAgentRepo();
-  const sections = await loadSections();
-  const res = await runSetup({
-    agentRoot: root,
-    maestroRoot: MAESTRO_ROOT,
-    sections,
-    flags: { resume: false, from: null, only: null, status: true, headless: true, answersFile: null, noEnrich: false, dryRun: false, verbose: false, help: false },
-    answers: {},
-  });
-  assert.equal(res.status, true);
-  // status must not have generated the operating model.
-  assert.equal(existsSync(join(root, "config", "operating-charter.md")), false);
-});
-
-test("maestro setup --no-enrich leaves prose skeletons but still completes the gate", async () => {
-  const root = seedAgentRepo();
-  const sections = await loadSections();
-  await runSetup({
-    agentRoot: root,
-    maestroRoot: MAESTRO_ROOT,
-    sections,
-    flags: { resume: false, from: null, only: null, status: false, headless: true, answersFile: null, noEnrich: true, dryRun: false, verbose: false, help: false },
-    answers: ANSWERS,
-  });
-  // The deterministic operating-model artifacts still exist...
-  assert.ok(existsSync(join(root, "config", "agent-roster.yaml")));
-  // ...but the charter still carries TBD slots (not enriched), so the gate is NOT green.
-  const gate = await assertComplete(root);
-  assert.equal(gate.ok, false, "without enrichment, charter TBD slots keep the gate red");
-});

package/lib/setup/io.test.mjs

@@ -1,77 +0,0 @@
-/**
- * io.test.mjs — headless-mode + helper tests for lib/setup/io.mjs.
- * Interactive raw-mode paths are not exercised here (no TTY in CI); we test the
- * pure helpers and the headless contract (no blocking, pre-supplied answers).
- * Run: `node --test lib/setup/io.test.mjs`
- * @module lib/setup/io.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import {
-  text, select, multiselect, confirm, secret,
-  isHeadless, resolveAnswer, stripBracketedPaste,
-} from "./io.mjs";
-
-const HL = { headless: true, answers: {} };
-
-test("isHeadless is true when ctx.headless set", () => {
-  assert.equal(isHeadless({ headless: true }), true);
-});
-
-test("resolveAnswer prefers answers, then env, then default", () => {
-  assert.equal(resolveAnswer({ answers: { k: "a" } }, "k", { default: "d" }), "a");
-  process.env.__IO_TEST_ENV = "fromenv";
-  assert.equal(resolveAnswer({ answers: {} }, "k", { env: "__IO_TEST_ENV", default: "d" }), "fromenv");
-  delete process.env.__IO_TEST_ENV;
-  assert.equal(resolveAnswer({ answers: {} }, "k", { default: "d" }), "d");
-  assert.equal(resolveAnswer({ answers: {} }, "k", {}), undefined);
-});
-
-test("stripBracketedPaste removes paste markers", () => {
-  assert.equal(stripBracketedPaste("\x1b[200~hello\x1b[201~"), "hello");
-  assert.equal(stripBracketedPaste("plain"), "plain");
-});
-
-test("text returns pre-supplied answer in headless mode (never blocks)", async () => {
-  const v = await text({ ...HL, answers: { name: "Jacob" } }, { message: "Name?", key: "name" });
-  assert.equal(v, "Jacob");
-});
-
-test("text falls back to default when no answer", async () => {
-  const v = await text(HL, { message: "Name?", key: "missing", default: "Anon" });
-  assert.equal(v, "Anon");
-});
-
-test("confirm coerces headless answer strings", async () => {
-  assert.equal(await confirm({ ...HL, answers: { ok: "yes" } }, { message: "?", key: "ok" }), true);
-  assert.equal(await confirm({ ...HL, answers: { ok: false } }, { message: "?", key: "ok" }), false);
-  assert.equal(await confirm(HL, { message: "?", key: "x", default: true }), true);
-});
-
-test("select matches by value or label, falls back to first/default", async () => {
-  const choices = [{ label: "Sonnet", value: "sonnet" }, { label: "Haiku", value: "haiku" }];
-  assert.equal(await select({ ...HL, answers: { m: "haiku" } }, { message: "?", key: "m", choices }), "haiku");
-  assert.equal(await select({ ...HL, answers: { m: "Sonnet" } }, { message: "?", key: "m", choices }), "sonnet");
-  assert.equal(await select(HL, { message: "?", key: "m", choices, default: "haiku" }), "haiku");
-  assert.equal(await select(HL, { message: "?", key: "m", choices }), "sonnet"); // first
-});
-
-test("multiselect returns matched values, ignoring unknowns", async () => {
-  const choices = [{ label: "Slack", value: "slack" }, { label: "Email", value: "email" }, { label: "SMS", value: "sms" }];
-  const v = await multiselect({ ...HL, answers: { ch: ["slack", "sms", "nope"] } }, { message: "?", key: "ch", choices });
-  assert.deepEqual(v, ["slack", "sms"]);
-});
-
-test("multiselect default applies when answer absent", async () => {
-  const choices = ["a", "b", "c"];
-  const v = await multiselect(HL, { message: "?", key: "ch", choices, default: ["b"] });
-  assert.deepEqual(v, ["b"]);
-});
-
-test("secret returns pre-supplied answer headless, never echoing", async () => {
-  const v = await secret({ ...HL, answers: { token: "xapp-123" } }, { message: "Token", key: "token" });
-  assert.equal(v, "xapp-123");
-});

package/lib/setup/runner.test.mjs

@@ -1,132 +0,0 @@
-/**
- * runner.test.mjs — section ordering, flag parsing, skip-complete, dry-run.
- * Uses injected fake sections so it stays fast + deterministic.
- * Run: `node --test lib/setup/runner.test.mjs`
- * @module lib/setup/runner.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, existsSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { parseFlags, loadSections, runSetup } from "./runner.mjs";
-import { loadProgress, progressPath } from "./state.mjs";
-
-function tmpRoot() { return mkdtempSync(join(tmpdir(), "maestro-runner-")); }
-
-test("parseFlags parses --only, --from, --headless, --dry-run", () => {
-  const a = parseFlags(["--only", "identity,company", "--headless"]);
-  assert.deepEqual(a.flags.only, ["identity", "company"]);
-  assert.equal(a.flags.headless, true);
-  const b = parseFlags(["company", "--from", "model", "--dry-run", "--no-enrich"]);
-  assert.equal(b.section, "company");
-  assert.equal(b.flags.from, "model");
-  assert.equal(b.flags.dryRun, true);
-  assert.equal(b.flags.noEnrich, true);
-});
-
-test("loadSections discovers the real sections sorted by order", async () => {
-  const sections = await loadSections();
-  const ids = sections.map((s) => s.id);
-  // core WS1 sections present and ordered
-  assert.ok(ids.includes("identity"));
-  assert.ok(ids.includes("operating-model"));
-  assert.ok(ids.includes("verify"));
-  const orders = sections.map((s) => s.order);
-  assert.deepEqual(orders, [...orders].sort((x, y) => x - y), "sections sorted by order");
-  // identity precedes operating-model precedes verify
-  assert.ok(ids.indexOf("identity") < ids.indexOf("operating-model"));
-  assert.ok(ids.indexOf("operating-model") < ids.indexOf("verify"));
-});
-
-function fakeSection(id, order, opts = {}) {
-  return {
-    id, order,
-    label: id,
-    applied: 0,
-    async detect() { return { status: opts.complete ? "complete" : "unconfigured" }; },
-    async prompt(ctx) { ctx[`prompted_${id}`] = true; },
-    async apply(ctx) { ctx[`applied_${id}`] = (ctx[`applied_${id}`] || 0) + 1; },
-    async verify() { return { ok: opts.verifyOk !== false, checks: [{ name: id, ok: opts.verifyOk !== false }] }; },
-  };
-}
-
-test("runSetup runs sections in order and records checkpoint", async () => {
-  const root = tmpRoot();
-  const order = [];
-  const mk = (id, o) => ({
-    id, order: o, label: id,
-    async detect() { return { status: "unconfigured" }; },
-    async prompt() {},
-    async apply() { order.push(id); },
-    async verify() { return { ok: true, checks: [] }; },
-  });
-  const sections = [mk("b", 20), mk("a", 10), mk("c", 30)];
-  const res = await runSetup({ agentRoot: root, sections, flags: baseFlags() });
-  assert.deepEqual(order, ["a", "b", "c"], "executed in ascending order");
-  assert.deepEqual(res.ran, ["a", "b", "c"]);
-  const p = loadProgress(root);
-  assert.equal(p.sections.a.status, "complete");
-});
-
-test("runSetup skips already-complete sections (resume default)", async () => {
-  const root = tmpRoot();
-  const applied = [];
-  const mk = (id, o, complete) => ({
-    id, order: o, label: id,
-    async detect() { return { status: complete ? "complete" : "unconfigured" }; },
-    async prompt() {},
-    async apply() { applied.push(id); },
-    async verify() { return { ok: true, checks: [] }; },
-  });
-  const sections = [mk("a", 10, true), mk("b", 20, false)];
-  const res = await runSetup({ agentRoot: root, sections, flags: baseFlags() });
-  assert.deepEqual(applied, ["b"], "complete section a was skipped");
-  assert.ok(res.skipped.includes("a"));
-});
-
-test("runSetup --dry-run writes nothing", async () => {
-  const root = tmpRoot();
-  const sections = [fakeSection("x", 10), fakeSection("y", 20)];
-  const res = await runSetup({ agentRoot: root, sections, flags: { ...baseFlags(), dryRun: true } });
-  assert.equal(existsSync(progressPath(root)), false, "no progress.json on dry-run");
-  // nothing under the temp root was created
-  assert.equal(readdirSync(root).length, 0, "dry-run created no files");
-  assert.deepEqual(res.ran, ["x", "y"]);
-});
-
-test("runSetup --only restricts and forces the named sections", async () => {
-  const root = tmpRoot();
-  const applied = [];
-  const mk = (id, o) => ({
-    id, order: o, label: id,
-    async detect() { return { status: "complete" }; }, // would normally skip
-    async prompt() {},
-    async apply() { applied.push(id); },
-    async verify() { return { ok: true, checks: [] }; },
-  });
-  const sections = [mk("a", 10), mk("b", 20), mk("c", 30)];
-  await runSetup({ agentRoot: root, sections, flags: { ...baseFlags(), only: ["b"] } });
-  assert.deepEqual(applied, ["b"], "only b runs, and forced despite complete detect");
-});
-
-test("runSetup --status returns without applying", async () => {
-  const root = tmpRoot();
-  const applied = [];
-  const sections = [{
-    id: "a", order: 10, label: "a",
-    async detect() { return { status: "partial", summary: "x" }; },
-    async prompt() {}, async apply() { applied.push("a"); },
-    async verify() { return { ok: true, checks: [] }; },
-  }];
-  const res = await runSetup({ agentRoot: root, sections, flags: { ...baseFlags(), status: true } });
-  assert.equal(res.status, true);
-  assert.deepEqual(applied, [], "status mode applies nothing");
-});
-
-function baseFlags() {
-  return { resume: false, from: null, only: null, status: false, headless: true, answersFile: null, noEnrich: false, dryRun: false, verbose: false, help: false };
-}