@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/lib/kpi-sensors.test.mjs

@@ -1,278 +0,0 @@
-/**
- * lib/kpi-sensors.test.mjs — the sensor registry.
- *
- * The load-bearing tests are the NEGATIVES: a sensor that cannot measure must
- * produce an honest `{ok:false, reason}` that `measureKpi` refuses to turn into
- * a sample, and that `admit`'s honesty gate therefore refuses to turn into work.
- * A silent zero here would let an agent invent its own justification for
- * anything, which is the whole reason the honesty gate exists.
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  SENSOR_SPECS,
-  buildSensorRegistry,
-  reachableCapabilities,
-  refusalFor,
-  hintedCapabilities,
-  reduceGeneric,
-  firstArray,
-  pluck,
-} from "./kpi-sensors.mjs";
-import { measureKpi, recordMeasurement, readSeries } from "./kpi.mjs";
-import { admit } from "./goals/admission.mjs";
-
-const NOW = Date.parse("2026-08-11T12:00:00.000Z");
-const now = () => NOW;
-
-function root() {
-  const d = mkdtempSync(join(tmpdir(), "kpi-sensors-"));
-  mkdirSync(join(d, "config"), { recursive: true });
-  return d;
-}
-
-/** A fake org: capability → error-or-result frame. */
-function fakeExec(table, calls = []) {
-  return async (name, input) => {
-    calls.push({ name, input });
-    const hit = table[name];
-    if (hit === undefined) return { ok: false, error: { code: "NOT_FOUND", message: `no fake for ${name}` } };
-    if (typeof hit === "function") return hit(input);
-    return { ok: true, result: hit };
-  };
-}
-
-const OBJ = (capability, params = {}) => ({
-  key: "k", kind: "GOAL", state: "active", metric: "m", direction: "up",
-  target: 90, tolerance: 2, cadence: "weekly",
-  // `adoptedById` is part of the law the admission gate enforces, not decoration:
-  // an active objective with nobody on record as having adopted it admits no work.
-  memberId: "M-OWNER", adoptedById: "M-SUPERVISOR",
-  sensor: { capability, params, source: "method" },
-});
-
-// ---------------------------------------------------------------------------
-// Reductions
-// ---------------------------------------------------------------------------
-
-test("board_ready measures an on-time rate and shows what it walked", async () => {
-  const calls = [];
-  const sensors = buildSensorRegistry({
-    agentRoot: root(), now,
-    executeImpl: fakeExec({ board_ready: { items: [
-      { id: "a", dueAt: "2026-06-01T00:00:00Z" },   // overdue
-      { id: "b", dueAt: "2026-12-01T00:00:00Z" },   // not yet
-      { id: "c", dueAt: null },                      // cannot be late
-      { id: "d", dueAt: null },
-    ] } }, calls),
-  });
-  const m = await measureKpi(OBJ("board_ready", { metric: "on_time_rate" }), { sensors, now });
-  assert.equal(m.ok, true);
-  assert.equal(m.value, 75);
-  assert.equal(m.source, "method");
-  assert.equal(m.evidence.rowCount, 4);
-  assert.equal(m.evidence.detail.overdue, 1);
-  assert.equal(m.evidence.detail.withDueDate, 2);
-  assert.equal(calls[0].name, "board_ready");
-});
-
-test("decision_list distinguishes an honest zero from an absence", async () => {
-  const sensors = (table) => buildSensorRegistry({ agentRoot: root(), now, executeImpl: fakeExec(table) });
-
-  // Rows exist, none undecided → a REAL zero-day backlog.
-  const zero = await measureKpi(OBJ("decision_list"), {
-    sensors: sensors({ decision_list: { decisions: [{ id: "1", status: "adopted", createdAt: "2026-08-01T00:00:00Z", decidedAt: "2026-08-02T00:00:00Z" }] } }),
-    now,
-  });
-  assert.equal(zero.ok, true);
-  assert.equal(zero.value, 0);
-  assert.match(zero.evidence.detail.note, /honest zero/);
-
-  // No rows at all → NOT a zero.
-  const none = await measureKpi(OBJ("decision_list"), { sensors: sensors({ decision_list: { decisions: [] } }), now });
-  assert.equal(none.ok, false);
-  assert.equal(none.value, null);
-  assert.equal(none.reason, "no-rows");
-});
-
-test("email_inbox pairs a reply to its inbound message and never averages silence in as speed", async () => {
-  const sensors = buildSensorRegistry({
-    agentRoot: root(), now,
-    executeImpl: fakeExec({ email_inbox: { messages: [
-      { id: "1", threadId: "t1", direction: "INBOUND", receivedAt: "2026-08-11T00:00:00Z" },
-      { id: "2", threadId: "t1", direction: "OUTBOUND", sentAt: "2026-08-11T02:00:00Z" },
-      { id: "3", threadId: "t2", direction: "INBOUND", receivedAt: "2026-08-10T00:00:00Z" }, // never answered
-    ] } }),
-  });
-  const m = await measureKpi(OBJ("email_inbox"), { sensors, now });
-  assert.equal(m.ok, true);
-  assert.equal(m.value, 2);                       // 2h, not 1h — the unanswered one is excluded
-  assert.equal(m.evidence.detail.answered, 1);
-  assert.equal(m.evidence.detail.unanswered, 1);
-});
-
-test("crm_list_deals never sends hq an illegal stage filter", async () => {
-  const calls = [];
-  const sensors = buildSensorRegistry({
-    agentRoot: root(), now,
-    executeImpl: fakeExec({ crm_list_deals: { deals: [
-      { id: "1", stage: "INBOUND", valueCents: 100_000_000 },
-      { id: "2", stage: "CLOSED", valueCents: 900_000_000 },
-    ] } }, calls),
-  });
-  // "open" is not in hq's enum — it must not reach the wire.
-  const m = await measureKpi(OBJ("crm_list_deals", { stage: "open" }), { sensors, now });
-  assert.deepEqual(calls[0].input, {});
-  assert.equal(m.value, 1_000_000);               // the CLOSED deal is excluded
-  assert.equal(m.evidence.detail.open, 1);
-});
-
-test("reduceGeneric is the escape hatch: filter an array, sum a field", () => {
-  const r = reduceGeneric(
-    { byAgent: [{ agent: "A016", usd: 4384.87 }, { agent: "A017", usd: 3455.27 }] },
-    { arrayPath: "byAgent", where: { key: "agent", equals: "A016" }, sum: "usd" },
-  );
-  assert.equal(r.value, 4384.87);
-  assert.equal(r.rowCount, 1);
-  assert.equal(pluck({ a: { b: [1, 2] } }, "a.b.1"), 2);
-  assert.equal(firstArray({ x: 1, deals: [1, 2, 3] }).key, "deals");
-});
-
-// ---------------------------------------------------------------------------
-// THE NEGATIVES
-// ---------------------------------------------------------------------------
-
-test("NEGATIVE: an unregistered capability yields no-implementation and NO sample", async () => {
-  const dir = root();
-  const sensors = buildSensorRegistry({ agentRoot: dir, now, executeImpl: fakeExec({}) });
-  const o = OBJ("messaging_send");
-  const m = await measureKpi(o, { sensors, now });
-
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "no-implementation");
-  assert.equal(m.value, null);
-
-  // The loop only records when m.ok — assert the ledger stays empty either way.
-  assert.equal(readSeries(dir, o.key).length, 0);
-});
-
-test("NEGATIVE: a WRITE capability is refused by name, not silently missing", async () => {
-  const sensors = buildSensorRegistry({ agentRoot: root(), now, executeImpl: fakeExec({}) });
-  assert.equal(typeof sensors.task_update, "function", "the derivation can pick it, so it must have an answer");
-  const m = await measureKpi(OBJ("task_update"), { sensors, now });
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "capability-is-not-a-sensor");
-  assert.match(m.evidence.detail.why, /may not mutate the org/);
-  assert.match(refusalFor("escalation_raise"), /may not mutate the org/);
-  assert.match(refusalFor("approval_wait"), /long-poll/);
-  assert.equal(refusalFor("board_ready"), null);
-});
-
-test("NEGATIVE: a failed org read is a read-failure, never a zero", async () => {
-  const dir = root();
-  const sensors = buildSensorRegistry({
-    agentRoot: dir, now,
-    executeImpl: fakeExec({ board_ready: () => ({ ok: false, error: { code: "UNAUTHORIZED", message: "no org credential" } }) }),
-  });
-  const m = await measureKpi(OBJ("board_ready"), { sensors, now });
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "read-failed");
-  assert.equal(m.value, null);
-  assert.equal(m.evidence.detail.code, "UNAUTHORIZED");
-});
-
-test("NEGATIVE: a sensor that throws is caught and reported, not propagated", async () => {
-  const sensors = buildSensorRegistry({
-    agentRoot: root(), now,
-    executeImpl: async () => { throw new Error("socket hang up"); },
-  });
-  const m = await measureKpi(OBJ("board_ready"), { sensors, now });
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "sensor-threw");
-});
-
-test("NEGATIVE: an unmeasurable objective cannot reach the admission honesty gate", async () => {
-  const dir = root();
-  const sensors = buildSensorRegistry({ agentRoot: dir, now, executeImpl: fakeExec({ board_ready: { items: [] } }) });
-  const o = OBJ("board_ready");
-
-  const m = await measureKpi(o, { sensors, now });
-  assert.equal(m.ok, false, "empty board → no measurement");
-
-  // Exactly what the loop does: record ONLY when ok.
-  if (m.ok) recordMeasurement(dir, { objectiveKey: o.key, value: m.value, window: "2026-W33", source: m.source }, { now });
-  const series = readSeries(dir, o.key);
-  assert.equal(series.length, 0);
-
-  const verdict = admit(
-    { title: "do something", advances: [o.key], why: { reason: "kpi-gap" } },
-    { objective: o, gap: { gap: 15, withinTolerance: false, trend: "unknown" }, latestSample: series[series.length - 1] || null, openItems: [], staleness: { outcome: "full" } },
-  );
-  assert.equal(verdict.admitted, false);
-  assert.equal(verdict.gate, "honesty");
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("a MEASURED sample satisfies the honesty gate — the joint, end to end", async () => {
-  const dir = root();
-  const sensors = buildSensorRegistry({
-    agentRoot: dir, now,
-    executeImpl: fakeExec({ board_ready: { items: [{ id: "a", dueAt: "2026-06-01T00:00:00Z" }, { id: "b", dueAt: null }, { id: "c", dueAt: null }, { id: "d", dueAt: null }] } }),
-  });
-  const o = OBJ("board_ready");
-  const m = await measureKpi(o, { sensors, now });
-  assert.equal(m.ok, true);
-  recordMeasurement(dir, { objectiveKey: o.key, value: m.value, window: "2026-W33", source: m.source, evidence: m.evidence }, { now });
-
-  const series = readSeries(dir, o.key);
-  const verdict = admit(
-    { title: "raise the on-time rate", advances: [o.key], why: { reason: "kpi-gap" }, estCents: 50 },
-    { objective: o, gap: { gap: 15, withinTolerance: false, trend: "unknown" }, latestSample: series[series.length - 1], openItems: [], remainingCents: 500, staleness: { outcome: "full" } },
-  );
-  assert.equal(verdict.admitted, true, verdict.reason);
-  assert.equal(series[0].evidence.method, "board_ready");
-  assert.equal(series[0].evidence.rowCount, 4);
-  rmSync(dir, { recursive: true, force: true });
-});
-
-// ---------------------------------------------------------------------------
-// Reachability — the fail-open that must not become fail-closed
-// ---------------------------------------------------------------------------
-
-test("a missing or empty manifest returns undefined, not an empty Set", () => {
-  const dir = root();
-  const logs = [];
-  const log = (l, m) => logs.push(`${l}:${m}`);
-  assert.equal(reachableCapabilities(dir, { log }), undefined);
-  assert.ok(logs.some((l) => /no capability manifest/.test(l)), "the degradation is logged");
-
-  writeFileSync(join(dir, "config", "capability-manifest.json"), JSON.stringify({ entries: [] }));
-  assert.equal(reachableCapabilities(dir, { log }), undefined, "zero reachable entries must not refuse every objective");
-
-  writeFileSync(join(dir, "config", "capability-manifest.json"), "{not json");
-  assert.equal(reachableCapabilities(dir, { log }), undefined);
-
-  writeFileSync(join(dir, "config", "capability-manifest.json"), JSON.stringify({ entries: [{ id: "board_ready", reachable: true }, { id: "task_update", reachable: false }] }));
-  const set = reachableCapabilities(dir, { log });
-  assert.ok(set.has("board_ready"));
-  assert.ok(!set.has("task_update"));
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("every capability the mandate derivation can bind has an answer in the registry", () => {
-  const sensors = buildSensorRegistry({ agentRoot: root(), now, executeImpl: fakeExec({}) });
-  for (const cap of hintedCapabilities()) {
-    assert.equal(typeof sensors[cap], "function", `${cap} is hinted by derive.SENSOR_HINTS but has no registry entry`);
-  }
-  // …and every spec is a READ.
-  for (const cap of Object.keys(SENSOR_SPECS)) {
-    assert.equal(refusalFor(cap), null, `${cap} has a spec so it must not be refused`);
-  }
-});

package/lib/kpi.test.mjs

@@ -1,244 +0,0 @@
-/**
- * kpi.test.mjs — measurement, the series, and the gap.
- * Run: `node --test lib/kpi.test.mjs`
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  windowFor,
-  isoWeek,
-  isDue,
-  readSeries,
-  recordMeasurement,
-  recordIntervention,
-  readInterventions,
-  measureKpi,
-  gapFor,
-  periodSeconds,
-} from "./kpi.mjs";
-
-function root() {
-  return mkdtempSync(join(tmpdir(), "kpi-test-"));
-}
-function cleanup(p) {
-  try { rmSync(p, { recursive: true, force: true }); } catch { /* */ }
-}
-
-const T = Date.parse("2026-08-11T09:00:00Z"); // a Tuesday, ISO week 33
-const now = () => T;
-
-const OBJ = {
-  key: "pipeline",
-  metric: "pipeline_coverage_x",
-  target: 3,
-  tolerance: 0.2,
-  direction: "up",
-  cadence: "weekly",
-  sensor: { capability: "crm_list_deals", params: { stage: "open" }, source: "method" },
-};
-
-// ---------------------------------------------------------------------------
-// windows
-// ---------------------------------------------------------------------------
-
-test("windowFor produces the right idempotency key per cadence", () => {
-  assert.equal(windowFor("weekly", T), "2026-W33");
-  assert.equal(windowFor("monthly", T), "2026-08");
-  assert.equal(windowFor("quarterly", T), "2026-Q3");
-  assert.equal(windowFor("daily", T), "2026-08-11");
-  assert.equal(isoWeek(new Date(T)).week, 33);
-});
-
-test("periodSeconds covers every cadence and defaults to a day", () => {
-  assert.equal(periodSeconds("weekly"), 604800);
-  assert.equal(periodSeconds("monthly"), 2592000);
-  assert.equal(periodSeconds("nonsense"), 86400);
-});
-
-// ---------------------------------------------------------------------------
-// the ledger
-// ---------------------------------------------------------------------------
-
-test("recordMeasurement is idempotent on (objective, window) and refuses a weaker duplicate", () => {
-  const r = root();
-  try {
-    const a = recordMeasurement(r, { objectiveKey: "pipeline", value: 2.1, window: "2026-W33", source: "method" }, { now });
-    assert.equal(a.recorded, true);
-
-    const dup = recordMeasurement(r, { objectiveKey: "pipeline", value: 9.9, window: "2026-W33", source: "llm" }, { now });
-    assert.equal(dup.recorded, false);
-    assert.equal(dup.reason, "duplicate-window");
-    assert.equal(readSeries(r, "pipeline")[0].value, 2.1, "the llm guess must not overwrite the measured number");
-
-    // A STRONGER source may supersede a weaker one in the same window.
-    const r2 = root();
-    try {
-      recordMeasurement(r2, { objectiveKey: "p", value: 1, window: "w", source: "llm" }, { now });
-      const better = recordMeasurement(r2, { objectiveKey: "p", value: 5, window: "w", source: "method" }, { now });
-      assert.equal(better.recorded, true);
-      assert.equal(readSeries(r2, "p")[0].value, 5);
-      assert.equal(readSeries(r2, "p").length, 1, "the window collapses to the strongest source");
-    } finally { cleanup(r2); }
-  } finally { cleanup(r); }
-});
-
-test("recordMeasurement refuses a non-numeric value and logs it", () => {
-  const r = root();
-  const logs = [];
-  try {
-    const res = recordMeasurement(r, { objectiveKey: "p", value: "banana", window: "w", source: "method" }, { now, log: (l, m) => logs.push(`${l}:${m}`) });
-    assert.equal(res.recorded, false);
-    assert.equal(res.reason, "non-numeric value");
-    assert.equal(logs.length, 1, "a refusal is never silent");
-  } finally { cleanup(r); }
-});
-
-test("interventions are the learning signal and read back newest-last", () => {
-  const r = root();
-  try {
-    for (const d of [-1, 0.5, 2]) {
-      recordIntervention(r, { objectiveKey: "pipeline", taskId: `t${d}`, expectedDelta: 1, realizedDelta: d }, { now });
-    }
-    const last2 = readInterventions(r, "pipeline", 2);
-    assert.deepEqual(last2.map((i) => i.realizedDelta), [0.5, 2]);
-  } finally { cleanup(r); }
-});
-
-test("isDue opens once per window and closes after a sample; no cadence is never due", () => {
-  const r = root();
-  try {
-    assert.equal(isDue(OBJ, [], { now }).due, true);
-    recordMeasurement(r, { objectiveKey: "pipeline", value: 2, window: "2026-W33", source: "method" }, { now });
-    assert.equal(isDue(OBJ, readSeries(r, "pipeline"), { now }).due, false);
-    const none = isDue({ ...OBJ, cadence: null }, [], { now });
-    assert.equal(none.due, false);
-    assert.match(none.reason, /no measure cadence/);
-  } finally { cleanup(r); }
-});
-
-// ---------------------------------------------------------------------------
-// measurement — the negative cases matter most
-// ---------------------------------------------------------------------------
-
-test("measureKpi executes a registered sensor and stamps method-sourced evidence", async () => {
-  const seen = [];
-  const m = await measureKpi(OBJ, {
-    sensors: { crm_list_deals: async ({ params }) => { seen.push(params); return { value: 2.4, rowCount: 17 }; } },
-    reachable: new Set(["crm_list_deals"]),
-  });
-  assert.equal(m.ok, true);
-  assert.equal(m.value, 2.4);
-  assert.equal(m.source, "method");
-  assert.equal(m.evidence.method, "crm_list_deals");
-  assert.equal(m.evidence.rowCount, 17);
-  assert.deepEqual(seen, [{ stage: "open" }]);
-});
-
-test("NEGATIVE — an unreachable capability refuses to measure rather than recording a zero", async () => {
-  const logs = [];
-  const m = await measureKpi(OBJ, {
-    sensors: { crm_list_deals: async () => 2.4 },
-    reachable: new Set(["something_else"]),
-    log: (l, msg) => logs.push(msg),
-  });
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "unreachable-capability");
-  assert.equal(m.value, null);
-  assert.match(logs.join(" "), /NOT reachable/);
-});
-
-test("NEGATIVE — a missing sensor implementation, a throwing sensor and a non-numeric result all fail loudly", async () => {
-  const logs = [];
-  const log = (l, msg) => logs.push(msg);
-
-  const missing = await measureKpi(OBJ, { sensors: {}, reachable: new Set(["crm_list_deals"]), log });
-  assert.equal(missing.reason, "no-implementation");
-
-  const threw = await measureKpi(OBJ, {
-    sensors: { crm_list_deals: async () => { throw new Error("server unreachable"); } },
-    reachable: new Set(["crm_list_deals"]),
-    log,
-  });
-  assert.equal(threw.reason, "sensor-threw");
-
-  const junk = await measureKpi(OBJ, {
-    sensors: { crm_list_deals: async () => ({ value: "n/a" }) },
-    reachable: new Set(["crm_list_deals"]),
-    log,
-  });
-  assert.equal(junk.reason, "non-numeric");
-  assert.equal(logs.length, 3, "every degradation is logged");
-});
-
-test("an objective with a human sensor is not an error — it is a human obligation", async () => {
-  const m = await measureKpi({ ...OBJ, sensor: { capability: null, source: "human" } }, { sensors: {} });
-  assert.equal(m.ok, false);
-  assert.equal(m.reason, "no-sensor");
-  assert.equal(m.source, "human");
-});
-
-// ---------------------------------------------------------------------------
-// the gap
-// ---------------------------------------------------------------------------
-
-function series(values, cadence = "weekly", at = "2026-08-11T09:00:00Z") {
-  return values.map((v, i) => ({ objectiveKey: "pipeline", value: v, window: `w${i}`, at, source: "method" }));
-}
-
-test("gapFor honours direction: up is a shortfall, down is an excess", () => {
-  const up = gapFor(OBJ, series([2.0]), { now });
-  assert.equal(up.gap, 1);
-  assert.equal(up.withinTolerance, false);
-  assert.equal(up.normalizedGap, +(1 / 3).toFixed(6));
-
-  const down = gapFor({ ...OBJ, direction: "down", target: 5 }, series([7]), { now });
-  assert.equal(down.gap, 2, "for a down metric, above target is the gap");
-
-  const under = gapFor({ ...OBJ, direction: "down", target: 5 }, series([3]), { now });
-  assert.equal(under.gap, -2);
-  assert.equal(under.withinTolerance, true, "beating a down-target is not a gap");
-});
-
-test("gapFor honours tolerance and band direction", () => {
-  const inTol = gapFor(OBJ, series([2.85]), { now });
-  assert.ok(inTol.gap <= 0.2 && inTol.withinTolerance, "0.15 short of 3 is inside a 0.2 tolerance");
-
-  const band = gapFor({ ...OBJ, direction: "band", target: 10, tolerance: 2 }, series([13]), { now });
-  assert.equal(band.gap, 1, "a band gap is the distance outside the band");
-  const inBand = gapFor({ ...OBJ, direction: "band", target: 10, tolerance: 2 }, series([11]), { now });
-  assert.equal(inBand.gap, 0);
-});
-
-test("gapFor computes a real trend over the gap, not the raw value", () => {
-  assert.equal(gapFor(OBJ, series([1.0, 1.8, 2.5]), { now }).trend, "improving");
-  assert.equal(gapFor(OBJ, series([2.5, 1.8, 1.0]), { now }).trend, "worsening");
-  assert.equal(gapFor(OBJ, series([2.0, 2.0, 2.0]), { now }).trend, "flat");
-  assert.equal(gapFor(OBJ, series([2.0]), { now }).trend, "unknown");
-});
-
-test("NEGATIVE — no samples, and no target, both report rather than compute", () => {
-  const none = gapFor(OBJ, [], { now });
-  assert.equal(none.gap, null);
-  assert.equal(none.reason, "no samples");
-
-  const noTarget = gapFor({ ...OBJ, target: null }, series([2]), { now });
-  assert.equal(noTarget.gap, null);
-  assert.match(noTarget.reason, /no numeric target/);
-  assert.equal(noTarget.target, null, "a null target must never coerce to 0");
-});
-
-test("a sensor silent for 2× its cadence is itself a gap", () => {
-  const stale = gapFor(OBJ, series([2], "weekly", "2026-07-01T09:00:00Z"), { now });
-  assert.equal(stale.stale, true);
-  assert.ok(stale.stalenessPeriods > 2);
-
-  const fresh = gapFor(OBJ, series([2], "weekly", "2026-08-10T09:00:00Z"), { now });
-  assert.equal(fresh.stale, false);
-});

package/lib/learning/config.test.mjs

@@ -1,75 +0,0 @@
-/**
- * config.test.mjs — learning config loader tests.
- * Run: node --test lib/learning/config.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 { loadLearningConfig, isLearningEnabled, DEFAULTS } from "./config.mjs";
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-learncfg-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-
-test("loadLearningConfig: defaults when no file / no root", async () => {
-  assert.deepEqual(await loadLearningConfig(null), DEFAULTS);
-  const root = tmpRoot();
-  const cfg = await loadLearningConfig(root);
-  assert.equal(cfg.minTurns, 4);
-  assert.equal(cfg.reviewModel, "sonnet");
-});
-
-test("loadLearningConfig: file overrides merge over defaults", async () => {
-  const root = tmpRoot();
-  writeFileSync(join(root, "config", "learning.yaml"), "minTurns: 6\nreviewModel: sonnet\nenabled: false\n");
-  const cfg = await loadLearningConfig(root);
-  assert.equal(cfg.minTurns, 6);
-  assert.equal(cfg.enabled, false);
-  assert.equal(isLearningEnabled(cfg), false);
-  // Untouched keys keep their defaults.
-  assert.equal(cfg.archiveDays, 90);
-});
-
-test("loadLearningConfig: inherits + unions the collective denylist", async () => {
-  const root = tmpRoot();
-  writeFileSync(join(root, "config", "learning.yaml"), "repoDenylist: [extra-repo]\n");
-  const cfg = await loadLearningConfig(root, { repoDenylist: ["client-work", "secrets"] });
-  assert.ok(cfg.repoDenylist.includes("client-work"));
-  assert.ok(cfg.repoDenylist.includes("secrets"));
-  assert.ok(cfg.repoDenylist.includes("extra-repo"), "file extends the inherited floor");
-});
-
-test("loadLearningConfig: consolidation defaults present (enabled / 5 / 14 / sonnet)", async () => {
-  const root = tmpRoot();
-  const cfg = await loadLearningConfig(root);
-  assert.equal(cfg.consolidation.enabled, true);
-  assert.equal(cfg.consolidation.minSkills, 5);
-  assert.equal(cfg.consolidation.intervalDays, 14);
-  assert.equal(cfg.consolidation.model, "sonnet");
-});
-
-test("loadLearningConfig: consolidation overrides deep-merge (keep untouched sub-keys)", async () => {
-  const root = tmpRoot();
-  writeFileSync(join(root, "config", "learning.yaml"), "consolidation:\n  enabled: false\n  minSkills: 3\n");
-  const cfg = await loadLearningConfig(root);
-  assert.equal(cfg.consolidation.enabled, false);
-  assert.equal(cfg.consolidation.minSkills, 3);
-  // intervalDays / model untouched → defaults.
-  assert.equal(cfg.consolidation.intervalDays, 14);
-  assert.equal(cfg.consolidation.model, "sonnet");
-});
-
-test("loadLearningConfig: corrupt yaml fails open to defaults+inheritance", async () => {
-  const root = tmpRoot();
-  writeFileSync(join(root, "config", "learning.yaml"), "minTurns: [unterminated");
-  const cfg = await loadLearningConfig(root, { repoDenylist: ["ring-fenced"] });
-  assert.equal(cfg.minTurns, 4);
-  assert.deepEqual(cfg.repoDenylist, ["ring-fenced"]);
-});

package/lib/learning/counters.test.mjs

@@ -1,69 +0,0 @@
-/**
- * counters.test.mjs — nudge-counter bump/reset/read tests.
- * Run: node --test lib/learning/counters.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 } from "node:path";
-
-import {
-  countersPath, emptyCounters, readCounters,
-  bumpToolUses, bumpSessions, resetSkillCounters,
-} from "./counters.mjs";
-
-function tmpRoot() {
-  return mkdtempSync(join(tmpdir(), "maestro-counters-"));
-}
-
-test("readCounters: fresh root reads as empty, never throws", () => {
-  const root = tmpRoot();
-  assert.deepEqual(readCounters(root), emptyCounters());
-  // No agentRoot → still empty, no throw.
-  assert.deepEqual(readCounters(null), emptyCounters());
-});
-
-test("readCounters: corrupt file fails open to empty", () => {
-  const root = tmpRoot();
-  const p = countersPath(root);
-  mkdirSync(join(root, "state", "learning"), { recursive: true });
-  writeFileSync(p, "{ not json");
-  assert.deepEqual(readCounters(root), emptyCounters());
-});
-
-test("bumpToolUses: increments and persists atomically", () => {
-  const root = tmpRoot();
-  bumpToolUses(root);
-  bumpToolUses(root, 4);
-  const c = readCounters(root);
-  assert.equal(c.tool_uses_since_skill, 5);
-  assert.ok(existsSync(countersPath(root)), "counters.json written");
-  // Round-trips through disk (not just in-memory).
-  const onDisk = JSON.parse(readFileSync(countersPath(root), "utf8"));
-  assert.equal(onDisk.tool_uses_since_skill, 5);
-});
-
-test("bumpSessions: increments + stamps last_reflect_at", () => {
-  const root = tmpRoot();
-  const nowMs = Date.parse("2026-06-09T10:00:00Z");
-  bumpSessions(root, { nowMs });
-  bumpSessions(root, { nowMs });
-  const c = readCounters(root);
-  assert.equal(c.sessions_since_skill, 2);
-  assert.equal(c.last_reflect_at, new Date(nowMs).toISOString());
-});
-
-test("resetSkillCounters: zeroes both counters + stamps last_skill_at", () => {
-  const root = tmpRoot();
-  bumpToolUses(root, 50);
-  bumpSessions(root);
-  const nowMs = Date.parse("2026-06-09T12:00:00Z");
-  resetSkillCounters(root, { nowMs });
-  const c = readCounters(root);
-  assert.equal(c.tool_uses_since_skill, 0);
-  assert.equal(c.sessions_since_skill, 0);
-  assert.equal(c.last_skill_at, new Date(nowMs).toISOString());
-});