@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/autonomy.test.mjs

@@ -1,66 +0,0 @@
-/**
- * autonomy.test.mjs — tests for the archetype-derived action-classification.
- * Run: `node --test lib/autonomy.test.mjs`
- * @module autonomy.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveArchetype } from "./archetype.mjs";
-import { buildActionClassification } from "./autonomy.mjs";
-
-test("action_levels bands come straight from the resolved profile", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const p = buildActionClassification(profile);
-  assert.deepEqual(p.action_levels.execute_autonomous.examples, profile.autonomy.green);
-  assert.deepEqual(p.action_levels.approval_preferred.examples, profile.autonomy.amber);
-  assert.deepEqual(p.action_levels.escalate.examples, profile.autonomy.red);
-  assert.ok(p.decision_rights.length >= 1 && p.decision_rights[0].authority);
-  assert.deepEqual(p.action_levels.escalate.escalate_to, profile.escalation.to);
-});
-
-test("per-action map is in the shape the voice gate reads (risk + verbal_confirm + approval)", async () => {
-  const p = buildActionClassification(await resolveArchetype({ function: "commercial-leader", altitude: "vp" }));
-  assert.ok(p.actions.send_email && typeof p.actions.send_email.risk === "string");
-  assert.equal(typeof p.actions.send_email.verbal_confirm, "boolean");
-  assert.ok(["explicit", "preferred", "autonomous"].includes(p.actions.send_email.approval));
-  // high-risk actions demand a verbal confirm
-  for (const a of Object.values(p.actions)) if (a.risk === "high") assert.equal(a.verbal_confirm, true);
-});
-
-test("breadth tunes the gate: founder (broad) is more autonomous than senior-manager (narrow)", async () => {
-  const founder = buildActionClassification(await resolveArchetype({ function: "technical-leader", altitude: "founder" }));
-  const srMgr = buildActionClassification(await resolveArchetype({ function: "technical-leader", altitude: "senior-manager" }));
-  // a routine send: broad → low/autonomous; narrow → high/gated
-  assert.equal(founder.actions.send_slack_message.risk, "low");
-  assert.equal(srMgr.actions.send_slack_message.risk, "high");
-  assert.equal(srMgr.actions.send_email.risk, "high");
-  assert.notEqual(founder.delegation_breadth, srMgr.delegation_breadth);
-});
-
-test("buildActionClassification requires a profile", () => {
-  assert.throws(() => buildActionClassification(null), /requires/);
-});
-
-test("org autonomyLevel/escalationPath (identity.orgProfile) override the archetype default", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const identity = { orgProfile: { autonomyLevel: "supervised", escalationPath: "CTO then CEO" } };
-  const p = buildActionClassification(profile, identity);
-  assert.equal(p.autonomy_default, "supervised", "org autonomyLevel wins over archetype default");
-  assert.equal(p.org_autonomy_level, "supervised");
-  assert.deepEqual(p.action_levels.escalate.escalate_to, ["CTO then CEO"], "org escalationPath wins");
-  assert.equal(p.action_levels.escalate.escalation_path, "CTO then CEO");
-});
-
-test("absent org fields → classification is unchanged (existing behaviour preserved)", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const without = buildActionClassification(profile, {});
-  const baseline = buildActionClassification(profile); // no identity at all
-  assert.equal(without.autonomy_default, profile.autonomy.default || "draft");
-  assert.equal(without.org_autonomy_level, undefined);
-  assert.deepEqual(without.action_levels.escalate.escalate_to, profile.escalation.to);
-  assert.equal(without.action_levels.escalate.escalation_path, undefined);
-  assert.deepEqual(without, baseline);
-});

package/lib/backlog.test.mjs

@@ -1,302 +0,0 @@
-/**
- * backlog.test.mjs — tests for the WBS backlog skeleton builder + materialiser.
- * Run: `node --test lib/backlog.test.mjs`
- * @module backlog.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveArchetype } from "./archetype.mjs";
-import { buildBacklogSkeleton, materializeReadyTasks, toQueueFile, countReadyTasks, parseQueueItems, orgContextStreams, PHASES } from "./backlog.mjs";
-
-const IDENTITY = { firstName: "Jacob", fullName: "Jacob Chen", title: "VP, Engineering", company: "Acme" };
-
-/** A representative cached org context (config/org-context.json shape). */
-const ORG_CONTEXT = {
-  fetchedAt: "2026-07-01T00:00:00.000Z",
-  strategy: {
-    northStar: "Become the default operating system for AI-run companies",
-    streams: [
-      { code: "GTM", name: "Go-to-market", mission: "Land 20 design partners by Q4" },
-      { code: "PLATFORM", name: "Platform reliability", mission: "99.95% control-plane uptime" },
-    ],
-  },
-  board: [
-    { title: "Draft the design-partner outreach sequence" },
-    { title: "Instrument /v1 dispatcher latency SLOs" },
-  ],
-};
-
-test("buildBacklogSkeleton mirrors the profile's streams with a 30/60/90 scaffold", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const wbs = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01" });
-  assert.equal(wbs.streams.length, profile.backlogStreams.length);
-  assert.equal(wbs.granularity, profile.backlogGranularity);
-  for (const s of wbs.streams) {
-    assert.deepEqual(s.phases.map((p) => p.id), PHASES.map((p) => p.id));
-    assert.ok(s.phases.every((p) => p.epics.length >= 1 && p.epics[0].tasks.length >= 1));
-  }
-});
-
-test("countReadyTasks ≥ stream count (≥5 satisfies the init acceptance gate)", async () => {
-  for (const fn of ["technical-leader", "commercial-leader", "compliance-officer", "product-leader", "operations-leader", "executive-operator"]) {
-    const profile = await resolveArchetype({ function: fn, altitude: "vp" });
-    const wbs = buildBacklogSkeleton(profile, IDENTITY);
-    assert.ok(countReadyTasks(wbs) >= 5, `${fn}: expected ≥5 ready tasks, got ${countReadyTasks(wbs)}`);
-  }
-});
-
-test("materializeReadyTasks emits backlog-executor-shaped queue items + priorities", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const wbs = buildBacklogSkeleton(profile, IDENTITY);
-  const { queueItems, priorities } = materializeReadyTasks(wbs, { owner: "jacob", date: "2026-06-01" });
-
-  assert.ok(queueItems.length >= 5);
-  for (const it of queueItems) {
-    assert.ok(it.id && it.title && it.next_action, "item needs id/title/next_action");
-    assert.equal(it.status, "open");
-    assert.equal(it.source, "backlog-seed");
-    assert.equal(it.owner, "jacob");
-    assert.ok(["critical", "high", "normal", "low"].includes(it.priority));
-    assert.ok(Array.isArray(it.history));
-  }
-  // one priority per stream
-  assert.equal(priorities.length, profile.backlogStreams.length);
-  assert.ok(priorities.every((p) => p.status === "active" && Array.isArray(p.streams)));
-});
-
-test("toQueueFile wraps items in the state/queues/*.yaml shape", () => {
-  const file = toQueueFile([{ id: "x" }], { queue: "backlog" });
-  assert.equal(file.queue, "backlog");
-  assert.ok(typeof file.description === "string");
-  assert.deepEqual(file.items, [{ id: "x" }]);
-});
-
-test("materializeReadyTasks rejects an invalid wbs", () => {
-  assert.throws(() => materializeReadyTasks({}), /invalid wbs/);
-});
-
-// ── parseQueueItems (F2: sweepBacklog must extract the item id) ──────────────
-// The daemon's sweepBacklog used an inline regex that pulled title/priority/
-// next_action but NEVER id — so qi.id was always undefined, and the whole
-// file-based item-claim subsystem (hasActiveClaim / claimItem / markItemBlocked)
-// silently no-op'd in production. parseQueueItems is the extracted, tested parser
-// that fixes this: it MUST surface id so claims can engage.
-
-const QUEUE_YAML = `queue_name: backlog
-description: Proactive backlog seeded at init from the archetype WBS.
-items:
-  - id: "seed-eng-d30-t1"
-    title: "Assess the engineering baseline"
-    status: open
-    priority: high
-    next_action: "Identify the top 3 risks and define success metrics."
-  - id: "seed-eng-d30-t2"
-    title: "Ship the first milestone"
-    status: in_progress
-    priority: normal
-    next_action: "Drive the highest-priority initiative to a shippable milestone."
-  - id: "seed-eng-d30-t3"
-    title: "Codify the process"
-    status: blocked
-    priority: normal
-    next_action: "This one is blocked and must be skipped."
-`;
-
-test("parseQueueItems extracts the id for actionable items (regression: F2 — was always undefined)", () => {
-  const items = parseQueueItems(QUEUE_YAML, "backlog.yaml");
-  // Two open/in_progress items, one blocked → blocked must be excluded.
-  assert.equal(items.length, 2, "blocked item must be skipped, open + in_progress kept");
-  const byTitle = Object.fromEntries(items.map((i) => [i.title, i]));
-
-  // THE bug: id was never parsed, so claims never engaged. Assert it is now real.
-  assert.equal(byTitle["Assess the engineering baseline"].id, "seed-eng-d30-t1");
-  assert.equal(byTitle["Ship the first milestone"].id, "seed-eng-d30-t2");
-  for (const it of items) {
-    assert.ok(it.id, `every swept item must carry an id so claimItem()/hasActiveClaim() can engage (got ${JSON.stringify(it)})`);
-    assert.equal(it.source_file, "backlog.yaml");
-  }
-
-  // The fields sweepBacklog already relied on must still be present.
-  const first = byTitle["Assess the engineering baseline"];
-  assert.equal(first.priority, "high");
-  assert.match(first.next_action, /top 3 risks/);
-  assert.equal(first.status, "open");
-});
-
-test("parseQueueItems round-trips a materialized seed item with its real id, so the claim key is stable", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const wbs = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01" });
-  const { queueItems } = materializeReadyTasks(wbs, { owner: "jacob", date: "2026-06-01" });
-  const file = toQueueFile(queueItems, { queue: "backlog" });
-
-  // Serialize exactly the fields sweepBacklog parses (id/title/status/priority/next_action).
-  const yaml = "queue_name: backlog\nitems:\n" + file.items.map((it) =>
-    `  - id: "${it.id}"\n    title: "${it.title}"\n    status: ${it.status}\n    priority: ${it.priority}\n    next_action: "${it.next_action}"\n`
-  ).join("");
-
-  const parsed = parseQueueItems(yaml, "backlog.yaml");
-  assert.ok(parsed.length >= 1);
-  // The parsed id must equal the materialized id (the seed- prefix is the claim key).
-  const ids = new Set(parsed.map((p) => p.id));
-  for (const it of file.items) {
-    assert.ok(ids.has(it.id), `parser dropped the id ${it.id} that claimItem() needs`);
-  }
-});
-
-test("parseQueueItems ignores commented schema-template lines", () => {
-  const yaml = `items:
-  # id: string
-  # title: string
-  - id: "real-1"
-    title: "Real item"
-    status: open
-    priority: normal
-    next_action: "do the thing"
-`;
-  const items = parseQueueItems(yaml, "tmpl.yaml");
-  assert.equal(items.length, 1);
-  assert.equal(items[0].id, "real-1");
-  assert.equal(items[0].title, "Real item");
-});
-
-test("parseQueueItems tolerates a missing id (does not throw, simply omits id)", () => {
-  const yaml = `items:
-  - title: "Legacy item with no id"
-    status: open
-    priority: normal
-    next_action: "still actionable"
-`;
-  const items = parseQueueItems(yaml, "legacy.yaml");
-  assert.equal(items.length, 1);
-  assert.equal(items[0].id, undefined);
-  assert.equal(items[0].title, "Legacy item with no id");
-});
-
-test("parseQueueItems: a key that is a SUFFIX of the real key is not mis-read as id (0.8)", () => {
-  // correlation_id:/message_id: must NOT be extracted as `id:` (confirmed bug).
-  const yaml = [
-    "items:",
-    '  - correlation_id: "WRONG-1"',
-    '    message_id: "ALSO-WRONG"',
-    '    id: "RIGHT-1"',
-    '    title: "Reconcile"',
-    "    status: open",
-    '    next_action: "do it"',
-  ].join("\n") + "\n";
-  const items = parseQueueItems(yaml, "q.yaml");
-  assert.equal(items.length, 1);
-  assert.equal(items[0].id, "RIGHT-1", "id must be the real id key, not a suffix match");
-});
-
-test("parseQueueItems: indented js-yaml sequence yields each item with its id (0.8)", () => {
-  const yaml = [
-    "items:",
-    '  - id: "a1"',
-    "    status: open",
-    '    title: "First"',
-    '    next_action: "go"',
-    '  - id: "b2"',
-    "    status: open",
-    '    title: "Second"',
-    '    next_action: "go"',
-  ].join("\n") + "\n";
-  const items = parseQueueItems(yaml, "q.yaml");
-  assert.equal(items.length, 2, "both indented items parsed (not folded into one)");
-  assert.deepEqual(items.map((i) => i.id), ["a1", "b2"]);
-});
-
-// --- org context shapes the backlog (closes the audit gap) -----------------
-
-test("orgContextStreams: null/empty context → [] (standalone agent unchanged)", () => {
-  assert.deepEqual(orgContextStreams(null), []);
-  assert.deepEqual(orgContextStreams({}), []);
-  assert.deepEqual(orgContextStreams({ strategy: {}, board: [] }), []);
-});
-
-test("orgContextStreams: one stream per org strategy stream + a ready-board frontier stream", () => {
-  const streams = orgContextStreams(ORG_CONTEXT);
-  // 2 strategy streams + 1 frontier stream
-  assert.equal(streams.length, 3);
-  assert.deepEqual(streams.map((s) => s.id), ["org-gtm", "org-platform", "org-frontier"]);
-  // strategy stream intent carries the org mission (authoritative work, not generic)
-  assert.equal(streams[0].source, "org-strategy");
-  assert.equal(streams[0].intent, "Land 20 design partners by Q4");
-  // strategy streams seed a full 30/60/90 scaffold
-  assert.deepEqual(streams[0].phases.map((p) => p.id), PHASES.map((p) => p.id));
-  // the frontier stream turns each ready-board item into a concrete high-priority d30 task
-  const frontier = streams[2];
-  assert.equal(frontier.source, "org-board");
-  const d30 = frontier.phases.find((p) => p.id === "d30");
-  assert.equal(d30.epics[0].tasks.length, 2);
-  assert.equal(d30.epics[0].tasks[0].title, "Draft the design-partner outreach sequence");
-  assert.equal(d30.epics[0].tasks[0].priority, "high");
-});
-
-test("orgContextStreams: north star fills a stream missing its own mission", () => {
-  const streams = orgContextStreams({ strategy: { northStar: "Win", streams: [{ code: "X", name: "Xeno" }] } });
-  assert.match(streams[0].intent, /Advance the org north star — Win/);
-});
-
-test("buildBacklogSkeleton: orgContext makes the org strategy + ready board LEAD the backlog", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const base = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01" });
-  const shaped = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01", orgContext: ORG_CONTEXT });
-
-  // org streams are additive and lead
-  assert.equal(shaped.streams.length, base.streams.length + 3);
-  assert.deepEqual(shaped.streams.slice(0, 3).map((s) => s.id), ["org-gtm", "org-platform", "org-frontier"]);
-  assert.equal(shaped.orgContextApplied, true);
-  assert.equal(base.orgContextApplied, undefined, "standalone skeleton carries no org flag");
-
-  // the org work materialises into real queue items + priorities the executor picks up
-  const { queueItems, priorities } = materializeReadyTasks(shaped, { owner: "jacob", date: "2026-06-01" });
-  const titles = queueItems.map((q) => q.title);
-  assert.ok(titles.includes("Draft the design-partner outreach sequence"), "ready-board item became a seeded task");
-  assert.ok(priorities.some((p) => p.id === "org-gtm" && p.title === "Go-to-market"), "org strategy stream became a strategic priority");
-});
-
-test("buildBacklogSkeleton: standalone (no orgContext) is byte-for-byte the archetype skeleton", async () => {
-  const profile = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const a = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01" });
-  const b = buildBacklogSkeleton(profile, IDENTITY, { date: "2026-06-01", orgContext: null });
-  assert.deepEqual(a, b);
-});
-
-test("REGRESSION — parseQueueItems reads back the `rung` the goal steward wrote", () => {
-  // `lib/goals/loop.renderQueueItems` writes rung: on every self-directed item.
-  // Nothing read it back, so the daemon's sweep dispatched a rung-0 single-method
-  // call and a rung-5 subagent fan-out as the identical plain session: the
-  // router's whole cost/blast-radius decision died on disk.
-  const yaml = [
-    "queue: goals",
-    "items:",
-    "  - id: goal-x-2026-W33-1",
-    '    title: "Close the on_time_rate gap"',
-    "    status: open",
-    "    priority: normal",
-    '    next_action: "Close the on_time_rate gap"',
-    "    source: goal-steward",
-    "    advances: [board-on-time-delivery]",
-    "    expected_delta: 10",
-    "    obligation_key: outcome.board-on-time-delivery",
-    "    disposition: SELF",
-    "    rung: 3",
-    "    created: 2026-08-11",
-  ].join("\n");
-  const [item] = parseQueueItems(yaml, "goals.yaml");
-  assert.equal(item.rung, 3);
-  assert.equal(item.source, "goal-steward");
-  assert.equal(item.disposition, "SELF");
-  assert.deepEqual(item.advances, ["board-on-time-delivery"]);
-  assert.equal(item.expected_delta, 10);
-  assert.equal(item.obligation_key, "outcome.board-on-time-delivery");
-});
-
-test("a hand-written item with no rung is unchanged (rung stays absent, not 0)", () => {
-  const yaml = ['items:', '  - id: seeded-1', '    title: "Tidy docs"', "    status: open", '    next_action: "tidy"'].join("\n");
-  const [item] = parseQueueItems(yaml, "backlog.yaml");
-  assert.equal("rung" in item, false, "absence must not become rung 0 — that is the cheapest rung");
-});

package/lib/backup/policy.test.mjs

@@ -1,305 +0,0 @@
-/**
- * policy.test.mjs — coverage for lib/backup/policy.mjs.
- *
- * The load-bearing cases are the two that a silent bug would make invisible:
- *   1. the hard deny-list actually drops `.env` / `.cohort-key.json` even when
- *      the config asks for them (credential exfiltration via backup), and
- *   2. the severity ladder distinguishes "no restore point at all" (fail) from
- *      "restore points that would not survive a house fire" (warn).
- *
- * Hermetic: tmp agent roots, injected env/home. No tar, no network, no launchd.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  DEFAULT_INCLUDE,
-  DENY_PATTERNS,
-  backupVerdict,
-  defaultConfigYaml,
-  defaultLocalRoot,
-  denyMatch,
-  parseBackupConfig,
-  resolveBackupPlan,
-  sanitisePrefix,
-  tarExcludeArgs,
-  scanTextForSecrets,
-  scanIncludesForSecrets,
-} from "./policy.mjs";
-
-function makeAgent(configBody) {
-  const root = mkdtempSync(join(tmpdir(), "bkpol-"));
-  mkdirSync(join(root, ".maestro"), { recursive: true });
-  if (configBody !== undefined) {
-    writeFileSync(join(root, ".maestro", "backup-config.yaml"), configBody);
-  }
-  return root;
-}
-const cleanup = (root) => rmSync(root, { recursive: true, force: true });
-
-// ── deny-list ──────────────────────────────────────────────────────────────
-
-test("deny-list rejects live credentials by exact name and by glob", () => {
-  assert.equal(denyMatch(".env"), ".env");
-  assert.equal(denyMatch(".env.local"), ".env.*");
-  assert.equal(denyMatch(".cohort-key.json"), ".cohort-key.json");
-  assert.equal(denyMatch(".claude/.credentials.json"), ".claude/.credentials.json");
-  assert.ok(denyMatch("config/tls/server.pem"));
-  assert.ok(denyMatch("secrets/id_rsa"));
-});
-
-test("deny-list applies to nested segments (node_modules at any depth)", () => {
-  assert.equal(denyMatch("node_modules"), "node_modules");
-  assert.equal(denyMatch("plugins/x/node_modules/y"), "node_modules");
-  assert.equal(denyMatch("state/rag/index/vectors.bin"), "state/rag/index");
-});
-
-test("deny-list leaves the durable state we DO want alone", () => {
-  for (const p of ["state", "state/queues/action-stack.yaml", "knowledge", "memory", "outputs", "config/agent.json", ".maestro/last-backup.json"]) {
-    assert.equal(denyMatch(p), null, `${p} must be backupable`);
-  }
-});
-
-test("a config that asks for .env gets it DROPPED and reported, not obeyed", () => {
-  const root = makeAgent(`enabled: true
-prefix: test
-include:
-  - state
-  - .env
-  - .cohort-key.json
-  - ../../etc
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, env: { MAESTRO_BACKUP_DIR: "/tmp/b" } });
-  cleanup(root);
-  assert.deepEqual(plan.include, ["state"]);
-  const denied = plan.violations.map((v) => v.path).sort();
-  assert.deepEqual(denied, ["../../etc", ".cohort-key.json", ".env"]);
-  assert.ok(plan.violations.some((v) => v.pattern === "outside-agent-root"));
-});
-
-test("tar exclude args always carry the hard deny-list first", () => {
-  const args = tarExcludeArgs({ exclude: ["outputs/scratch"] });
-  assert.ok(args.includes("--exclude=.env"));
-  assert.ok(args.includes("--exclude=.cohort-key.json"));
-  assert.ok(args.includes("--exclude=node_modules"));
-  assert.ok(args.includes("--exclude=*/node_modules"));
-  assert.ok(args.includes("--exclude=outputs/scratch"));
-  assert.ok(args.indexOf("--exclude=.env") < args.indexOf("--exclude=outputs/scratch"));
-});
-
-test("every deny pattern is non-empty and lowercase-stable", () => {
-  for (const p of DENY_PATTERNS) assert.ok(typeof p === "string" && p.length > 0);
-});
-
-// ── config parsing / plan resolution ───────────────────────────────────────
-
-test("missing config → tier none, nothing enabled", () => {
-  const root = makeAgent();
-  const plan = resolveBackupPlan({ agentRoot: root });
-  cleanup(root);
-  assert.equal(plan.present, false);
-  assert.equal(plan.tier, "none");
-  assert.equal(plan.enabled, false);
-});
-
-test("malformed YAML → present but unreadable (a DIFFERENT problem from absent)", () => {
-  const root = makeAgent("enabled: true\n  : : broken\n\t- x");
-  const plan = resolveBackupPlan({ agentRoot: root });
-  cleanup(root);
-  assert.equal(plan.present, true);
-  assert.equal(plan.readable, false);
-  assert.equal(plan.tier, "unreadable");
-});
-
-test("the shipped default config resolves to the LOCAL tier with no credentials", () => {
-  const root = makeAgent(defaultConfigYaml({ prefix: "astra-ai" }));
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  assert.equal(plan.enabled, true);
-  assert.equal(plan.tier, "local");
-  assert.equal(plan.prefix, "astra-ai");
-  assert.equal(plan.local.enabled, true);
-  assert.equal(plan.offsite.configured, false);
-  assert.deepEqual(plan.include, [...DEFAULT_INCLUDE]);
-  assert.deepEqual(plan.violations, []);
-  assert.ok(plan.local.dir.endsWith("/Maestro/backups/astra-ai"));
-});
-
-test("offsite provider + bucket promotes the tier to offsite", () => {
-  const root = makeAgent(`enabled: true
-prefix: astra-ai
-offsite:
-  provider: s3
-  bucket: acme-agent-backups
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  assert.equal(plan.tier, "offsite");
-  assert.equal(plan.offsite.provider, "s3");
-  assert.equal(plan.offsite.bucket, "acme-agent-backups");
-});
-
-test("an unknown offsite provider does not count as configured", () => {
-  const root = makeAgent(`enabled: true
-offsite:
-  provider: dropbox
-  bucket: nope
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  assert.equal(plan.offsite.configured, false);
-  assert.equal(plan.tier, "local");
-});
-
-test("enabled:false → tier disabled even with a full config", () => {
-  const root = makeAgent(`enabled: false
-offsite:
-  provider: gcs
-  bucket: b
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  assert.equal(plan.tier, "disabled");
-});
-
-test("MAESTRO_BACKUP_DIR overrides the local root", () => {
-  assert.equal(defaultLocalRoot({ env: { MAESTRO_BACKUP_DIR: "/mnt/dr" } }), "/mnt/dr");
-  assert.equal(
-    defaultLocalRoot({ env: {}, home: "/Users/x" }),
-    "/Users/x/Library/Application Support/Maestro/backups"
-  );
-});
-
-test("parseBackupConfig never throws and rejects non-objects", () => {
-  assert.equal(parseBackupConfig(""), null);
-  assert.equal(parseBackupConfig("- a\n- b"), null);
-  assert.equal(parseBackupConfig("just a string"), null);
-  assert.deepEqual(parseBackupConfig("enabled: true"), { enabled: true });
-});
-
-test("prefixes are sanitised into safe archive/bucket keys", () => {
-  assert.equal(sanitisePrefix("Astra AI"), "astra-ai");
-  assert.equal(sanitisePrefix("../../etc/passwd"), "etc-passwd");
-  assert.equal(sanitisePrefix(""), "agent");
-});
-
-// ── severity ladder ────────────────────────────────────────────────────────
-
-const FRESH = { configured: true, lastBackupAt: "2026-08-12T03:10:00Z", ageHours: 6, stale: false };
-
-test("no config → FAIL naming the one command that fixes it", () => {
-  const v = backupVerdict({ present: false }, {});
-  assert.equal(v.level, "fail");
-  assert.match(v.fix, /maestro init backup-replication --apply/);
-});
-
-test("configured + enabled but never run → FAIL (there is no restore point)", () => {
-  const root = makeAgent(defaultConfigYaml({ prefix: "a" }));
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  const v = backupVerdict(plan, { configured: true, lastBackupAt: null, ageHours: null, stale: true });
-  assert.equal(v.level, "fail");
-  assert.match(v.msg, /NEVER completed/);
-});
-
-test("local-only but fresh → WARN that names the residual machine-loss risk", () => {
-  const root = makeAgent(defaultConfigYaml({ prefix: "a" }));
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  const v = backupVerdict(plan, FRESH);
-  assert.equal(v.level, "warn");
-  assert.match(v.msg, /LOCAL-ONLY/);
-  assert.match(v.fix, /offsite\.provider/);
-});
-
-test("offsite + fresh → the only OK", () => {
-  const root = makeAgent(`enabled: true
-prefix: a
-offsite:
-  provider: gcs
-  bucket: agent-backups
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  const v = backupVerdict(plan, FRESH);
-  assert.equal(v.level, "ok");
-  assert.match(v.msg, /gcs:\/\/agent-backups/);
-});
-
-test("stale beats local-only: a stale offsite backup still WARNs", () => {
-  const root = makeAgent(`enabled: true
-offsite:
-  provider: s3
-  bucket: b
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  const v = backupVerdict(plan, { configured: true, lastBackupAt: "2026-08-01T00:00:00Z", ageHours: 200, stale: true });
-  assert.equal(v.level, "warn");
-  assert.match(v.msg, /stale/);
-});
-
-test("an include list that is entirely denied FAILs rather than shipping an empty archive", () => {
-  const root = makeAgent(`enabled: true
-include:
-  - .env
-`);
-  const plan = resolveBackupPlan({ agentRoot: root, home: "/Users/fake" });
-  cleanup(root);
-  const v = backupVerdict(plan, FRESH);
-  assert.equal(v.level, "fail");
-  assert.match(v.msg, /every include path was rejected/);
-});
-
-// ---------------------------------------------------------------------------
-// THE CONTENT DENY-LIST — the hole a path deny-list cannot see
-// ---------------------------------------------------------------------------
-
-test("scanTextForSecrets catches the credential shapes that authenticate AS this agent", () => {
-  // The real leak: state/setup/progress.json carried "orgToken":"nlk_…" — the
-  // byte-identical value of COHORT_API_KEY in .env — inside an included tree,
-  // while the runner logged "archive verified clean".
-  assert.deepEqual(scanTextForSecrets('{"orgToken":"nlk_7bc80020aa11bb22cc33dd44ee55ff66"}'), ["cohort-api-key"]);
-  assert.deepEqual(scanTextForSecrets("sk-ant-api03-AAAAAAAAAAAAAAAAAAAAAAAA"), ["anthropic-key"]);
-  assert.deepEqual(scanTextForSecrets("-----BEGIN OPENSSH PRIVATE KEY-----"), ["private-key-block"]);
-  assert.deepEqual(scanTextForSecrets("ghp_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"), ["github-token"]);
-  // And does not fire on ordinary prose or config.
-  assert.deepEqual(scanTextForSecrets('{"orgAuthMethod":"apikey","orgBase":"https://hq.example"}'), []);
-  assert.deepEqual(scanTextForSecrets("the token lives in .env"), []);
-});
-
-test("scanIncludesForSecrets finds a credential INSIDE an included file", () => {
-  const root = mkdtempSync(join(tmpdir(), "backup-content-"));
-  try {
-    mkdirSync(join(root, "state", "setup"), { recursive: true });
-    mkdirSync(join(root, "knowledge"), { recursive: true });
-    writeFileSync(join(root, "state", "setup", "progress.json"),
-      JSON.stringify({ answers: { orgId: "acme", orgToken: "nlk_7bc80020aa11bb22cc33dd44ee55ff66" } }));
-    writeFileSync(join(root, "state", "notes.md"), "no secrets here");
-    writeFileSync(join(root, "knowledge", "faq.md"), "the api key is in .env");
-
-    const plan = { include: ["state", "knowledge"], exclude: [] };
-    const r = scanIncludesForSecrets(plan, root);
-    assert.deepEqual(r.leaks.map((l) => l.path), ["state/setup/progress.json"]);
-    assert.deepEqual(r.leaks[0].patterns, ["cohort-api-key"]);
-    assert.equal(r.truncated, false);
-    assert.ok(r.scanned >= 3);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});
-
-test("the content scan skips path-denied trees and binary files", () => {
-  const root = mkdtempSync(join(tmpdir(), "backup-content-"));
-  try {
-    // A dependency full of example keys must not cost us the whole DR posture.
-    mkdirSync(join(root, "state", "node_modules", "pkg"), { recursive: true });
-    writeFileSync(join(root, "state", "node_modules", "pkg", "readme.md"), "sk-ant-api03-BBBBBBBBBBBBBBBBBBBBBBBB");
-    writeFileSync(join(root, "state", "blob.bin"), Buffer.from([0x00, 0x01, 0x02, 0x00]));
-    const r = scanIncludesForSecrets({ include: ["state"], exclude: [] }, root);
-    assert.deepEqual(r.leaks, [], "node_modules is already path-denied");
-    assert.equal(r.skippedBinary, 1);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});