@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/learning/curator-consolidate.test.mjs

@@ -1,238 +0,0 @@
-/**
- * curator-consolidate.test.mjs — LLM skill-umbrella consolidation (WS3 phase 2).
- * Run: node --test lib/learning/curator-consolidate.test.mjs
- *
- * consolidateUmbrellas() merges narrowly-overlapping agent-authored skills into
- * ONE class-level umbrella. The LLM is a bounded, INJECTED function: a fake
- * `spawn` returns a strict-JSON envelope; no `claude --print`, no network. We
- * assert the full effect of a real consolidation:
- *   - the umbrella .md is created + added to plugin.json,
- *   - each absorbed skill is MOVED to _archive/ + dropped from plugin.json +
- *     marked state:"archived" / absorbed_into in the sidecar,
- *   - a consolidate row is appended to logs/audit/skills.jsonl,
- *   - below threshold → no spawn, no writes,
- *   - malformed / empty spawn output → fail-open no-op,
- *   - any thrown spawn → fail-open ({umbrellas:[], error}), never throws.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { consolidateUmbrellas } from "./curator.mjs";
-import { writeSkill, readSidecar } from "./skill-writer.mjs";
-
-function tmpRoot() {
-  return mkdtempSync(join(tmpdir(), "maestro-consolidate-"));
-}
-const skillPath = (root, id) => join(root, "plugins", "agent-skills", "skills", `${id}.md`);
-const archivePath = (root, id) => join(root, "plugins", "agent-skills", "skills", "_archive", `${id}.md`);
-const pluginJson = (root) => JSON.parse(readFileSync(join(root, "plugins", "agent-skills", "plugin.json"), "utf8"));
-const auditPath = (root) => join(root, "logs", "audit", "skills.jsonl");
-function auditRows(root) {
-  if (!existsSync(auditPath(root))) return [];
-  return readFileSync(auditPath(root), "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
-}
-
-/** Seed N active (live) skills to consolidate; returns their ids. */
-function seedSkills(root, n) {
-  const ids = [];
-  for (let i = 0; i < n; i++) {
-    const w = writeSkill({
-      agentRoot: root,
-      name: `Reconcile ledger variant ${i}`,
-      description: `close the books for source ${i}`,
-      body: `# Reconcile ${i}\n1. pull export\n2. diff ledger\n3. close`,
-      nowIso: new Date().toISOString(),
-      trusted: true, // seed LIVE skills; consolidation operates on active skills
-    });
-    assert.ok(w.ok, `seed skill ${i}`);
-    ids.push(w.id);
-  }
-  return ids;
-}
-
-/** A fake spawn that returns a JSON envelope merging the given absorb ids. */
-function spawnMerging(umbrellaName, absorb) {
-  return async () => JSON.stringify({
-    umbrellas: [{
-      name: umbrellaName,
-      description: "class-level reconciliation umbrella",
-      body: "# Reconciliation\nWhen closing any ledger:\n1. pull\n2. diff\n3. close",
-      absorbs: absorb,
-    }],
-  });
-}
-
-test("below minSkills → no spawn, no writes, reason 'below-threshold'", async () => {
-  const root = tmpRoot();
-  seedSkills(root, 3);
-  let spawned = false;
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    spawn: async () => { spawned = true; return "{}"; },
-  });
-  assert.equal(spawned, false, "spawn never called below threshold");
-  assert.equal(res.reason, "below-threshold");
-  assert.deepEqual(res.umbrellas, []);
-});
-
-test("merges 2 of N siblings: creates umbrella, archives absorbed, audits", async () => {
-  const root = tmpRoot();
-  const ids = seedSkills(root, 5);
-  const absorb = [ids[0], ids[1]];
-  assert.equal(pluginJson(root).skills.length, 5);
-
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    spawn: spawnMerging("Reconciliation", absorb),
-  });
-
-  // Summary
-  assert.equal(res.umbrellas.length, 1, "one umbrella created");
-  const umb = res.umbrellas[0];
-  assert.deepEqual(umb.absorbed.sort(), absorb.slice().sort());
-  assert.ok(umb.id, "umbrella has an id");
-
-  // Umbrella .md created + present in plugin.json.
-  assert.ok(existsSync(skillPath(root, umb.id)), "umbrella .md written");
-  const pj = pluginJson(root);
-  assert.ok(pj.skills.some((s) => s.name === umb.id), "umbrella in plugin.json");
-
-  // Absorbed skills: MOVED to _archive/, dropped from plugin.json.
-  for (const id of absorb) {
-    assert.ok(!existsSync(skillPath(root, id)), `${id} removed from active dir`);
-    assert.ok(existsSync(archivePath(root, id)), `${id} moved to _archive (not deleted)`);
-    assert.ok(!pj.skills.some((s) => s.name === id), `${id} dropped from plugin.json`);
-  }
-
-  // The 3 un-absorbed siblings + the umbrella remain in plugin.json (5 - 2 + 1 = 4).
-  assert.equal(pj.skills.length, 4, "plugin.json reflects archive + umbrella");
-
-  // Sidecar: absorbed marked archived + absorbed_into the umbrella id.
-  const sc = readSidecar(root);
-  for (const id of absorb) {
-    assert.equal(sc[id].state, "archived", `${id} sidecar state archived`);
-    assert.equal(sc[id].absorbed_into, umb.id, `${id} absorbed_into umbrella`);
-    assert.ok(sc[id].archived_at, `${id} has archived_at`);
-  }
-  // Umbrella sidecar record exists, active.
-  assert.ok(sc[umb.id], "umbrella sidecar record");
-  assert.equal(sc[umb.id].state, "active");
-
-  // Audit: a consolidate row referencing the umbrella + absorbed ids.
-  const rows = auditRows(root);
-  const consolidate = rows.find((r) => r.action === "consolidate");
-  assert.ok(consolidate, "consolidate audit row written");
-  assert.equal(consolidate.umbrella, umb.id);
-  assert.deepEqual(consolidate.absorbed.slice().sort(), absorb.slice().sort());
-});
-
-test("malformed spawn output → fail-open no-op (no umbrella, siblings untouched)", async () => {
-  const root = tmpRoot();
-  const ids = seedSkills(root, 5);
-  const before = pluginJson(root).skills.length;
-
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    spawn: async () => "this is not json at all",
-  });
-  assert.deepEqual(res.umbrellas, []);
-  assert.equal(pluginJson(root).skills.length, before, "no skills archived");
-  // None of the seeded skills moved.
-  for (const id of ids) assert.ok(existsSync(skillPath(root, id)), `${id} untouched`);
-});
-
-test("empty-envelope spawn (no clusters) → no-op", async () => {
-  const root = tmpRoot();
-  seedSkills(root, 6);
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    spawn: async () => JSON.stringify({ umbrellas: [] }),
-  });
-  assert.deepEqual(res.umbrellas, []);
-  assert.equal(pluginJson(root).skills.length, 6, "all siblings intact");
-});
-
-test("a cluster of <2 absorbs is rejected (never merge a single skill into an umbrella)", async () => {
-  const root = tmpRoot();
-  const ids = seedSkills(root, 5);
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    spawn: async () => JSON.stringify({
-      umbrellas: [{ name: "Singleton", description: "d", body: "b", absorbs: [ids[0]] }],
-    }),
-  });
-  assert.deepEqual(res.umbrellas, [], "singleton cluster ignored");
-  assert.ok(existsSync(skillPath(root, ids[0])), "lone skill not archived");
-});
-
-test("absorbs referencing unknown ids are filtered (only real siblings merge)", async () => {
-  const root = tmpRoot();
-  const ids = seedSkills(root, 5);
-  const res = await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 5,
-    // one valid id + one bogus → after filtering only 1 valid → cluster <2 → reject.
-    spawn: async () => JSON.stringify({
-      umbrellas: [{ name: "Mixed", description: "d", body: "b", absorbs: [ids[0], "does-not-exist"] }],
-    }),
-  });
-  assert.deepEqual(res.umbrellas, [], "cluster with <2 *valid* absorbs rejected");
-  assert.ok(existsSync(skillPath(root, ids[0])), "valid id not archived when cluster invalid");
-});
-
-test("a throwing spawn is fully fail-open: returns {umbrellas:[], error}, never throws", async () => {
-  const root = tmpRoot();
-  seedSkills(root, 5);
-  let res;
-  await assert.doesNotReject(async () => {
-    res = await consolidateUmbrellas({
-      agentRoot: root,
-      minSkills: 5,
-      spawn: async () => { throw new Error("model down"); },
-    });
-  });
-  assert.deepEqual(res.umbrellas, []);
-  assert.ok(res.error, "error captured in summary");
-});
-
-test("no agentRoot → clean no-op", async () => {
-  const res = await consolidateUmbrellas({ spawn: async () => "{}" });
-  assert.deepEqual(res.umbrellas, []);
-});
-
-test("pinned / non-agent / already-archived skills are excluded from candidates", async () => {
-  const root = tmpRoot();
-  const ids = seedSkills(root, 6);
-  // Pin one, archive one, mark one as human-authored.
-  const sc = readSidecar(root);
-  sc[ids[0]].pinned = true;
-  sc[ids[1]].state = "archived";
-  sc[ids[2]].created_by = "human";
-  // writeSidecar via skill-writer re-export
-  const { writeSidecar } = await import("./skill-writer.mjs");
-  writeSidecar(root, sc);
-
-  // The candidate list the prompt sees must exclude pinned/archived/human.
-  // We capture it by inspecting which ids the spawn is asked to consider via a
-  // recording spawn that merges only what it's actually given a description for.
-  let promptSeen = "";
-  await consolidateUmbrellas({
-    agentRoot: root,
-    minSkills: 3,
-    spawn: async (prompt) => { promptSeen = prompt; return JSON.stringify({ umbrellas: [] }); },
-  });
-  assert.ok(!promptSeen.includes(ids[0]), "pinned excluded from prompt");
-  assert.ok(!promptSeen.includes(ids[1]), "archived excluded from prompt");
-  assert.ok(!promptSeen.includes(ids[2]), "human-authored excluded from prompt");
-  assert.ok(promptSeen.includes(ids[3]), "active agent skill included");
-});

package/lib/learning/curator.test.mjs

@@ -1,106 +0,0 @@
-/**
- * curator.test.mjs — deterministic skill lifecycle tests.
- * Run: node --test lib/learning/curator.test.mjs
- *
- * Covers: 30d active→stale, 90d →archived, archive MOVES (not deletes) +
- * drops from plugin.json, pinned exempt, hasPendingTransitions guard.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { runCurator, nextState, hasPendingTransitions } from "./curator.mjs";
-import { writeSkill, readSidecar, writeSidecar } from "./skill-writer.mjs";
-
-function tmpRoot() {
-  return mkdtempSync(join(tmpdir(), "maestro-curator-"));
-}
-const skillPath = (root, id) => join(root, "plugins", "agent-skills", "skills", `${id}.md`);
-const archivePath = (root, id) => join(root, "plugins", "agent-skills", "skills", "_archive", `${id}.md`);
-const pluginJson = (root) => JSON.parse(readFileSync(join(root, "plugins", "agent-skills", "plugin.json"), "utf8"));
-
-const NOW = Date.parse("2026-06-09T00:00:00Z");
-const daysAgo = (n) => new Date(NOW - n * 86400_000).toISOString();
-
-test("nextState: pure transitions by age", () => {
-  assert.equal(nextState({ state: "active", last_activity: daysAgo(5) }, { nowMs: NOW }), "active");
-  assert.equal(nextState({ state: "active", last_activity: daysAgo(31) }, { nowMs: NOW }), "stale");
-  assert.equal(nextState({ state: "stale", last_activity: daysAgo(95) }, { nowMs: NOW }), "archived");
-  // active that's been silent >90d jumps straight to archived.
-  assert.equal(nextState({ state: "active", last_activity: daysAgo(120) }, { nowMs: NOW }), "archived");
-  // pinned is exempt regardless of age.
-  assert.equal(nextState({ state: "active", pinned: true, last_activity: daysAgo(365) }, { nowMs: NOW }), "active");
-  // archived is terminal.
-  assert.equal(nextState({ state: "archived", last_activity: daysAgo(365) }, { nowMs: NOW }), "archived");
-});
-
-test("runCurator: active→stale at 30d, no file move", () => {
-  const root = tmpRoot();
-  const a = writeSkill({ agentRoot: root, name: "Aging Skill", description: "d", body: "x", nowIso: daysAgo(40), trusted: true });
-  // Backdate last_activity so it's stale-eligible.
-  const sc = readSidecar(root);
-  sc[a.id].last_activity = daysAgo(40);
-  writeSidecar(root, sc);
-
-  const res = runCurator({ agentRoot: root, now: NOW });
-  assert.deepEqual(res.transitioned, [{ id: a.id, from: "active", to: "stale" }]);
-  assert.deepEqual(res.archived, []);
-  assert.equal(readSidecar(root)[a.id].state, "stale");
-  assert.ok(existsSync(skillPath(root, a.id)), "stale skill still in place");
-});
-
-test("runCurator: stale→archived at 90d MOVES the file + drops from plugin.json (never deletes)", () => {
-  const root = tmpRoot();
-  const a = writeSkill({ agentRoot: root, name: "Old Skill", description: "d", body: "ARCHIVE ME", nowIso: daysAgo(120), trusted: true });
-  const sc = readSidecar(root);
-  sc[a.id].state = "stale";
-  sc[a.id].last_activity = daysAgo(120);
-  writeSidecar(root, sc);
-  assert.equal(pluginJson(root).skills.length, 1);
-
-  const res = runCurator({ agentRoot: root, now: NOW });
-  assert.deepEqual(res.archived, [a.id]);
-  assert.equal(readSidecar(root)[a.id].state, "archived");
-
-  // File MOVED — gone from skills/, present in skills/_archive/ with body intact.
-  assert.ok(!existsSync(skillPath(root, a.id)), "removed from active skills dir");
-  assert.ok(existsSync(archivePath(root, a.id)), "moved into _archive (not deleted)");
-  assert.match(readFileSync(archivePath(root, a.id), "utf8"), /ARCHIVE ME/);
-
-  // Dropped from plugin.json manifest.
-  assert.equal(pluginJson(root).skills.length, 0, "dropped from plugin.json");
-});
-
-test("runCurator: pinned skill is exempt from all transitions", () => {
-  const root = tmpRoot();
-  const a = writeSkill({ agentRoot: root, name: "Pinned Skill", description: "d", body: "keep", nowIso: daysAgo(400), trusted: true });
-  const sc = readSidecar(root);
-  sc[a.id].pinned = true;
-  sc[a.id].last_activity = daysAgo(400);
-  writeSidecar(root, sc);
-
-  const res = runCurator({ agentRoot: root, now: NOW });
-  assert.deepEqual(res.transitioned, []);
-  assert.equal(readSidecar(root)[a.id].state, "active");
-  assert.ok(existsSync(skillPath(root, a.id)), "pinned skill untouched");
-});
-
-test("hasPendingTransitions: true only when something would move", () => {
-  const root = tmpRoot();
-  const a = writeSkill({ agentRoot: root, name: "Fresh", description: "d", body: "x", nowIso: daysAgo(2), trusted: true });
-  assert.equal(hasPendingTransitions(root, { now: NOW }), false, "fresh → nothing pending");
-  const sc = readSidecar(root);
-  sc[a.id].last_activity = daysAgo(45);
-  writeSidecar(root, sc);
-  assert.equal(hasPendingTransitions(root, { now: NOW }), true, "45d-old active → stale pending");
-});
-
-test("runCurator: no agentRoot / empty sidecar is a clean no-op", () => {
-  assert.deepEqual(runCurator({}), { transitioned: [], archived: [], errors: [] });
-  const root = tmpRoot();
-  assert.deepEqual(runCurator({ agentRoot: root, now: NOW }), { transitioned: [], archived: [], errors: [] });
-});

package/lib/learning/session-index.test.mjs

@@ -1,125 +0,0 @@
-/**
- * session-index.test.mjs — transcript FTS5 store tests (temp DB, no network).
- * Run: node --test lib/learning/session-index.test.mjs
- *
- * Covers: ingest idempotency (mtime skip + force replace), discovery bm25 +
- * bookend, scroll window, read full session, browse recency.
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, utimesSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { ingestSession, ingestAll, search, dbPath } from "./session-index.mjs";
-
-function tmpRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-sessidx-"));
-  mkdirSync(join(root, "logs", "sessions"), { recursive: true });
-  return root;
-}
-
-/** Write a JSONL transcript with explicit sessionId on each record. */
-function writeTranscript(root, name, sessionId, turns, mtimeSec) {
-  const file = join(root, "logs", "sessions", `${name}.jsonl`);
-  const lines = turns.map((t) => JSON.stringify({
-    sessionId, role: t.role, content: t.body, timestamp: t.ts || "",
-  }));
-  writeFileSync(file, lines.join("\n") + "\n");
-  if (mtimeSec) utimesSync(file, mtimeSec, mtimeSec);
-  return file;
-}
-
-const TURNS = [
-  { role: "user", body: "We need to reconcile the billing export with stripe", ts: "2026-06-01T09:00:00Z" },
-  { role: "assistant", body: "I will pull the export and diff it against the ledger", ts: "2026-06-01T09:01:00Z" },
-  { role: "user", body: "Great, focus on the duplicate charge anomaly", ts: "2026-06-01T09:02:00Z" },
-  { role: "assistant", body: "Found three duplicates; refund issued and reconciliation closed", ts: "2026-06-01T09:03:00Z" },
-];
-
-test("ingestSession: adds turns, idempotent on unchanged mtime, replaces on force", async () => {
-  const root = tmpRoot();
-  const file = writeTranscript(root, "sess-a", "SID-A", TURNS, 1_700_000_000);
-
-  const r1 = await ingestSession({ agentRoot: root, file });
-  assert.equal(r1.sessionId, "SID-A");
-  assert.equal(r1.turns, 4);
-  assert.equal(r1.reason, "added");
-  assert.ok(existsSync(dbPath(root)), "db created");
-
-  // Re-ingest, same mtime → skipped (idempotent).
-  const r2 = await ingestSession({ agentRoot: root, file });
-  assert.equal(r2.skipped, true);
-  assert.equal(r2.reason, "unchanged");
-
-  // Force → replace.
-  const r3 = await ingestSession({ agentRoot: root, file, force: true });
-  assert.equal(r3.skipped, false);
-  assert.equal(r3.turns, 4);
-});
-
-test("ingestAll: ingests a directory, then skips unchanged on a second pass", async () => {
-  const root = tmpRoot();
-  writeTranscript(root, "sess-a", "SID-A", TURNS, 1_700_000_000);
-  writeTranscript(root, "sess-b", "SID-B", TURNS.slice(0, 2), 1_700_000_100);
-
-  const first = await ingestAll({ agentRoot: root });
-  assert.equal(first.files, 2);
-  assert.equal(first.added, 2);
-
-  const second = await ingestAll({ agentRoot: root });
-  assert.equal(second.added, 0);
-  assert.equal(second.skipped, 2, "unchanged files skipped");
-});
-
-test("search discovery: bm25 hit + per-session bookend (first & last turn)", async () => {
-  const root = tmpRoot();
-  const file = writeTranscript(root, "sess-a", "SID-A", TURNS, 1_700_000_000);
-  await ingestSession({ agentRoot: root, file });
-
-  const res = await search("duplicate charge anomaly", { agentRoot: root, mode: "discovery", topN: 5 });
-  assert.equal(res.mode, "discovery");
-  assert.ok(res.hits.length >= 1, "found a matching turn");
-  const top = res.hits[0];
-  assert.equal(top.session_id, "SID-A");
-  assert.match(top.snippet, /duplicate|anomaly|charge/i);
-  // Bookend present on the first hit of the session.
-  assert.ok(top.bookend, "bookend attached");
-  assert.match(top.bookend.first.body, /reconcile the billing export/);
-  assert.match(top.bookend.last.body, /reconciliation closed/);
-});
-
-test("search scroll: window of turns around an anchor seq", async () => {
-  const root = tmpRoot();
-  const file = writeTranscript(root, "sess-a", "SID-A", TURNS, 1_700_000_000);
-  await ingestSession({ agentRoot: root, file });
-
-  const res = await search("", { agentRoot: root, mode: "scroll", sessionId: "SID-A", seq: 1, window: 1 });
-  assert.equal(res.mode, "scroll");
-  const seqs = res.turns.map((t) => t.seq);
-  assert.deepEqual(seqs, [0, 1, 2], "±1 around seq 1");
-});
-
-test("search read: full session in order; browse: recent sessions", async () => {
-  const root = tmpRoot();
-  writeTranscript(root, "sess-a", "SID-A", TURNS, 1_700_000_000);
-  writeTranscript(root, "sess-b", "SID-B", TURNS.slice(0, 2), 1_700_000_100);
-  await ingestAll({ agentRoot: root });
-
-  const read = await search("", { agentRoot: root, mode: "read", sessionId: "SID-A" });
-  assert.equal(read.turns.length, 4);
-  assert.deepEqual(read.turns.map((t) => t.seq), [0, 1, 2, 3]);
-
-  const browse = await search("", { agentRoot: root, mode: "browse" });
-  assert.equal(browse.mode, "browse");
-  const ids = browse.sessions.map((s) => s.session_id);
-  assert.ok(ids.includes("SID-A") && ids.includes("SID-B"));
-});
-
-test("search: missing DB fails open to empty per mode", async () => {
-  const root = tmpRoot(); // nothing ingested
-  assert.deepEqual((await search("x", { agentRoot: root, mode: "discovery" })).hits, []);
-  assert.deepEqual((await search("", { agentRoot: root, mode: "browse" })).sessions, []);
-});