@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/archetype.test.mjs

@@ -1,132 +0,0 @@
-/**
- * archetype.test.mjs — tests for the function × altitude archetype resolver.
- *
- * Covers the pure merge engine (deterministic, no I/O) and the live resolution
- * of the reference cell (technical-leader × vp). A full-matrix "every cell
- * resolves & validates" test guards the whole library once all overlays exist.
- *
- * Run: `node --test lib/archetype.test.mjs`
- * @module archetype.test
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  deepMerge,
-  resolveArchetype,
-  validateProfile,
-  listFunctions,
-  listAltitudes,
-  listCells,
-  deriveLegacyArchetype,
-  migrateLegacyArchetype,
-  LEGACY_ALTITUDE_DEFAULT,
-} from "./archetype.mjs";
-
-// --- deepMerge: the deterministic merge engine ---
-
-test("deepMerge: scalars — last layer wins", () => {
-  assert.equal(deepMerge("draft", "execute"), "execute");
-  assert.equal(deepMerge(1, 2), 2);
-  assert.equal(deepMerge("x", undefined), "x"); // undefined never overrides
-});
-
-test("deepMerge: plain objects merge key by key", () => {
-  assert.deepEqual(
-    deepMerge({ a: 1, n: { x: 1, y: 1 } }, { b: 2, n: { y: 2, z: 3 } }),
-    { a: 1, b: 2, n: { x: 1, y: 2, z: 3 } }
-  );
-});
-
-test("deepMerge: arrays of {id} upsert by id (later wins, new ids appended)", () => {
-  const a = [{ id: "k", authority: "recommends" }, { id: "m", authority: "owns" }];
-  const b = [{ id: "k", authority: "escalates" }, { id: "n", authority: "owns" }];
-  const merged = deepMerge(a, b);
-  assert.deepEqual(merged.map((e) => e.id), ["k", "m", "n"]);
-  assert.equal(merged.find((e) => e.id === "k").authority, "escalates"); // b wins
-});
-
-test("deepMerge: scalar arrays union (order-preserving, deduped)", () => {
-  assert.deepEqual(deepMerge(["a", "b"], ["b", "c"]), ["a", "b", "c"]);
-});
-
-// --- library is discoverable ---
-
-test("listFunctions/listAltitudes include the reference overlays", () => {
-  assert.ok(listFunctions().includes("technical-leader"));
-  assert.ok(listAltitudes().includes("vp"));
-});
-
-// --- live resolution of the reference cell ---
-
-test("resolveArchetype(technical-leader × vp) composes a valid profile", async () => {
-  const p = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  assert.equal(p.schemaVersion, 1);
-  assert.equal(p.function, "technical-leader");
-  assert.equal(p.altitude, "vp");
-  assert.equal(p.label, "VP, Engineering");
-  // function-provided WHAT:
-  assert.ok(p.towers.length >= 5);
-  assert.ok(p.backlogStreams.some((s) => s.id === "roadmap-delivery"));
-  assert.ok(p.kpiCategories.some((k) => k.id === "reliability"));
-  // altitude-provided HOW (overrides base):
-  assert.equal(p.autonomy.default, "execute"); // base 'draft' → altitude 'execute'
-  assert.equal(p.backlogGranularity, "epics");
-  assert.equal(p.kpiAltitude, "operational");
-});
-
-test("decision rights merge: function defaults + altitude overrides coexist", async () => {
-  const p = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  const byId = Object.fromEntries(p.decisionRights.map((d) => [d.id, d.authority]));
-  assert.equal(byId.architecture, "owns"); // from function
-  assert.equal(byId["external-commitments"], "escalates"); // from altitude
-  assert.equal(byId.strategy, "recommends"); // altitude-only scope
-});
-
-test("autonomy red band unions base (universal reds) with altitude reds", async () => {
-  const p = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  assert.ok(p.autonomy.red.some((r) => /Binding legal or financial/i.test(r))); // base
-  assert.ok(p.autonomy.red.some((r) => /strategy|restructure|headcount/i.test(r))); // altitude
-});
-
-test("operatingPrinciples union base + function + altitude", async () => {
-  const p = await resolveArchetype({ function: "technical-leader", altitude: "vp" });
-  assert.ok(p.operatingPrinciples.includes("Audit everything")); // base
-  assert.ok(p.operatingPrinciples.includes("Technical rigour over speed")); // function
-  assert.ok(p.operatingPrinciples.some((x) => /escalate the tradeoff/i.test(x))); // altitude
-});
-
-// --- failure modes ---
-
-test("resolveArchetype throws on unknown function or altitude", async () => {
-  await assert.rejects(() => resolveArchetype({ function: "nope", altitude: "vp" }), /unknown function/);
-  await assert.rejects(() => resolveArchetype({ function: "technical-leader", altitude: "nope" }), /unknown altitude/);
-  await assert.rejects(() => resolveArchetype({}), /requires \{ function, altitude \}/);
-});
-
-test("validateProfile rejects a malformed profile", () => {
-  assert.throws(() => validateProfile({ schemaVersion: 1, function: "x", altitude: "y", label: "z" }), /towers must be/);
-});
-
-// --- legacy back-compat ---
-
-test("legacy archetype derivation + migration", () => {
-  assert.equal(deriveLegacyArchetype({ function: "technical-leader" }), "technical-leader");
-  assert.deepEqual(migrateLegacyArchetype("technical-leader"), { function: "technical-leader", altitude: LEGACY_ALTITUDE_DEFAULT });
-  assert.equal(migrateLegacyArchetype("not-a-function"), null);
-});
-
-// --- full-matrix guard: every authored cell resolves & validates ---
-
-test("every (function × altitude) cell resolves and validates", async () => {
-  const cells = listCells();
-  assert.ok(cells.length >= 1);
-  for (const cell of cells) {
-    const p = await resolveArchetype(cell); // resolveArchetype validates internally
-    assert.equal(p.function, cell.function);
-    assert.equal(p.altitude, cell.altitude);
-  }
-});

package/lib/assurance/plan-note.test.mjs

@@ -1,234 +0,0 @@
-/**
- * plan-note.test.mjs — if we say we are working, show work; otherwise say nothing.
- *
- * The rule this pins is the hard one: NEVER FABRICATE A PLAN. Every bullet must
- * be text the model itself wrote in its own first turn. When there is no first
- * turn, or nothing in it that states an intent, the answer is null and null
- * means the agent posts nothing at all. A rendered template over an absent
- * session is exactly the content-free message this whole work package exists to
- * delete — it would merely be a longer one.
- *
- * Run: node --test lib/assurance/plan-note.test.mjs
- */
-
-import { test, describe } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  renderPlanNote,
-  firstAssistantText,
-  PLAN_MAX_BULLETS,
-  FORWARD_PROMISE,
-  containsForwardPromise,
-} from "./plan-note.mjs";
-
-const STEPS = [
-  "First I'll pull the July ledger rows and the forecast we signed off in June.",
-  "Then I'll reconcile them line by line and mark every variance over 5%.",
-  "Finally I'll write up the three biggest gaps with the numbers behind each.",
-].join("\n");
-
-// ---------------------------------------------------------------------------
-// firstAssistantText — every shape the CLI can hand us
-// ---------------------------------------------------------------------------
-
-describe("firstAssistantText — reading the session's own first turn", () => {
-  test("a --output-format json result object", () => {
-    assert.match(firstAssistantText(JSON.stringify({ type: "result", result: STEPS })), /pull the July ledger/);
-  });
-
-  test("an already-parsed result object", () => {
-    assert.match(firstAssistantText({ type: "result", result: STEPS }), /pull the July ledger/);
-  });
-
-  test("a stream-json assistant message", () => {
-    const msg = { type: "assistant", message: { content: [{ type: "text", text: STEPS }] } };
-    assert.match(firstAssistantText(msg), /pull the July ledger/);
-  });
-
-  test("an array of stream-json events takes the FIRST assistant turn, not the last", () => {
-    const events = [
-      { type: "system", subtype: "init" },
-      { type: "assistant", message: { content: [{ type: "text", text: STEPS }] } },
-      { type: "assistant", message: { content: [{ type: "text", text: "Done — all three variances written up." }] } },
-    ];
-    assert.match(firstAssistantText(events), /pull the July ledger/);
-    assert.doesNotMatch(firstAssistantText(events), /Done —/);
-  });
-
-  test("newline-delimited stream-json text", () => {
-    const ndjson = [
-      JSON.stringify({ type: "system", subtype: "init" }),
-      JSON.stringify({ type: "assistant", message: { content: [{ type: "text", text: STEPS }] } }),
-    ].join("\n");
-    assert.match(firstAssistantText(ndjson), /pull the July ledger/);
-  });
-
-  test("a tool_use block is not text and is skipped", () => {
-    const msg = { type: "assistant", message: { content: [{ type: "tool_use", name: "Read", input: {} }, { type: "text", text: STEPS }] } };
-    assert.match(firstAssistantText(msg), /pull the July ledger/);
-  });
-
-  test("plain prose is taken as itself", () => {
-    assert.equal(firstAssistantText(STEPS), STEPS);
-  });
-
-  test("absent, empty and malformed input read as nothing", () => {
-    for (const bad of [null, undefined, "", "   ", 12, [], {}, { type: "result" }, "{not json", { type: "assistant", message: null }]) {
-      assert.equal(firstAssistantText(bad), null, `${JSON.stringify(bad)} must read as nothing`);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// renderPlanNote
-// ---------------------------------------------------------------------------
-
-describe("renderPlanNote — at most three bullets of STATED intent, or null", () => {
-  test("three stated steps render as three bullets, in the model's own words", () => {
-    const note = renderPlanNote({ type: "assistant", message: { content: [{ type: "text", text: STEPS }] } });
-    assert.ok(note, "a real first turn with real steps must produce a note");
-    const bullets = note.split("\n").filter((l) => l.startsWith("- "));
-    assert.equal(bullets.length, 3);
-    assert.match(bullets[0], /pull the July ledger/);
-    assert.match(bullets[1], /reconcile them line by line/);
-    assert.match(bullets[2], /three biggest gaps/);
-  });
-
-  test("a numbered list is read as steps", () => {
-    const text = "Here's how I'll approach it:\n1. Pull the deal memos from the data room.\n2. Cross-check each against the signed term sheet.\n3. Flag anything the term sheet does not cover.";
-    const note = renderPlanNote(text);
-    assert.equal(note.split("\n").filter((l) => l.startsWith("- ")).length, 3);
-    assert.doesNotMatch(note, /^\s*1\./m, "the list markers are normalised away, not doubled");
-  });
-
-  test("more than three steps are CLIPPED to three, never summarised into something unsaid", () => {
-    const text = ["1. Pull the ledger rows for July.", "2. Reconcile against the forecast.", "3. Mark variances over five percent.", "4. Write the summary.", "5. Post it in the channel."].join("\n");
-    const note = renderPlanNote(text);
-    const bullets = note.split("\n").filter((l) => l.startsWith("- "));
-    assert.equal(bullets.length, PLAN_MAX_BULLETS);
-    assert.match(bullets[0], /Pull the ledger rows/);
-    assert.match(bullets[2], /variances over five percent/);
-  });
-
-  test("NEVER FABRICATE: every bullet is a substring of the model's own turn", () => {
-    const text = "1. Pull the deal memos from the data room.\n2. Cross-check each against the signed term sheet.";
-    const note = renderPlanNote(text);
-    for (const b of note.split("\n").filter((l) => l.startsWith("- "))) {
-      const body = b.slice(2).replace(/\.$/, "");
-      assert.ok(text.includes(body), `"${body}" is not text the model wrote`);
-    }
-  });
-
-  test("no first turn ⇒ null ⇒ nothing is posted", () => {
-    for (const bad of [null, undefined, "", {}, [], "{broken", { type: "result" }]) {
-      assert.equal(renderPlanNote(bad), null, `${JSON.stringify(bad)} must render nothing`);
-    }
-  });
-
-  test("a first turn with no stated intent ⇒ null, not a template", () => {
-    // Chatter, a question back, an answer — none of these is a plan, and
-    // dressing any of them up as one is the fabrication this rule forbids.
-    for (const text of [
-      "Sure, happy to look at that.",
-      "Which quarter did you mean — Q2 or Q3?",
-      "The board call is at 14:00 UK on Thursday.",
-      "Hmm.",
-    ]) {
-      assert.equal(renderPlanNote(text), null, `"${text}" is not a plan`);
-    }
-  });
-
-  test("a single stated step is still a plan", () => {
-    const note = renderPlanNote("I'll reconcile the July ledger against the signed forecast and list every variance over 5%.");
-    assert.ok(note);
-    assert.equal(note.split("\n").filter((l) => l.startsWith("- ")).length, 1);
-  });
-
-  test("a generic opener is not a step and is dropped", () => {
-    // "On it" inside a numbered list is still "On it".
-    const note = renderPlanNote("1. On it.\n2. Looking into this now.\n3. Pull the July ledger rows and reconcile them against the forecast.");
-    assert.ok(note);
-    const bullets = note.split("\n").filter((l) => l.startsWith("- "));
-    assert.equal(bullets.length, 1);
-    assert.match(bullets[0], /July ledger/);
-  });
-
-  test("…and a turn that is ONLY generic openers renders nothing", () => {
-    assert.equal(renderPlanNote("1. On it.\n2. Checking.\n3. One moment."), null);
-  });
-
-  test("the note names no working agent and wears no assistant costume", () => {
-    const note = renderPlanNote(STEPS);
-    assert.doesNotMatch(note, /\b(Odette|Coh|the agent|automation)\b/i);
-    assert.doesNotMatch(note, /^(sure|certainly|absolutely|happy to|of course)\b/i);
-    assert.doesNotMatch(note, /let me know if|here's a comprehensive/i);
-    assert.doesNotMatch(note, /[\u{1F300}-\u{1FAFF}]/u, "no emoji");
-  });
-
-  test("bullets are clipped, so one runaway paragraph cannot become a wall of text", () => {
-    const long = `I'll ${"reconcile every single line of the ledger ".repeat(20)}now.`;
-    const note = renderPlanNote(long);
-    for (const line of note.split("\n")) assert.ok(line.length <= 200, `line of ${line.length} chars is not a bullet`);
-  });
-
-  test("the renderer is pure — same input, same output, input untouched", () => {
-    const events = [{ type: "assistant", message: { content: [{ type: "text", text: STEPS }] } }];
-    const before = JSON.stringify(events);
-    const first = renderPlanNote(events);
-    for (let i = 0; i < 20; i++) assert.equal(renderPlanNote(events), first);
-    assert.equal(JSON.stringify(events), before);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// The copy rule the plan shares with every other interim
-// ---------------------------------------------------------------------------
-
-describe("containsForwardPromise — no promise without a mechanism", () => {
-  test("it recognises the promises the production sample was full of", () => {
-    for (const t of [
-      "Still on this — 5 minutes in. I'll come back as soon as I've got something.",
-      "Still going — 15 minutes in. I'll follow up the moment it's done.",
-      "I'll get back to you shortly.",
-      "I will report back as soon as I have it.",
-      "I'll let you know once it's done.",
-      "I'll circle back on this.",
-    ]) {
-      assert.equal(containsForwardPromise(t), true, `"${t}" is a forward promise`);
-    }
-  });
-
-  test("it does not flag a statement of what is being done now", () => {
-    for (const t of [
-      "Pulling the July ledger rows and reconciling them against the forecast.",
-      "I'm reconciling July against the forecast now.",
-      "Three variances so far, all in payroll.",
-      "Done — pushed as a41f0c9.",
-    ]) {
-      assert.equal(containsForwardPromise(t), false, `"${t}" is not a promise`);
-    }
-  });
-
-  test("a bullet that is only a promise is dropped from the plan", () => {
-    const note = renderPlanNote("1. Pull the July ledger rows and reconcile against the forecast.\n2. I'll come back as soon as I've got something.");
-    const bullets = note.split("\n").filter((l) => l.startsWith("- "));
-    assert.equal(bullets.length, 1);
-    assert.doesNotMatch(note, FORWARD_PROMISE);
-  });
-
-  test("a rendered plan NEVER carries a forward promise", () => {
-    for (const text of [
-      STEPS,
-      "1. Draft the memo. 2. I'll follow up with the numbers.",
-      "I'll pull the rows, then I'll come back as soon as I've got something.",
-    ]) {
-      const note = renderPlanNote(text);
-      if (note != null) assert.doesNotMatch(note, FORWARD_PROMISE, `"${note}" promises a return the sweep did not agree to`);
-    }
-  });
-
-  test("garbage in never throws", () => {
-    for (const bad of [null, undefined, 12, {}, []]) assert.equal(containsForwardPromise(bad), false);
-  });
-});