@cohortapp/agent-sdk 2.3.0

package/lib/backlog.mjs

@@ -0,0 +1,358 @@
+/**
+ * backlog.mjs — WBS backlog skeleton builder + queue materialiser.
+ *
+ * Turns a resolved archetype profile into a Work-Breakdown-Structure backlog
+ * (streams → phases → epics → tasks) and materialises the immediately-actionable
+ * (first-30-day) tasks into the queue-item shape the reactive backlog-executor
+ * already consumes (state/queues/*.yaml). This is what makes a freshly-
+ * initialised agent "get straight to work": the moment the daemon starts, the
+ * backlog-executor finds seeded, archetype-appropriate work and begins.
+ *
+ * The skeleton is structurally complete from the profile alone (streams come
+ * from profile.backlogStreams; granularity from the altitude). The init wizard
+ * ENRICHES epics/tasks with company-specific content from the gathered context
+ * pack before materialising — but even un-enriched the seed is real, actionable
+ * first-moves, not empty queues.
+ *
+ * Pure (no I/O). The caller passes `date` (no Date.now here) so output is
+ * deterministic and testable. ESM.
+ *
+ * @module backlog
+ */
+
+"use strict";
+
+/** The three first-quarter phases every seeded backlog scaffolds. */
+export const PHASES = [
+  { id: "d30", name: "First 30 days", horizon: "establish" },
+  { id: "d60", name: "Days 31–60", horizon: "execute" },
+  { id: "d90", name: "Days 61–90", horizon: "compound" },
+];
+
+/** Per-horizon seed templates. Generic-but-actionable; enriched at init. */
+const SEED = {
+  establish: (s) => ({
+    epic: `Establish baseline for ${s.name}`,
+    task: `Assess the current state of ${s.intent || s.name}: identify the top 3 risks/opportunities and define the success metrics.`,
+    criteria: ["Baseline documented", "Top 3 risks/opportunities identified", "Success metrics agreed"],
+  }),
+  execute: (s) => ({
+    epic: `Advance ${s.name} to a first milestone`,
+    task: `Drive the highest-priority initiative in ${s.name} to a concrete, shippable milestone.`,
+    criteria: ["A milestone shipped", "Outcome measured against the metric"],
+  }),
+  compound: (s) => ({
+    epic: `Systematise ${s.name}`,
+    task: `Codify what works in ${s.name} into a repeatable process and report outcomes against the KPI tree.`,
+    criteria: ["Process documented", "Outcomes reported"],
+  }),
+};
+
+/** Max org-context items pulled into the backlog so a huge org can't unbound it. */
+const MAX_ORG_STREAMS = 8;
+const MAX_FRONTIER_ITEMS = 8;
+
+function str(v) {
+  return v == null ? "" : String(v).trim();
+}
+
+/** Slugify a code/name into a stream-id-safe token (lowercase, dash-separated). */
+function slugToken(v) {
+  return str(v).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "x";
+}
+
+/**
+ * Build the standard 30/60/90 phase scaffold for a stream-like ({ id, name,
+ * intent }) from the per-horizon SEED templates. Extracted so archetype streams
+ * AND org-context strategy streams seed identically. Pure.
+ * @param {{id:string, name:string, intent?:string}} s
+ * @returns {object[]} phases
+ */
+function seedPhases(s) {
+  return PHASES.map((ph) => {
+    const seed = SEED[ph.horizon](s);
+    return {
+      id: ph.id,
+      name: ph.name,
+      epics: [
+        {
+          id: `${s.id}-${ph.id}-e1`,
+          title: seed.epic,
+          tasks: [
+            {
+              id: `${s.id}-${ph.id}-t1`,
+              title: seed.task,
+              next_action: seed.task,
+              priority: ph.id === "d30" ? "high" : "normal",
+              success_criteria: seed.criteria,
+            },
+          ],
+        },
+      ],
+    };
+  });
+}
+
+/** Normalise the org ready-board feed (array of objects or strings) to {title}. */
+function normFrontier(board) {
+  const arr = Array.isArray(board) ? board : [];
+  const out = [];
+  for (const b of arr) {
+    const title = typeof b === "string" ? str(b) : str(b && (b.title || b.name || b.summary));
+    if (title) out.push({ title });
+    if (out.length >= MAX_FRONTIER_ITEMS) break;
+  }
+  return out;
+}
+
+/**
+ * Distil the agent's cached Cohort org context (the `config/org-context.json`
+ * object `bootstrap-context.persistOrgContext` writes, or its distilled excerpt)
+ * into WBS streams so the FETCHED org context actually SHAPES the backlog —
+ * closing the audit gap "fetched org context shapes nothing: backlog".
+ *
+ * Produces, in priority order:
+ *   1. one stream PER org STRATEGY stream (`strategy.streams[]`): a real,
+ *      org-authored workstream (id from its code, intent = its mission, the org
+ *      north-star woven in as a fallback intent), seeded across 30/60/90 like any
+ *      archetype stream — so it flows through materializeReadyTasks unchanged.
+ *   2. a single "org-frontier" stream when the org's READY BOARD feed carries
+ *      items: each ready item becomes a concrete HIGH-priority d30 task, so the
+ *      agent starts on LITERAL org work rather than a generic template.
+ *
+ * Returns [] for a null/empty/standalone context (no strategy streams AND no
+ * board), so a non-enrolled agent's backlog is byte-for-byte unchanged. Pure.
+ *
+ * @param {object|null} orgContext config/org-context.json (or its excerpt)
+ * @returns {object[]} WBS streams
+ */
+export function orgContextStreams(orgContext) {
+  if (!orgContext || typeof orgContext !== "object") return [];
+  const strategy = orgContext.strategy && typeof orgContext.strategy === "object" ? orgContext.strategy : {};
+  const northStar = str(strategy.northStar || strategy.northstar);
+  const streamsIn = Array.isArray(strategy.streams) ? strategy.streams : [];
+
+  const out = [];
+  const seenIds = new Set();
+  for (const s of streamsIn) {
+    if (!s || typeof s !== "object") continue;
+    const code = str(s.code || s.id);
+    const name = str(s.name || s.code || s.id);
+    if (!code && !name) continue;
+    let id = `org-${slugToken(code || name)}`;
+    while (seenIds.has(id)) id = `${id}-x`;
+    seenIds.add(id);
+    const intent = str(s.mission || s.intent) || (northStar ? `Advance the org north star — ${northStar}` : "");
+    const streamLike = { id, name: name || code, intent };
+    out.push({ ...streamLike, source: "org-strategy", phases: seedPhases(streamLike) });
+    if (out.length >= MAX_ORG_STREAMS) break;
+  }
+
+  const frontier = normFrontier(orgContext.board);
+  if (frontier.length) {
+    const tasks = frontier.map((it, i) => ({
+      id: `org-frontier-d30-t${i + 1}`,
+      title: it.title,
+      next_action: it.title,
+      priority: "high",
+      success_criteria: ["Ready-board item picked up and progressed", "Outcome reported back to the org"],
+    }));
+    out.push({
+      id: "org-frontier",
+      name: "Org ready-board frontier",
+      intent: "Concrete work items pulled from the org's ready board — do these first.",
+      source: "org-board",
+      phases: [
+        { id: "d30", name: PHASES[0].name, epics: [{ id: "org-frontier-d30-e1", title: "Clear the org ready-board frontier", tasks }] },
+        { id: "d60", name: PHASES[1].name, epics: [] },
+        { id: "d90", name: PHASES[2].name, epics: [] },
+      ],
+    });
+  }
+
+  return out;
+}
+
+/**
+ * Build the WBS skeleton from a resolved profile + identity.
+ *
+ * When `opts.orgContext` is supplied (the cached Cohort org context from
+ * `config/org-context.json`), the org's authoritative strategy streams + ready
+ * board are distilled into LEADING backlog streams (see orgContextStreams), so
+ * an enrolled agent's backlog is shaped by the org — not just its archetype. A
+ * standalone agent (no orgContext) gets the archetype-only skeleton unchanged.
+ *
+ * @param {object} profile resolved archetype profile
+ * @param {object} identity config/agent.json
+ * @param {object} [opts] @param {string} [opts.date] @param {object} [opts.orgContext]
+ * @returns {object} wbs
+ */
+export function buildBacklogSkeleton(profile, identity, opts = {}) {
+  if (!profile || !identity) throw new Error("buildBacklogSkeleton: requires (profile, identity)");
+  const archetypeStreams = (profile.backlogStreams || []).map((s) => ({
+    id: s.id,
+    name: s.name,
+    intent: s.intent || "",
+    phases: seedPhases({ id: s.id, name: s.name, intent: s.intent || "" }),
+  }));
+
+  // The fetched org context leads: org strategy streams + ready-board frontier
+  // come first so materializeReadyTasks surfaces org work as the top priorities.
+  const orgStreams = orgContextStreams(opts.orgContext);
+  const streams = [...orgStreams, ...archetypeStreams];
+
+  return {
+    schemaVersion: 1,
+    agent: identity.fullName || "Unconfigured Agent",
+    archetype: `${profile.function}@${profile.altitude}`,
+    granularity: profile.backlogGranularity || "epics",
+    generated: opts.date || "",
+    note: orgStreams.length
+      ? "Seed skeleton shaped by the org context (strategy streams + ready board lead) — enrich with company-specific content at init, then materialise."
+      : "Seed skeleton — enrich epics/tasks with company-specific content at init, then materialise.",
+    ...(orgStreams.length ? { orgContextApplied: true } : {}),
+    streams,
+  };
+}
+
+/**
+ * Flatten the immediately-actionable (first-30-day) tasks into queue items in
+ * the shape the backlog-executor consumes, plus a strategic priorities list.
+ *
+ * @param {object} wbs @param {object} [opts] @param {string} [opts.owner] @param {string} [opts.date]
+ * @returns {{ queueItems: object[], priorities: object[] }}
+ */
+export function materializeReadyTasks(wbs, opts = {}) {
+  if (!wbs || !Array.isArray(wbs.streams)) throw new Error("materializeReadyTasks: invalid wbs");
+  const owner = opts.owner || "agent";
+  const date = opts.date || "";
+  const queueItems = [];
+  const priorities = [];
+
+  for (const s of wbs.streams) {
+    priorities.push({
+      id: s.id,
+      title: s.name,
+      description: s.intent,
+      streams: [s.id],
+      status: "active",
+    });
+    const d30 = (s.phases || []).find((p) => p.id === "d30");
+    if (!d30) continue;
+    for (const epic of d30.epics || []) {
+      for (const task of epic.tasks || []) {
+        queueItems.push({
+          id: `seed-${task.id}`,
+          title: task.title,
+          status: "open",
+          priority: task.priority || "normal",
+          stream: s.id,
+          epic: epic.id,
+          owner,
+          next_action: task.next_action || task.title,
+          context: `Seeded from the "${s.name}" stream (first-30-day objective). ${s.intent || ""}`.trim(),
+          success_criteria: task.success_criteria || [],
+          source: "backlog-seed",
+          created: date,
+          history: [],
+        });
+      }
+    }
+  }
+  return { queueItems, priorities };
+}
+
+/**
+ * Wrap materialised queue items into the state/queues/<name>.yaml file object.
+ * @param {object[]} queueItems @param {object} [opts] @param {string} [opts.queue]
+ * @returns {{ queue: string, description: string, items: object[] }}
+ */
+export function toQueueFile(queueItems, opts = {}) {
+  return {
+    queue: opts.queue || "backlog",
+    description: "Proactive backlog seeded at init from the archetype WBS. The backlog-executor works open items by priority.",
+    items: queueItems,
+  };
+}
+
+/**
+ * Parse a `state/queues/*.yaml` file body into the actionable-item shape the
+ * daemon's backlog sweep dispatches. Pure, dependency-free (mirrors the
+ * daemon's hand-rolled block parser so we stay aligned with the on-disk format
+ * written by setup + the agent's own work loop — no YAML dependency).
+ *
+ * Only `status: open` / `status: in_progress` items are returned; `blocked`
+ * items are excluded (matching the sweep's filter).
+ *
+ * F2 (state-integrity audit) regression: the daemon's inline `sweepBacklog`
+ * parser extracted title/priority/next_action but NEVER `id`, so every swept
+ * item had `qi.id === undefined`. That silently disabled the entire file-based
+ * item-claim subsystem — `hasActiveClaim(qi.id)` (agent-daemon.mjs),
+ * `claimItem(item.id, …)`, `releaseItemClaim`, and `markItemBlocked` are all
+ * gated on a defined id, so claims/blocks never engaged across restarts or
+ * concurrent triggers. This parser extracts `id` so those paths come alive.
+ * `sweepBacklog` should call this instead of its inline regex (see notes).
+ *
+ * @param {string} content raw YAML file body
+ * @param {string} sourceFile filename, recorded as `source_file` on each item
+ * @returns {Array<{ id?: string, title: string, status: string, priority: string, next_action: string, source_file: string, raw: string }>}
+ */
+export function parseQueueItems(content, sourceFile = "") {
+  const out = [];
+  if (typeof content !== "string" || content.length === 0) return out;
+
+  // Items are a YAML sequence; split on the `- ` sequence marker (multiline).
+  // Tolerate leading indentation — js-yaml (the real serializer) writes items
+  // indented under `items:` (`  - id: …`), and the agent's own work loop and
+  // markItemBlocked both handle indented dashes; matching only column-0 dashes
+  // would fold every indented item into one block and lose all but the first.
+  const blocks = content.split(/^\s*-\s+/m).filter(Boolean);
+  for (const itemBlock of blocks) {
+    // Strip comment lines so schema templates (e.g. "# id: string") never match.
+    const cleanBlock = itemBlock
+      .split("\n")
+      .filter((l) => !l.trimStart().startsWith("#"))
+      .join("\n");
+
+    // Match both quoted ("status":) and unquoted (status:) YAML keys. Each key
+    // is anchored to the START of a line (optional indent + an optional inline
+    // sequence dash) so a key is matched as a WHOLE key, never as the suffix of
+    // a longer one — e.g. `correlation_id:` / `message_id:` must NOT be read as
+    // `id:` (a confirmed mis-extraction). The `m` flag scopes `^`/`$` per line.
+    const statusMatch = cleanBlock.match(/^\s*-?\s*"?status"?:\s*["']?(open|in_progress)["']?/m);
+    const blockedMatch = cleanBlock.match(/^\s*-?\s*"?status"?:\s*["']?blocked["']?/m);
+    if (!statusMatch || blockedMatch) continue;
+
+    const idMatch = cleanBlock.match(/^\s*-?\s*"?id"?:\s*["']?([^"'\n]+?)["']?\s*$/m);
+    const titleMatch = cleanBlock.match(/^\s*-?\s*"?title"?:\s*["']?(.+?)["']?\s*$/m);
+    const priorityMatch = cleanBlock.match(/^\s*-?\s*"?priority"?:\s*["']?(critical|high|normal|low)["']?/m);
+    const nextActionMatch = cleanBlock.match(/^\s*-?\s*"?next_action"?:\s*["']?(.+?)["']?\s*$/m);
+    if (!titleMatch || !nextActionMatch) continue;
+
+    const item = {
+      title: titleMatch[1],
+      status: statusMatch[1],
+      priority: priorityMatch?.[1] || "normal",
+      next_action: nextActionMatch[1],
+      source_file: sourceFile,
+      raw: cleanBlock.substring(0, 500),
+    };
+    // Only attach id when one was actually present (legacy items may lack it);
+    // the claim subsystem keys on a defined id and tolerates undefined.
+    const id = idMatch?.[1]?.trim();
+    if (id) item.id = id;
+    out.push(item);
+  }
+  return out;
+}
+
+/** Count immediately-actionable (d30) tasks in a WBS. @param {object} wbs @returns {number} */
+export function countReadyTasks(wbs) {
+  if (!wbs || !Array.isArray(wbs.streams)) return 0;
+  let n = 0;
+  for (const s of wbs.streams) {
+    const d30 = (s.phases || []).find((p) => p.id === "d30");
+    for (const e of (d30 && d30.epics) || []) n += (e.tasks || []).length;
+  }
+  return n;
+}

package/lib/backlog.test.mjs

@@ -0,0 +1,266 @@
+/**
+ * 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);
+});