@cleocode/playbooks 2026.6.13 → 2026.6.14

package/src/__tests__/inputs-bindings.test.ts

@@ -0,0 +1,250 @@
+/**
+ * T1944 (M4 cantbook done-gate) — `PlaybookAgenticNode.inputs` →
+ * `AgentDispatchInput.bindings` wiring + mustache resolution at the dispatch
+ * boundary.
+ *
+ * Two layers of coverage:
+ *
+ *  1. Pure-unit tests of {@link resolveStepBindings} — precedence, shadowing,
+ *     dot-path resolution, and the lenient missing-key rule, exercised in
+ *     isolation with no DB.
+ *  2. In-process `executePlaybook` end-to-end — a `.cantbook`-equivalent node
+ *     with `inputs: { topic: '{{inputs.epicId}}' }` resolves and the bound
+ *     value reaches {@link AgentDispatchInput.bindings} at dispatch time.
+ *
+ * No `@cleocode/*` module is mocked — the resolver is the real canonical
+ * T1238 engine and the runtime runs against an in-memory `node:sqlite` DB.
+ *
+ * @task T1944 — wire PlaybookAgenticNode.inputs → AgentDispatchInput.bindings
+ */
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import type { DatabaseSync as _DatabaseSyncType } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import type { PlaybookAgenticNode, PlaybookDefinition } from '@cleocode/contracts';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  type AgentDispatcher,
+  type AgentDispatchInput,
+  type AgentDispatchResult,
+  executePlaybook,
+  resolveStepBindings,
+} from '../runtime.js';
+
+const _require = createRequire(import.meta.url);
+type DatabaseSync = _DatabaseSyncType;
+const { DatabaseSync } = _require('node:sqlite') as {
+  DatabaseSync: new (...args: ConstructorParameters<typeof _DatabaseSyncType>) => DatabaseSync;
+};
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATION_SQL = resolve(
+  __dirname,
+  '../../../core/migrations/drizzle-tasks/20260417220000_t889-playbook-tables/migration.sql',
+);
+
+function applyMigration(db: DatabaseSync, sql: string): void {
+  const statements = sql
+    .split(/--> statement-breakpoint/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    const lines = stmt.split('\n');
+    const hasSql = lines.some((l) => l.trim().length > 0 && !l.trim().startsWith('--'));
+    if (hasSql) db.exec(stmt);
+  }
+}
+
+function agenticNode(
+  id: string,
+  overrides: Partial<PlaybookAgenticNode> = {},
+): PlaybookAgenticNode {
+  return { id, type: 'agentic', skill: `skill-${id}`, ...overrides };
+}
+
+/** Dispatcher that records the full {@link AgentDispatchInput} per call. */
+function makeBindingRecorder(
+  handler: (input: AgentDispatchInput) => AgentDispatchResult,
+): AgentDispatcher & { calls: AgentDispatchInput[] } {
+  const calls: AgentDispatchInput[] = [];
+  return {
+    calls,
+    async dispatch(input: AgentDispatchInput): Promise<AgentDispatchResult> {
+      // Snapshot bindings/context so later mutation cannot taint the assertion.
+      calls.push({
+        ...input,
+        context: { ...input.context },
+        bindings: input.bindings === undefined ? undefined : { ...input.bindings },
+      });
+      return handler(input);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// resolveStepBindings — pure unit
+// ---------------------------------------------------------------------------
+
+describe('T1944: resolveStepBindings (pure)', () => {
+  it('AC5: resolves a {{inputs.epicId}} template from the run context', () => {
+    const node = agenticNode('research', { inputs: { topic: '{{inputs.epicId}}' } });
+    const context = { inputs: { epicId: 'T1942' } };
+
+    const bound = resolveStepBindings(node, context);
+
+    expect(bound['topic']).toBe('T1942');
+    // Original context keys remain present.
+    expect(bound['inputs']).toEqual({ epicId: 'T1942' });
+  });
+
+  it('AC5: resolves a flat {{epicId}} single-segment template', () => {
+    const node = agenticNode('research', { inputs: { topic: '{{epicId}}' } });
+    const bound = resolveStepBindings(node, { epicId: 'T1942' });
+    expect(bound['topic']).toBe('T1942');
+  });
+
+  it('AC6: step bindings shadow playbook bindings for the same key', () => {
+    // The run context already carries `topic`; the step input MUST win.
+    const node = agenticNode('research', { inputs: { topic: '{{inputs.epicId}}' } });
+    const context = { topic: 'stale-context-value', inputs: { epicId: 'T1942' } };
+
+    const bound = resolveStepBindings(node, context);
+
+    expect(bound['topic']).toBe('T1942');
+    expect(bound['topic']).not.toBe('stale-context-value');
+  });
+
+  it('missing-key rule: unresolved {{path}} is left as a literal placeholder', () => {
+    const node = agenticNode('research', { inputs: { topic: '{{inputs.nope}}' } });
+    const bound = resolveStepBindings(node, { inputs: { epicId: 'T1942' } });
+    expect(bound['topic']).toBe('{{inputs.nope}}');
+  });
+
+  it('resolves dot-path nesting deeper than one level', () => {
+    const node = agenticNode('research', { inputs: { fw: '{{project.testing.framework}}' } });
+    const bound = resolveStepBindings(node, {
+      project: { testing: { framework: 'vitest' } },
+    });
+    expect(bound['fw']).toBe('vitest');
+  });
+
+  it('passes literal (non-template) input values through unchanged', () => {
+    const node = agenticNode('research', { inputs: { mode: 'fast' } });
+    const bound = resolveStepBindings(node, { x: 1 });
+    expect(bound['mode']).toBe('fast');
+  });
+
+  it('returns a shallow copy of context when the node declares no inputs', () => {
+    const node = agenticNode('research');
+    const context = { taskId: 'T123', a: 1 };
+    const bound = resolveStepBindings(node, context);
+    expect(bound).toEqual(context);
+    expect(bound).not.toBe(context);
+  });
+
+  it('returns a shallow copy of context for an empty inputs map', () => {
+    const node = agenticNode('research', { inputs: {} });
+    const context = { taskId: 'T123' };
+    expect(resolveStepBindings(node, context)).toEqual(context);
+  });
+
+  it('does not mutate the source context', () => {
+    const node = agenticNode('research', { inputs: { topic: '{{epicId}}' } });
+    const context = { epicId: 'T1942' };
+    resolveStepBindings(node, context);
+    expect(context).toEqual({ epicId: 'T1942' });
+    expect(context).not.toHaveProperty('topic');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// executePlaybook — bindings reach the dispatch boundary (in-process e2e)
+// ---------------------------------------------------------------------------
+
+describe('T1944: AgentDispatchInput.bindings (in-process)', () => {
+  let db: DatabaseSync;
+
+  beforeEach(() => {
+    db = new DatabaseSync(':memory:');
+    db.exec('PRAGMA foreign_keys=ON');
+    applyMigration(db, readFileSync(MIGRATION_SQL, 'utf8'));
+  });
+  afterEach(() => db.close());
+
+  it('AC2: resolved step input reaches AgentDispatchInput.bindings at dispatch', async () => {
+    const playbook: PlaybookDefinition = {
+      version: '1.0',
+      name: 'inputs-bindings',
+      nodes: [agenticNode('research', { inputs: { topic: '{{inputs.epicId}}' } })],
+      edges: [],
+    };
+    const dispatcher = makeBindingRecorder(() => ({ status: 'success', output: {} }));
+
+    const result = await executePlaybook({
+      db,
+      playbook,
+      playbookHash: 'hash-t1944',
+      initialContext: { inputs: { epicId: 'T1942' } },
+      dispatcher,
+    });
+
+    expect(result.terminalStatus).toBe('completed');
+    expect(dispatcher.calls).toHaveLength(1);
+    // The resolved binding (NOT the raw template) reaches the dispatcher.
+    expect(dispatcher.calls[0]?.bindings?.['topic']).toBe('T1942');
+    // The raw accumulated context still carries the source object.
+    expect(dispatcher.calls[0]?.context['inputs']).toEqual({ epicId: 'T1942' });
+  });
+
+  it('AC2: bindings is always populated even when the node declares no inputs', async () => {
+    const playbook: PlaybookDefinition = {
+      version: '1.0',
+      name: 'no-inputs',
+      nodes: [agenticNode('plain')],
+      edges: [],
+    };
+    const dispatcher = makeBindingRecorder(() => ({ status: 'success', output: {} }));
+
+    await executePlaybook({
+      db,
+      playbook,
+      playbookHash: 'hash-t1944-b',
+      initialContext: { taskId: 'T123' },
+      dispatcher,
+    });
+
+    expect(dispatcher.calls[0]?.bindings).toMatchObject({ taskId: 'T123' });
+  });
+
+  it('AC6: step binding shadows a same-named accumulated context key end-to-end', async () => {
+    // Node `a` emits `topic`; node `b` declares an `inputs.topic` template that
+    // MUST shadow the inherited context value when dispatched.
+    const playbook: PlaybookDefinition = {
+      version: '1.0',
+      name: 'shadowing',
+      nodes: [agenticNode('a'), agenticNode('b', { inputs: { topic: '{{inputs.epicId}}' } })],
+      edges: [{ from: 'a', to: 'b' }],
+    };
+    const dispatcher = makeBindingRecorder((input) =>
+      input.nodeId === 'a'
+        ? { status: 'success', output: { topic: 'from-node-a' } }
+        : { status: 'success', output: {} },
+    );
+
+    await executePlaybook({
+      db,
+      playbook,
+      playbookHash: 'hash-t1944-c',
+      initialContext: { inputs: { epicId: 'T1942' } },
+      dispatcher,
+    });
+
+    const callB = dispatcher.calls.find((c) => c.nodeId === 'b');
+    // Accumulated context still has node-a's value...
+    expect(callB?.context['topic']).toBe('from-node-a');
+    // ...but the step binding shadows it.
+    expect(callB?.bindings?.['topic']).toBe('T1942');
+  });
+});

package/src/__tests__/node-allowlist.test.ts

@@ -0,0 +1,186 @@
+/**
+ * T1947 (M4 cantbook done-gate, Gap E/F) — `PlaybookAgenticNode.allowed_skills`
+ * / `.allowed_tools` are parsed (AC1) and reach the dispatch boundary as
+ * `AgentDispatchInput.allowedSkills` / `.allowedTools` (AC5) so the dispatcher
+ * can intersect them against the Tier-0/1/2 baseline at spawn time.
+ *
+ * Two layers:
+ *  1. Parser → runtime forwarding: a `.cantbook` node with `allowed_skills:` /
+ *     `allowed_tools:` is parsed and the lists reach {@link AgentDispatchInput}
+ *     at dispatch time — asserted with a recorder dispatcher (no live backend).
+ *  2. Default (un-restricted) nodes carry NO allowlist — the dispatch path is
+ *     unchanged (additive).
+ *
+ * The intersection enforcement itself lives in `@cleocode/core`'s
+ * `composeSpawnPayload` and is covered by `spawn.test.ts`; this suite proves the
+ * runtime hands the allowlists to the dispatcher so that enforcement can occur.
+ * No `@cleocode/*` module is mocked.
+ *
+ * @task T1947
+ */
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import type { DatabaseSync as _DatabaseSyncType } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { parsePlaybook } from '../parser.js';
+import {
+  type AgentDispatcher,
+  type AgentDispatchInput,
+  type AgentDispatchResult,
+  executePlaybook,
+} from '../runtime.js';
+
+const _require = createRequire(import.meta.url);
+type DatabaseSync = _DatabaseSyncType;
+const { DatabaseSync } = _require('node:sqlite') as {
+  DatabaseSync: new (...args: ConstructorParameters<typeof _DatabaseSyncType>) => DatabaseSync;
+};
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATION_SQL = resolve(
+  __dirname,
+  '../../../core/migrations/drizzle-tasks/20260417220000_t889-playbook-tables/migration.sql',
+);
+
+function applyMigration(db: DatabaseSync, sql: string): void {
+  const statements = sql
+    .split(/--> statement-breakpoint/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    const lines = stmt.split('\n');
+    const hasSql = lines.some((l) => l.trim().length > 0 && !l.trim().startsWith('--'));
+    if (hasSql) db.exec(stmt);
+  }
+}
+
+/** Records the full {@link AgentDispatchInput} per call. */
+function makeRecorder(): AgentDispatcher & { calls: AgentDispatchInput[] } {
+  const calls: AgentDispatchInput[] = [];
+  return {
+    calls,
+    async dispatch(input: AgentDispatchInput): Promise<AgentDispatchResult> {
+      calls.push({ ...input, context: { ...input.context } });
+      return { status: 'success', output: {} };
+    },
+  };
+}
+
+describe('T1947: AC1 — parser accepts allowed_skills / allowed_tools', () => {
+  it('parses string[] allowlists onto the agentic node', () => {
+    const yaml = `
+version: "1.0"
+name: gated-flow
+nodes:
+  - id: review
+    type: agentic
+    skill: ct-validator
+    allowed_skills: [ct-validator, ct-cleo]
+    allowed_tools: [Read, Grep]
+`;
+    const { definition } = parsePlaybook(yaml);
+    const node = definition.nodes[0];
+    expect(node?.type).toBe('agentic');
+    if (node?.type !== 'agentic') throw new Error('expected agentic node');
+    expect(node.allowed_skills).toEqual(['ct-validator', 'ct-cleo']);
+    expect(node.allowed_tools).toEqual(['Read', 'Grep']);
+  });
+
+  it('omits both fields when the node declares neither (additive)', () => {
+    const yaml = `
+version: "1.0"
+name: plain-flow
+nodes:
+  - id: research
+    type: agentic
+    skill: ct-research-agent
+`;
+    const { definition } = parsePlaybook(yaml);
+    const node = definition.nodes[0];
+    if (node?.type !== 'agentic') throw new Error('expected agentic node');
+    expect(node.allowed_skills).toBeUndefined();
+    expect(node.allowed_tools).toBeUndefined();
+  });
+
+  it('rejects a non-string entry in allowed_skills', () => {
+    const yaml = `
+version: "1.0"
+name: bad-flow
+nodes:
+  - id: review
+    type: agentic
+    skill: ct-validator
+    allowed_skills: [ct-validator, 42]
+`;
+    expect(() => parsePlaybook(yaml)).toThrow(/allowed_skills/);
+  });
+});
+
+describe('T1947: AC5 — allowlists reach the dispatch boundary', () => {
+  let db: DatabaseSync;
+
+  beforeEach(() => {
+    db = new DatabaseSync(':memory:');
+    db.exec('PRAGMA foreign_keys=ON');
+    applyMigration(db, readFileSync(MIGRATION_SQL, 'utf8'));
+  });
+  afterEach(() => db.close());
+
+  it('forwards allowed_skills/allowed_tools as allowedSkills/allowedTools', async () => {
+    const yaml = `
+version: "1.0"
+name: gated-flow
+nodes:
+  - id: review
+    type: agentic
+    skill: ct-validator
+    allowed_skills: [ct-validator]
+    allowed_tools: [Read, Grep]
+`;
+    const { definition } = parsePlaybook(yaml);
+    const dispatcher = makeRecorder();
+
+    const result = await executePlaybook({
+      db,
+      playbook: definition,
+      playbookHash: 'hash-t1947',
+      initialContext: { taskId: 'T1947' },
+      dispatcher,
+    });
+
+    expect(result.terminalStatus).toBe('completed');
+    expect(dispatcher.calls).toHaveLength(1);
+    const call = dispatcher.calls[0];
+    expect(call?.nodeId).toBe('review');
+    expect(call?.allowedSkills).toEqual(['ct-validator']);
+    expect(call?.allowedTools).toEqual(['Read', 'Grep']);
+  });
+
+  it('an un-restricted stage carries NO allowedSkills/allowedTools (additive)', async () => {
+    const yaml = `
+version: "1.0"
+name: plain-flow
+nodes:
+  - id: research
+    type: agentic
+    skill: ct-research-agent
+`;
+    const { definition } = parsePlaybook(yaml);
+    const dispatcher = makeRecorder();
+
+    await executePlaybook({
+      db,
+      playbook: definition,
+      playbookHash: 'hash-t1947-b',
+      initialContext: { taskId: 'T123' },
+      dispatcher,
+    });
+
+    const call = dispatcher.calls[0];
+    expect(call?.allowedSkills).toBeUndefined();
+    expect(call?.allowedTools).toBeUndefined();
+  });
+});

package/src/__tests__/node-profile.test.ts

@@ -0,0 +1,142 @@
+/**
+ * T11759 (M4 cantbook done-gate) — `PlaybookAgenticNode.profile` / `.model` /
+ * `.provider` reach the dispatch boundary so a cantbook stage can pin its LLM.
+ *
+ * Two layers:
+ *  1. Parser → runtime forwarding: a `.cantbook` node with `profile:` is parsed
+ *     and the pin reaches {@link AgentDispatchInput} (with `playbookName`) at
+ *     dispatch time — asserted with a recorder dispatcher (no live backend).
+ *  2. Default (un-pinned) nodes carry NO pin — the dispatch path is unchanged.
+ *
+ * The dispatcher's E9 resolution itself (cantbook system key + profile pin) is
+ * covered in-process by `@cleocode/core`'s `cantbook-profile.test.ts`; this
+ * suite proves the runtime hands the pin to the dispatcher so that resolution
+ * can occur. No `@cleocode/*` module is mocked.
+ *
+ * @task T11759
+ */
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import type { DatabaseSync as _DatabaseSyncType } from 'node:sqlite';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { parsePlaybook } from '../parser.js';
+import {
+  type AgentDispatcher,
+  type AgentDispatchInput,
+  type AgentDispatchResult,
+  executePlaybook,
+} from '../runtime.js';
+
+const _require = createRequire(import.meta.url);
+type DatabaseSync = _DatabaseSyncType;
+const { DatabaseSync } = _require('node:sqlite') as {
+  DatabaseSync: new (...args: ConstructorParameters<typeof _DatabaseSyncType>) => DatabaseSync;
+};
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const MIGRATION_SQL = resolve(
+  __dirname,
+  '../../../core/migrations/drizzle-tasks/20260417220000_t889-playbook-tables/migration.sql',
+);
+
+function applyMigration(db: DatabaseSync, sql: string): void {
+  const statements = sql
+    .split(/--> statement-breakpoint/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    const lines = stmt.split('\n');
+    const hasSql = lines.some((l) => l.trim().length > 0 && !l.trim().startsWith('--'));
+    if (hasSql) db.exec(stmt);
+  }
+}
+
+/** Records the full {@link AgentDispatchInput} per call. */
+function makeRecorder(): AgentDispatcher & { calls: AgentDispatchInput[] } {
+  const calls: AgentDispatchInput[] = [];
+  return {
+    calls,
+    async dispatch(input: AgentDispatchInput): Promise<AgentDispatchResult> {
+      calls.push({ ...input, context: { ...input.context } });
+      return { status: 'success', output: {} };
+    },
+  };
+}
+
+describe('T11759: node profile pin reaches the dispatch boundary', () => {
+  let db: DatabaseSync;
+
+  beforeEach(() => {
+    db = new DatabaseSync(':memory:');
+    db.exec('PRAGMA foreign_keys=ON');
+    applyMigration(db, readFileSync(MIGRATION_SQL, 'utf8'));
+  });
+  afterEach(() => db.close());
+
+  it('AC3: a `.cantbook` stage with `profile:` forwards the pin + playbookName', async () => {
+    const yaml = `
+version: "1.0"
+name: pinned-flow
+nodes:
+  - id: review
+    type: agentic
+    skill: ct-validator
+    profile: frontier-review
+    model: claude-opus-4-8
+    provider: anthropic
+`;
+    const { definition } = parsePlaybook(yaml);
+    const dispatcher = makeRecorder();
+
+    const result = await executePlaybook({
+      db,
+      playbook: definition,
+      playbookHash: 'hash-t11759',
+      initialContext: { taskId: 'T11759' },
+      dispatcher,
+    });
+
+    expect(result.terminalStatus).toBe('completed');
+    expect(dispatcher.calls).toHaveLength(1);
+    const call = dispatcher.calls[0];
+    // The cantbook node identity reaches the dispatcher so it can build the
+    // `cantbook:<playbook>#<nodeId>` system key (AC2 resolution input).
+    expect(call?.playbookName).toBe('pinned-flow');
+    expect(call?.nodeId).toBe('review');
+    // The per-stage LLM pin is forwarded verbatim (the dispatcher resolves it
+    // through `resolveCantbookNodeProfile` → E9).
+    expect(call?.profile).toBe('frontier-review');
+    expect(call?.model).toBe('claude-opus-4-8');
+    expect(call?.provider).toBe('anthropic');
+  });
+
+  it('AC3: an un-pinned stage carries NO profile/model/provider (additive)', async () => {
+    const yaml = `
+version: "1.0"
+name: plain-flow
+nodes:
+  - id: research
+    type: agentic
+    skill: ct-research-agent
+`;
+    const { definition } = parsePlaybook(yaml);
+    const dispatcher = makeRecorder();
+
+    await executePlaybook({
+      db,
+      playbook: definition,
+      playbookHash: 'hash-t11759-b',
+      initialContext: { taskId: 'T123' },
+      dispatcher,
+    });
+
+    const call = dispatcher.calls[0];
+    expect(call?.playbookName).toBe('plain-flow');
+    expect(call?.profile).toBeUndefined();
+    expect(call?.model).toBeUndefined();
+    expect(call?.provider).toBeUndefined();
+  });
+});

package/src/__tests__/parser.test.ts

@@ -340,6 +340,86 @@ nodes:
     });
   });
 
+  describe('T11759: agentic node LLM profile pin', () => {
+    it('AC1: parses profile/model/provider on an agentic node', () => {
+      const yaml = `
+version: "1.0"
+name: pinned
+nodes:
+  - id: review
+    type: agentic
+    skill: ct-validator
+    profile: frontier-review
+    model: claude-opus-4-8
+    provider: anthropic
+`;
+      const { definition } = parsePlaybook(yaml);
+      expect(definition.nodes[0]).toMatchObject({
+        id: 'review',
+        type: 'agentic',
+        profile: 'frontier-review',
+        model: 'claude-opus-4-8',
+        provider: 'anthropic',
+      });
+    });
+
+    it('AC1: omits profile/model/provider when not declared (additive)', () => {
+      const yaml = `
+version: "1.0"
+name: unpinned
+nodes:
+  - id: plain
+    type: agentic
+    skill: ct-research-agent
+`;
+      const node = parsePlaybook(yaml).definition.nodes[0];
+      expect(node).not.toHaveProperty('profile');
+      expect(node).not.toHaveProperty('model');
+      expect(node).not.toHaveProperty('provider');
+    });
+
+    it('AC1: a profile-only pin is valid', () => {
+      const yaml = `
+version: "1.0"
+name: profile-only
+nodes:
+  - id: stage
+    type: agentic
+    skill: ct-task-executor
+    profile: fast-lane
+`;
+      const node = parsePlaybook(yaml).definition.nodes[0];
+      expect(node).toMatchObject({ profile: 'fast-lane' });
+      expect(node).not.toHaveProperty('model');
+    });
+
+    it('AC1: rejects an empty-string profile', () => {
+      const yaml = `
+version: "1.0"
+name: bad-profile
+nodes:
+  - id: stage
+    type: agentic
+    skill: ct-task-executor
+    profile: ""
+`;
+      expect(() => parsePlaybook(yaml)).toThrow(/profile must be a non-empty string/);
+    });
+
+    it('AC1: rejects a non-string model', () => {
+      const yaml = `
+version: "1.0"
+name: bad-model
+nodes:
+  - id: stage
+    type: agentic
+    skill: ct-task-executor
+    model: 42
+`;
+      expect(() => parsePlaybook(yaml)).toThrow(/model must be a non-empty string/);
+    });
+  });
+
   describe('bounds checks', () => {
     it('rejects max_iterations > 10', () => {
       const yaml = `