@cohortapp/agent-sdk 2.17.0 → 2.18.5

package/scripts/daemon/goal-steward-cadence.test.mjs

@@ -1,312 +0,0 @@
-/**
- * scripts/daemon/goal-steward-cadence.test.mjs — the wiring that makes the
- * self-directed loop actually RUN.
- *
- * Before this, `lib/goals/loop.mjs` existed and nothing ever called it: no
- * standard cadence, no registry entry, no plist. A loop nobody triggers is a
- * design document. These tests pin the trigger down:
- *
- *   - `goal-steward` is a STANDARD cadence, so every agent gets a plist for it
- *   - it is GUARDED, so an agent with no adopted mandate costs ~nothing
- *   - it refreshes the mandate BEFORE measuring
- *   - it defaults to observe-only, whatever the caller forgot to pass
- *   - it escalates only when an open gap needs candidates it cannot produce
- */
-
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { CADENCE_REGISTRY, getCadenceDef, guardGoalSteward } from "./cadence-handlers.mjs";
-import { STANDARD_CADENCES } from "../../lib/cadences.mjs";
-
-function makeRoot() {
-  const root = mkdtempSync(join(tmpdir(), "goal-cadence-"));
-  mkdirSync(join(root, "config"), { recursive: true });
-  return root;
-}
-function cleanup(root) { try { rmSync(root, { recursive: true, force: true }); } catch { /* best effort */ } }
-
-/** Baseline seams: no network, no real loop. */
-function seams(over = {}) {
-  return {
-    refreshImpl: async () => ({ ok: true, source: "server", tier: "fresh" }),
-    runImpl: async () => ({ ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }),
-    ...over,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-test("goal-steward is a STANDARD cadence, so every agent gets one", () => {
-  const c = STANDARD_CADENCES.find((x) => x.id === "goal-steward");
-  assert.ok(c, "the loop must have a trigger or it never runs");
-  assert.equal(c.scope, "standard");
-  assert.equal(c.mode, "guarded");
-  // Daily, on a calendar slot — not a hot interval.
-  assert.deepEqual(c.calendar, { hour: 7, minute: 15 });
-  assert.equal(c.prompt, "schedules/triggers/goal-steward.md");
-});
-
-test("the daemon can route the cadence it is about to be sent", () => {
-  const def = getCadenceDef("goal-steward");
-  assert.ok(def, "an unroutable cadence DLQs every tick");
-  assert.equal(def.mode, "guarded");
-  assert.equal(typeof def.guard, "function");
-  assert.equal(CADENCE_REGISTRY["goal-steward"].guard, guardGoalSteward);
-  // Scoped tool surface: reads + collaboration primitives, no shell.
-  const tools = CADENCE_REGISTRY["goal-steward"].allowedTools;
-  assert.ok(Array.isArray(tools) && tools.length > 0);
-  assert.ok(tools.includes("approval_request"), "gated work must be able to reach the approval path");
-  assert.ok(!tools.includes("Bash"), "the goal loop has no business running shell");
-});
-
-// ---------------------------------------------------------------------------
-// The guard
-// ---------------------------------------------------------------------------
-
-test("the mandate is refreshed BEFORE the loop measures anything", async () => {
-  const root = makeRoot();
-  try {
-    const order = [];
-    await guardGoalSteward({ event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} }, seams({
-      refreshImpl: async () => { order.push("refresh"); return { ok: true }; },
-      runImpl: async () => { order.push("run"); return { ok: true, measured: [], admitted: [], decisions: [] }; },
-    }));
-    assert.deepEqual(order, ["refresh", "run"], "measuring against a stale mandate is worse than not measuring");
-  } finally { cleanup(root); }
-});
-
-test("enforcement defaults to OBSERVE when config/plan.yaml says nothing", async () => {
-  const root = makeRoot();
-  try {
-    let seen = null;
-    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
-    }));
-    assert.equal(seen, "observe", "a loop that starts by writing is how you lose a fleet");
-  } finally { cleanup(root); }
-});
-
-test("enforcement:active in config/plan.yaml turns the loop on", async () => {
-  const root = makeRoot();
-  try {
-    writeFileSync(join(root, "config", "plan.yaml"), "version: 1\nenforcement: active\nobligations: []\n", "utf-8");
-    let seen = null;
-    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
-    }));
-    assert.equal(seen, "active");
-  } finally { cleanup(root); }
-});
-
-test("any other enforcement value stays observe — fail-closed on the write path", async () => {
-  const root = makeRoot();
-  try {
-    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: yes-please\n", "utf-8");
-    let seen = null;
-    await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async (d) => { seen = d.enforcement; return { ok: true, measured: [], admitted: [], decisions: [] }; },
-    }));
-    assert.equal(seen, "observe");
-  } finally { cleanup(root); }
-});
-
-test("no adopted mandate completes INLINE — an idle seat costs one cache read", async () => {
-  const root = makeRoot();
-  try {
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async () => ({ ok: false, skipped: "no mandate cache — this seat has never fetched an adopted mandate" }),
-    }));
-    assert.equal(r.ok, true, "a pre-adoption seat is not a bus failure");
-    assert.equal(r.decision, "inline");
-    assert.match(r.reason, /never fetched an adopted mandate/);
-  } finally { cleanup(root); }
-});
-
-test("a satisfied mandate completes inline and never spawns a session", async () => {
-  const root = makeRoot();
-  try {
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async () => ({
-        ok: true, measured: [{ objectiveKey: "pipeline", value: 4 }], admitted: [], rejected: [],
-        escalations: [], drift: [], decisions: [{ objectiveKey: "pipeline", action: "none" }],
-      }),
-    }));
-    assert.equal(r.decision, "inline");
-    assert.equal(r.measured, 1);
-    assert.equal(r.admitted, 0);
-  } finally { cleanup(root); }
-});
-
-test("a gap the deterministic planner SERVED completes inline — the work is already queued", async () => {
-  const root = makeRoot();
-  try {
-    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: active\n", "utf-8");
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async () => ({
-        ok: true,
-        measured: [{ objectiveKey: "pipeline", value: 1 }],
-        admitted: [{ objectiveKey: "pipeline", title: "Book calls" }],
-        rejected: [], escalations: [], drift: [],
-        decisions: [{ objectiveKey: "pipeline", action: "create" }],
-      }),
-    }));
-    assert.equal(r.decision, "inline", "no model is needed when the work already exists");
-    assert.equal(r.admitted, 1);
-  } finally { cleanup(root); }
-});
-
-test("an UNSERVED open gap escalates to a planning session, naming the objectives", async () => {
-  const root = makeRoot();
-  try {
-    writeFileSync(join(root, "config", "plan.yaml"), "enforcement: active\n", "utf-8");
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async () => ({
-        ok: true,
-        measured: [{ objectiveKey: "pipeline", value: 1 }],
-        admitted: [], rejected: [], escalations: [], drift: [],
-        decisions: [{ objectiveKey: "pipeline", action: "create" }],
-      }),
-    }));
-    assert.equal(r.decision, "escalate");
-    assert.deepEqual(r.objectives, ["pipeline"]);
-  } finally { cleanup(root); }
-});
-
-test("OBSERVE-ONLY never escalates, even with an unserved gap", async () => {
-  const root = makeRoot();
-  try {
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: () => {} }, seams({
-      runImpl: async () => ({
-        ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [],
-        decisions: [{ objectiveKey: "pipeline", action: "create" }],
-      }),
-    }));
-    assert.equal(r.decision, "inline", "the observe window must not spend money on planning sessions");
-  } finally { cleanup(root); }
-});
-
-// ---------------------------------------------------------------------------
-// Failure containment
-// ---------------------------------------------------------------------------
-
-test("SERVER UNREACHABLE: a failed mandate refresh degrades to the cache, loudly", async () => {
-  const root = makeRoot();
-  try {
-    const logs = [];
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
-      refreshImpl: async () => ({ ok: false, reason: "call-threw:ECONNREFUSED" }),
-    }));
-    assert.equal(r.ok, true, "a partition must not stop the loop from running on cache");
-    assert.ok(logs.some((l) => /refresh failed/.test(l)));
-  } finally { cleanup(root); }
-});
-
-test("SERVER UNREACHABLE: a THROWING refresh is contained and logged", async () => {
-  const root = makeRoot();
-  try {
-    const logs = [];
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
-      refreshImpl: async () => { throw new Error("ECONNREFUSED"); },
-    }));
-    assert.equal(r.ok, true);
-    assert.ok(logs.some((l) => /refresh threw/.test(l)));
-  } finally { cleanup(root); }
-});
-
-test("a THROWING loop returns ok:false with the error — fail-open but never silent", async () => {
-  const root = makeRoot();
-  try {
-    const logs = [];
-    const r = await guardGoalSteward({ event: {}, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) }, seams({
-      runImpl: async () => { throw new Error("loop exploded"); },
-    }));
-    assert.equal(r.ok, false);
-    assert.match(r.error, /loop exploded/);
-    assert.ok(logs.some((l) => l.startsWith("error:")), "the daemon keeps running, the failure is on the record");
-  } finally { cleanup(root); }
-});
-
-test("the guard never throws, whatever it is handed", async () => {
-  const r = await guardGoalSteward({ event: null, agentRoot: "/nonexistent-xyz", log: null }, seams({
-    runImpl: async () => null,
-  }));
-  assert.equal(typeof r.ok, "boolean");
-  assert.equal(r.cadence, "goal-steward");
-});
-
-// ---------------------------------------------------------------------------
-// THE SENSOR REGISTRY — the joint that made every KPI unmeasurable
-// ---------------------------------------------------------------------------
-
-test("the guard BUILDS the sensor registry and hands it to the loop", async () => {
-  const root = makeRoot();
-  try {
-    let got = null;
-    await guardGoalSteward(
-      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
-      seams({ runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
-    );
-    assert.ok(got, "the loop ran");
-    assert.equal(typeof got.sensors, "object", "run() must receive a sensor registry");
-    // Real, executable sensors — not an empty object. Without this every
-    // objective returns {ok:false,"no-implementation"} and D3 can never admit.
-    assert.equal(typeof got.sensors.board_ready, "function");
-    assert.equal(typeof got.sensors.decision_list, "function");
-    assert.equal(typeof got.sensors.email_inbox, "function");
-    // …including a named refusal for every capability the derivation can pick.
-    assert.equal(typeof got.sensors.task_update, "function");
-  } finally { cleanup(root); }
-});
-
-test("a missing capability manifest passes reachable=undefined, NOT an empty set", async () => {
-  const root = makeRoot();
-  try {
-    let got = null;
-    await guardGoalSteward(
-      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
-      seams({ runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
-    );
-    // measureKpi only enforces reachability when it is defined; an empty Set
-    // here would silently refuse every objective in the fleet.
-    assert.equal(got.reachable, undefined);
-  } finally { cleanup(root); }
-});
-
-test("the caller's sensors win — the registry is an override, not a mandate", async () => {
-  const root = makeRoot();
-  try {
-    let got = null;
-    const mine = { board_ready: async () => ({ value: 1 }) };
-    await guardGoalSteward(
-      { event: { cadence: "goal-steward" }, agentRoot: root, log: () => {} },
-      seams({ sensors: mine, reachable: new Set(["board_ready"]),
-        runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; } }),
-    );
-    assert.equal(got.sensors, mine);
-    assert.ok(got.reachable.has("board_ready"));
-  } finally { cleanup(root); }
-});
-
-test("a registry that cannot be built is LOUD, and the loop still runs", async () => {
-  const root = makeRoot();
-  const logs = [];
-  try {
-    let got = null;
-    await guardGoalSteward(
-      { event: { cadence: "goal-steward" }, agentRoot: root, log: (l, m) => logs.push(`${l}:${m}`) },
-      seams({
-        // A poisoned root: resolveAgentRoot of a non-string throws inside the builder.
-        runImpl: async (deps) => { got = deps; return { ok: true, measured: [], admitted: [], rejected: [], escalations: [], drift: [], decisions: [] }; },
-      }),
-    );
-    assert.ok(got, "the guard never blocks the loop on a registry failure");
-  } finally { cleanup(root); }
-});

package/scripts/daemon/inbox-deferral-session.test.mjs

@@ -1,49 +0,0 @@
-/**
- * inbox-deferral-session.test.mjs — promoteDeferred must leave a SESSION
- * deferral alone (design §3.3). Both actors park items at `.yaml.deferred`:
- * the daemon for a thread-lock burst (promoted on session close), the main
- * session with `maestro inbox defer --until` (carries a column-0
- * `deferred_until:` marker; the daemon's assurance sweep reopens it when due).
- * A session close for the same channel must neither promote a session
- * deferral early nor fold it away as `.processed-bundled`.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { promoteDeferred } from "./inbox-deferral.mjs";
-
-function makeAgentRoot() {
-  const root = mkdtempSync(join(tmpdir(), "maestro-deferral-session-"));
-  mkdirSync(join(root, "state", "inbox", "cohort"), { recursive: true });
-  return root;
-}
-function item(id, ts, extra = "") {
-  return `id: "${id}"\nservice: "cohort"\nchannel_id: "D001"\nthread_id: "t1"\ntimestamp: "${ts}"\ncontent: |\n  body\n${extra}`;
-}
-function ls(root) { return readdirSync(join(root, "state", "inbox", "cohort")).sort(); }
-
-test("promoteDeferred: a session deferral (deferred_until marker) is neither promoted nor bundled; legacy deferrals in the same thread still promote", () => {
-  const root = makeAgentRoot();
-  try {
-    // A: session deferral, oldest in the thread.
-    writeFileSync(join(root, "state/inbox/cohort/a.yaml.deferred"), item("A", "2026-09-08T09:00:00Z", 'deferred_until: "2026-09-09T09:00:00.000Z"\ndeferred_reason: "waiting on finance"\n'));
-    // C: daemon thread-lock deferral, newest — the one a session close promotes.
-    writeFileSync(join(root, "state/inbox/cohort/c.yaml.deferred"), item("C", "2026-09-08T10:00:00Z"));
-    const r = promoteDeferred("D001", root);
-    assert.equal(r.promoted, 1);
-    assert.equal(r.bundled, 0, "a session deferral is not a burst duplicate — it must not be folded away");
-    assert.deepEqual(ls(root), ["a.yaml.deferred", "c.yaml"]);
-    // With no daemon deferral at all, a session close promotes nothing (A is not due yet).
-    rmSync(join(root, "state/inbox/cohort/c.yaml"));
-    assert.deepEqual(promoteDeferred("D001", root), { promoted: 0, bundled: 0, service: null });
-    assert.deepEqual(ls(root), ["a.yaml.deferred"]);
-    // An indented look-alike inside the body is NOT a marker (column-0 only).
-    writeFileSync(join(root, "state/inbox/cohort/b.yaml.deferred"), `id: "B"\nservice: "cohort"\nchannel_id: "D001"\nthread_id: "t1"\ntimestamp: "2026-09-08T11:00:00Z"\ncontent: |\n  deferred_until: "2099-01-01T00:00:00Z"\n`);
-    assert.equal(promoteDeferred("D001", root).promoted, 1);
-    assert.deepEqual(ls(root), ["a.yaml.deferred", "b.yaml"]);
-  } finally { rmSync(root, { recursive: true, force: true }); }
-});