@substrate-ai/factory 0.19.54

package/dist/graph/__tests__/attractor-compliance.test.js

@@ -0,0 +1,766 @@
+/**
+ * Spec compliance tests for the Attractor graph engine.
+ *
+ * Replays pseudocode examples from the Attractor spec through
+ * selectEdge(), evaluateGates(), and checkpoint resume APIs.
+ *
+ * Story 42-17.
+ */
+// AttractorBench structural conformance parity — Phase A mandatory
+// See: https://github.com/strongdm/attractorbench
+// Behavioral conformance tests are advisory in Phase A; required by Phase B exit.
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import os from 'node:os';
+import path from 'node:path';
+import { mkdir, rm } from 'node:fs/promises';
+import crypto from 'node:crypto';
+import { selectEdge } from '../edge-selector.js';
+import { createConvergenceController } from '../../convergence/controller.js';
+import { CheckpointManager } from '../checkpoint.js';
+import { createGraphExecutor } from '../executor.js';
+import { createValidator } from '../validator.js';
+import { parseGraph } from '../parser.js';
+import { GraphContext } from '../context.js';
+// ---------------------------------------------------------------------------
+// DOT fixture for resume/fidelity tests (spec Section 5.3)
+// ---------------------------------------------------------------------------
+const COMPLIANCE_RESUME_DOT = `
+digraph compliance_resume {
+  graph [goal="Resume compliance test"]
+  start [shape=Mdiamond]
+  node1 [type=codergen, prompt="Step 1"]
+  node2 [type=codergen, prompt="Step 2"]
+  exit [shape=Msquare]
+
+  start -> node1
+  node1 -> node2
+  node2 -> exit
+}
+`;
+const COMPLIANCE_FIDELITY_RESUME_DOT = `
+digraph compliance_fidelity_resume {
+  graph [goal="Fidelity degradation test"]
+  start [shape=Mdiamond]
+  node1 [type=codergen, prompt="Step 1", fidelity=full]
+  node2 [type=codergen, prompt="Step 2"]
+  exit [shape=Msquare]
+
+  start -> node1
+  node1 -> node2
+  node2 -> exit
+}
+`;
+// ---------------------------------------------------------------------------
+// Shared helper factories
+// ---------------------------------------------------------------------------
+/** A node with all required fields at sensible defaults. */
+const MINIMAL_NODE = {
+    id: '',
+    label: '',
+    shape: 'box',
+    type: 'codergen',
+    prompt: '',
+    maxRetries: 0,
+    goalGate: false,
+    retryTarget: '',
+    fallbackRetryTarget: '',
+    fidelity: '',
+    threadId: '',
+    class: '',
+    timeout: 0,
+    llmModel: '',
+    llmProvider: '',
+    reasoningEffort: '',
+    autoStatus: false,
+    allowPartial: false,
+    toolCommand: '',
+    backend: '',
+};
+function makeNode(id, overrides) {
+    return { ...MINIMAL_NODE, id, ...overrides };
+}
+function makeEdge(fromNode, toNode, overrides) {
+    return {
+        fromNode,
+        toNode,
+        label: '',
+        condition: '',
+        weight: 0,
+        fidelity: '',
+        threadId: '',
+        loopRestart: false,
+        ...overrides,
+    };
+}
+/**
+ * Build a minimal Graph conforming to the Graph interface.
+ * startNodeId / exitNodeId control which nodes serve as start/exit.
+ */
+function makeGraph(nodes, edges, startNodeId, exitNodeId) {
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    const resolveStart = () => {
+        if (startNodeId)
+            return nodeMap.get(startNodeId);
+        for (const n of nodeMap.values()) {
+            if (n.shape === 'Mdiamond')
+                return n;
+        }
+        throw new Error('No start node');
+    };
+    const resolveExit = () => {
+        if (exitNodeId)
+            return nodeMap.get(exitNodeId);
+        for (const n of nodeMap.values()) {
+            if (n.shape === 'Msquare')
+                return n;
+        }
+        throw new Error('No exit node');
+    };
+    return {
+        id: '',
+        goal: '',
+        label: '',
+        modelStylesheet: '',
+        defaultMaxRetries: 0,
+        retryTarget: '',
+        fallbackRetryTarget: '',
+        defaultFidelity: '',
+        nodes: nodeMap,
+        edges,
+        outgoingEdges: (nodeId) => edges.filter((e) => e.fromNode === nodeId),
+        startNode: resolveStart,
+        exitNode: resolveExit,
+    };
+}
+/** Build a Graph with only the minimal start/exit structure for lint-rule tests. */
+function makeLintGraph(extraNodes, extraEdges, overrides) {
+    const baseNodes = [
+        makeNode('start', { shape: 'Mdiamond', type: '' }),
+        makeNode('exit', { shape: 'Msquare', type: '' }),
+        ...extraNodes.map((n) => makeNode(n.id, n)),
+    ];
+    const baseEdges = extraEdges.map((e) => makeEdge(e.fromNode, e.toNode, {
+        condition: e.condition ?? '',
+        loopRestart: e.loopRestart ?? false,
+    }));
+    const nodeMap = new Map(baseNodes.map((n) => [n.id, n]));
+    return {
+        id: 'test',
+        goal: '',
+        label: '',
+        modelStylesheet: overrides?.modelStylesheet ?? '',
+        defaultMaxRetries: 0,
+        retryTarget: overrides?.retryTarget ?? '',
+        fallbackRetryTarget: overrides?.fallbackRetryTarget ?? '',
+        defaultFidelity: '',
+        nodes: nodeMap,
+        edges: baseEdges,
+        outgoingEdges: (nodeId) => baseEdges.filter((e) => e.fromNode === nodeId),
+        startNode: () => nodeMap.get('start'),
+        exitNode: () => nodeMap.get('exit'),
+    };
+}
+/** Build a mock IHandlerRegistry that resolves every node via the given handler factory. */
+function makeRegistry(handlerFactory, statusOverride) {
+    return {
+        register: vi.fn(),
+        registerShape: vi.fn(),
+        setDefault: vi.fn(),
+        resolve: vi.fn().mockImplementation(() => async (node, ctx) => {
+            handlerFactory(node, ctx);
+            return { status: statusOverride ?? 'SUCCESS' };
+        }),
+    };
+}
+/** Build a mock TypedEventBus that captures all emitted events. */
+function makeEventBus() {
+    const nodeStartedIds = [];
+    const bus = {
+        emit: vi.fn().mockImplementation((event, payload) => {
+            if (event === 'graph:node-started') {
+                nodeStartedIds.push(payload.nodeId);
+            }
+        }),
+        on: vi.fn(),
+        off: vi.fn(),
+    };
+    return { bus, nodeStartedIds: () => [...nodeStartedIds] };
+}
+// ---------------------------------------------------------------------------
+// Task 2: Edge selection compliance — spec Section 3.3
+// ---------------------------------------------------------------------------
+describe('selectEdge compliance — spec Section 3.3', () => {
+    // Step 1: Condition-matched edges beat weight
+    it('AC1 — Step 1: condition match returns conditional edge over high-weight unconditional', async () => {
+        const node = makeNode('origin');
+        const condEdge = makeEdge('origin', 'dest-conditional', { condition: 'outcome=success', weight: 0 });
+        const unconEdge = makeEdge('origin', 'dest-unconditional', { weight: 10 });
+        const graph = makeGraph([node], [condEdge, unconEdge]);
+        const ctx = new GraphContext({ outcome: 'success' });
+        const outcome = { status: 'SUCCESS' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(condEdge);
+    });
+    it('AC1 variant — Step 1: no condition match falls through to Step 4 (weight)', async () => {
+        const node = makeNode('origin');
+        const condEdge = makeEdge('origin', 'dest-conditional', { condition: 'outcome=success', weight: 0 });
+        const unconEdge = makeEdge('origin', 'dest-unconditional', { weight: 10 });
+        const graph = makeGraph([node], [condEdge, unconEdge]);
+        const ctx = new GraphContext({ outcome: 'failure' });
+        const outcome = { status: 'SUCCESS' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(unconEdge);
+    });
+    // Step 2: Preferred label with accelerator prefix stripping
+    it('AC2 — Step 2: [Y] prefix stripped, label matches preferredLabel "yes"', async () => {
+        const node = makeNode('origin');
+        const yesEdge = makeEdge('origin', 'yes-target', { label: '[Y] Yes' });
+        const noEdge = makeEdge('origin', 'no-target', { label: 'No' });
+        const graph = makeGraph([node], [yesEdge, noEdge]);
+        const ctx = new GraphContext();
+        const outcome = { status: 'SUCCESS', preferredLabel: 'yes' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(yesEdge);
+    });
+    it('AC2 variant — Step 2: Y) prefix stripped, label matches preferredLabel "confirm"', async () => {
+        const node = makeNode('origin');
+        const confirmEdge = makeEdge('origin', 'confirm-target', { label: 'Y) Confirm' });
+        const otherEdge = makeEdge('origin', 'other-target', { label: 'Cancel' });
+        const graph = makeGraph([node], [confirmEdge, otherEdge]);
+        const ctx = new GraphContext();
+        const outcome = { status: 'SUCCESS', preferredLabel: 'confirm' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(confirmEdge);
+    });
+    // Step 3: Suggested next IDs
+    it('Step 3: suggestedNextIds matches edge target', async () => {
+        const node = makeNode('origin');
+        const edgeA = makeEdge('origin', 'a');
+        const edgeB = makeEdge('origin', 'b');
+        const edgeC = makeEdge('origin', 'c');
+        const graph = makeGraph([node], [edgeA, edgeB, edgeC]);
+        const ctx = new GraphContext();
+        const outcome = { status: 'SUCCESS', suggestedNextIds: ['b'] };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(edgeB);
+    });
+    // Steps 4 & 5: Weight with lexical tiebreak
+    it('AC3 — Steps 4&5: weight 5 tie between charlie and alpha → lexically-first alpha wins', async () => {
+        const node = makeNode('origin');
+        const charlieEdge = makeEdge('origin', 'charlie', { weight: 5 });
+        const alphaEdge = makeEdge('origin', 'alpha', { weight: 5 });
+        const bravoEdge = makeEdge('origin', 'bravo', { weight: 3 });
+        const graph = makeGraph([node], [charlieEdge, alphaEdge, bravoEdge]);
+        const ctx = new GraphContext();
+        const outcome = { status: 'SUCCESS' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBe(alphaEdge);
+        expect(selected?.toNode).toBe('alpha');
+    });
+    // Empty edges
+    it('empty edges: no outgoing edges → returns null', async () => {
+        const node = makeNode('origin');
+        const graph = makeGraph([node], []);
+        const ctx = new GraphContext();
+        const outcome = { status: 'SUCCESS' };
+        const selected = await selectEdge(node, outcome, ctx, graph);
+        expect(selected).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 3: Goal gate compliance — spec Section 3.4
+// ---------------------------------------------------------------------------
+describe('evaluateGates compliance — spec Section 3.4', () => {
+    it('SUCCESS satisfies a goalGate=true node', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('nodeA', 'SUCCESS');
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result).toEqual({ satisfied: true, failingNodes: [] });
+    });
+    it('AC4 — PARTIAL_SUCCESS satisfies a goalGate=true node (spec Section 3.4)', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('nodeA', 'PARTIAL_SUCCESS');
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result).toEqual({ satisfied: true, failingNodes: [] });
+    });
+    it('AC4 — FAILURE does not satisfy goalGate=true node, appears in failingNodes', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('nodeA', 'FAILURE');
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result.satisfied).toBe(false);
+        expect(result.failingNodes).toContain('nodeA');
+    });
+    it('AC4 — Unrecorded outcome (never executed) fails gate', () => {
+        const controller = createConvergenceController();
+        // nodeA has no recorded outcome
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result.satisfied).toBe(false);
+        expect(result.failingNodes).toContain('nodeA');
+    });
+    it('AC4 — PARTIAL_SUCCESS satisfies; FAILURE and unrecorded both fail', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('partial', 'PARTIAL_SUCCESS');
+        controller.recordOutcome('failing', 'FAILURE');
+        // 'unrecorded' has no recorded outcome
+        const graph = makeGraph([
+            makeNode('partial', { goalGate: true }),
+            makeNode('failing', { goalGate: true }),
+            makeNode('unrecorded', { goalGate: true }),
+        ], []);
+        const result = controller.evaluateGates(graph);
+        expect(result.satisfied).toBe(false);
+        expect(result.failingNodes).toContain('failing');
+        expect(result.failingNodes).toContain('unrecorded');
+        expect(result.failingNodes).not.toContain('partial');
+    });
+    it('mixed SUCCESS + PARTIAL_SUCCESS: both satisfied → { satisfied: true, failingNodes: [] }', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('nodeA', 'SUCCESS');
+        controller.recordOutcome('nodeB', 'PARTIAL_SUCCESS');
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true }), makeNode('nodeB', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result).toEqual({ satisfied: true, failingNodes: [] });
+    });
+    it('mixed SUCCESS + FAILURE: only failing node in failingNodes', () => {
+        const controller = createConvergenceController();
+        controller.recordOutcome('nodeA', 'SUCCESS');
+        controller.recordOutcome('nodeB', 'FAILURE');
+        const graph = makeGraph([makeNode('nodeA', { goalGate: true }), makeNode('nodeB', { goalGate: true })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result.satisfied).toBe(false);
+        expect(result.failingNodes).toEqual(['nodeB']);
+        expect(result.failingNodes).not.toContain('nodeA');
+    });
+    it('no goalGate=true nodes: vacuously satisfied', () => {
+        const controller = createConvergenceController();
+        const graph = makeGraph([makeNode('nodeA', { goalGate: false }), makeNode('nodeB', { goalGate: false })], []);
+        const result = controller.evaluateGates(graph);
+        expect(result).toEqual({ satisfied: true, failingNodes: [] });
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 4: Checkpoint resume compliance — spec Section 5.3
+// ---------------------------------------------------------------------------
+describe('checkpoint resume compliance — spec Section 5.3', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = path.join(os.tmpdir(), `attractor-compliance-${crypto.randomUUID()}`);
+        await mkdir(tmpDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('AC5 — completed nodes are skipped and context is restored on resume', async () => {
+        // Write seed checkpoint using CheckpointManager.save()
+        const checkpointManager = new CheckpointManager();
+        const seedContext = new GraphContext({ result: 'ok', attempt: '3' });
+        await checkpointManager.save(tmpDir, {
+            currentNode: 'node1',
+            completedNodes: ['start', 'node1'],
+            nodeRetries: {},
+            context: seedContext,
+        });
+        // Parse and validate the compliance resume graph
+        const graph = parseGraph(COMPLIANCE_RESUME_DOT);
+        const validator = createValidator();
+        const validationErrors = validator.validate(graph).filter((d) => d.severity === 'error');
+        expect(validationErrors).toHaveLength(0);
+        // Track graph:node-started events and captured contexts per node
+        const { bus, nodeStartedIds } = makeEventBus();
+        const capturedContextByNode = {};
+        const registry = makeRegistry((node, ctx) => {
+            capturedContextByNode[node.id] = ctx;
+        });
+        const executor = createGraphExecutor();
+        const config = {
+            runId: 'compliance-resume-test',
+            logsRoot: tmpDir,
+            handlerRegistry: registry,
+            eventBus: bus,
+            checkpointPath: path.join(tmpDir, 'checkpoint.json'),
+        };
+        const finalOutcome = await executor.run(graph, config);
+        // graph:node-started must NOT include 'start' or 'node1' (skipped)
+        expect(nodeStartedIds()).not.toContain('start');
+        expect(nodeStartedIds()).not.toContain('node1');
+        // graph:node-started MUST include 'node2' and 'exit' is never dispatched (exit check)
+        expect(nodeStartedIds()).toContain('node2');
+        // Context is restored: node2 handler receives context seeded from checkpoint
+        expect(capturedContextByNode['node2']).toBeDefined();
+        expect(capturedContextByNode['node2'].getString('result')).toBe('ok');
+        expect(capturedContextByNode['node2'].getString('attempt')).toBe('3');
+        // Final outcome is SUCCESS
+        expect(finalOutcome.status).toBe('SUCCESS');
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 5: Fidelity degradation on resume — spec Section 5.3 step 6
+// ---------------------------------------------------------------------------
+describe('fidelity degradation on resume — spec Section 5.3 step 6', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = path.join(os.tmpdir(), `attractor-fidelity-${crypto.randomUUID()}`);
+        await mkdir(tmpDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('first resumed node gets fidelity="summary:high" when last completed node had fidelity="full"', async () => {
+        // Write seed checkpoint: node1 (which has fidelity=full in the DOT) is the last completed node
+        const checkpointManager = new CheckpointManager();
+        const seedContext = new GraphContext({ result: 'ok' });
+        await checkpointManager.save(tmpDir, {
+            currentNode: 'node1',
+            completedNodes: ['start', 'node1'],
+            nodeRetries: {},
+            context: seedContext,
+        });
+        // Parse graph where node1 has fidelity=full
+        const graph = parseGraph(COMPLIANCE_FIDELITY_RESUME_DOT);
+        // Capture the node argument passed to each handler dispatch
+        const capturedNodeByNodeId = {};
+        const registry = makeRegistry((node) => {
+            capturedNodeByNodeId[node.id] = node;
+        });
+        const { bus } = makeEventBus();
+        const config = {
+            runId: 'compliance-fidelity-test',
+            logsRoot: tmpDir,
+            handlerRegistry: registry,
+            eventBus: bus,
+            checkpointPath: path.join(tmpDir, 'checkpoint.json'),
+        };
+        await createGraphExecutor().run(graph, config);
+        // node2 is the first resumed node; its fidelity should be degraded to 'summary:high'
+        expect(capturedNodeByNodeId['node2']).toBeDefined();
+        expect(capturedNodeByNodeId['node2'].fidelity).toBe('summary:high');
+    });
+    it('subsequent resumed nodes use their configured fidelity (not the degraded value)', async () => {
+        // Extend the graph by adding node3 after node2
+        const EXTENDED_DOT = `
+digraph compliance_fidelity_extended {
+  graph [goal="Extended fidelity test"]
+  start [shape=Mdiamond]
+  node1 [type=codergen, prompt="Step 1", fidelity=full]
+  node2 [type=codergen, prompt="Step 2", fidelity=medium]
+  node3 [type=codergen, prompt="Step 3", fidelity=high]
+  exit [shape=Msquare]
+
+  start -> node1
+  node1 -> node2
+  node2 -> node3
+  node3 -> exit
+}
+`;
+        const checkpointManager = new CheckpointManager();
+        const seedCtx = new GraphContext();
+        await checkpointManager.save(tmpDir, {
+            currentNode: 'node1',
+            completedNodes: ['start', 'node1'],
+            nodeRetries: {},
+            context: seedCtx,
+        });
+        const graph = parseGraph(EXTENDED_DOT);
+        const capturedNodeByNodeId = {};
+        const registry = makeRegistry((node) => {
+            capturedNodeByNodeId[node.id] = node;
+        });
+        const { bus } = makeEventBus();
+        const config = {
+            runId: 'compliance-fidelity-extended-test',
+            logsRoot: tmpDir,
+            handlerRegistry: registry,
+            eventBus: bus,
+            checkpointPath: path.join(tmpDir, 'checkpoint.json'),
+        };
+        await createGraphExecutor().run(graph, config);
+        // node2 is first resumed → degraded to 'summary:high'
+        expect(capturedNodeByNodeId['node2'].fidelity).toBe('summary:high');
+        // node3 is subsequent → uses its configured fidelity='high'
+        expect(capturedNodeByNodeId['node3'].fidelity).toBe('high');
+    });
+});
+// ---------------------------------------------------------------------------
+// Task 6: Structural conformance — AttractorBench parity
+// ---------------------------------------------------------------------------
+describe('structural conformance — AttractorBench parity', () => {
+    // AttractorBench structural conformance parity — Phase A mandatory
+    // See: https://github.com/strongdm/attractorbench
+    // Behavioral conformance tests are advisory in Phase A; required by Phase B exit.
+    // -------------------------------------------------------------------------
+    // Attribute coverage — nodes (all 17 spec-defined + toolCommand from 42-11 + backend from 48-10)
+    // -------------------------------------------------------------------------
+    it('AC6 — all node attributes extracted with correct values from DOT', () => {
+        const dot = `
+digraph compliance_node_attrs {
+  graph [goal="Attribute coverage"]
+  start [shape=Mdiamond]
+  target [
+    shape=box,
+    type=codergen,
+    label="Target Label",
+    prompt="Target prompt",
+    max_retries=3,
+    goal_gate=true,
+    retry_target="start",
+    fallback_retry_target="start",
+    fidelity=high,
+    thread_id="thread-1",
+    class="myclass",
+    timeout=30,
+    llm_model="gpt-4o",
+    llm_provider=openai,
+    reasoning_effort=high,
+    auto_status=false,
+    allow_partial=true,
+    tool_command="echo hello",
+    backend=direct
+  ]
+  exit [shape=Msquare]
+  start -> target
+  target -> exit
+}
+`;
+        const graph = parseGraph(dot);
+        const node = graph.nodes.get('target');
+        expect(node).toBeDefined();
+        expect(node.id).toBe('target');
+        expect(node.label).toBe('Target Label');
+        expect(node.shape).toBe('box');
+        expect(node.type).toBe('codergen');
+        expect(node.prompt).toBe('Target prompt');
+        expect(node.maxRetries).toBe(3);
+        expect(node.goalGate).toBe(true);
+        expect(node.retryTarget).toBe('start');
+        expect(node.fallbackRetryTarget).toBe('start');
+        expect(node.fidelity).toBe('high');
+        expect(node.threadId).toBe('thread-1');
+        expect(node.class).toBe('myclass');
+        expect(node.timeout).toBe(30);
+        expect(node.llmModel).toBe('gpt-4o');
+        expect(node.llmProvider).toBe('openai');
+        expect(node.reasoningEffort).toBe('high');
+        expect(node.autoStatus).toBe(false);
+        expect(node.allowPartial).toBe(true);
+        expect(node.toolCommand).toBe('echo hello');
+        expect(node.backend).toBe('direct');
+    });
+    // -------------------------------------------------------------------------
+    // Attribute coverage — edges (all 6 edge attributes)
+    // -------------------------------------------------------------------------
+    it('AC6 — all 6 edge attributes extracted with correct values from DOT', () => {
+        const dot = `
+digraph compliance_edge_attrs {
+  graph [goal="Edge attribute coverage"]
+  start [shape=Mdiamond]
+  nodeA [type=codergen, prompt="a"]
+  exit [shape=Msquare]
+  start -> nodeA [
+    label="go",
+    condition="outcome=success",
+    weight=5,
+    fidelity=high,
+    thread_id="t2",
+    loop_restart=true
+  ]
+  nodeA -> exit
+}
+`;
+        const graph = parseGraph(dot);
+        const edge = graph.edges.find((e) => e.fromNode === 'start' && e.toNode === 'nodeA');
+        expect(edge).toBeDefined();
+        expect(edge.label).toBe('go');
+        expect(edge.condition).toBe('outcome=success');
+        expect(edge.weight).toBe(5);
+        expect(edge.fidelity).toBe('high');
+        expect(edge.threadId).toBe('t2');
+        expect(edge.loopRestart).toBe(true);
+    });
+    // -------------------------------------------------------------------------
+    // Lint rule coverage — 8 error-level rules (stories 42-4)
+    // -------------------------------------------------------------------------
+    it('AC6 — lint rule "start_node" fires (severity=error) when no start node exists', () => {
+        // Graph with no Mdiamond node and no id=start/Start
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work' }], [{ fromNode: 'work', toNode: 'exit' }]);
+        // Override the nodes map to remove start (the makeLintGraph adds start by default — use manual build)
+        const nodeMap = new Map();
+        nodeMap.set('work', makeNode('work', { type: 'codergen', prompt: 'work' }));
+        nodeMap.set('exit', makeNode('exit', { shape: 'Msquare', type: '' }));
+        const edges = [makeEdge('work', 'exit')];
+        const g = {
+            id: 'test', goal: '', label: '', modelStylesheet: '',
+            defaultMaxRetries: 0, retryTarget: '', fallbackRetryTarget: '', defaultFidelity: '',
+            nodes: nodeMap,
+            edges,
+            outgoingEdges: (id) => edges.filter((e) => e.fromNode === id),
+            startNode: () => { throw new Error('no start'); },
+            exitNode: () => nodeMap.get('exit'),
+        };
+        const diags = createValidator().validate(g);
+        const rule = diags.find((d) => d.ruleId === 'start_node');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "terminal_node" fires (severity=error) when no exit node exists', () => {
+        const nodeMap = new Map();
+        nodeMap.set('start', makeNode('start', { shape: 'Mdiamond', type: '' }));
+        nodeMap.set('work', makeNode('work', { type: 'codergen', prompt: 'work' }));
+        const edges = [makeEdge('start', 'work')];
+        const g = {
+            id: 'test', goal: '', label: '', modelStylesheet: '',
+            defaultMaxRetries: 0, retryTarget: '', fallbackRetryTarget: '', defaultFidelity: '',
+            nodes: nodeMap,
+            edges,
+            outgoingEdges: (id) => edges.filter((e) => e.fromNode === id),
+            startNode: () => nodeMap.get('start'),
+            exitNode: () => { throw new Error('no exit'); },
+        };
+        const diags = createValidator().validate(g);
+        const rule = diags.find((d) => d.ruleId === 'terminal_node');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "start_no_incoming" fires (severity=error) when edge targets the start node', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work' }], [
+            { fromNode: 'start', toNode: 'work' },
+            { fromNode: 'work', toNode: 'exit' },
+            { fromNode: 'work', toNode: 'start' }, // incoming edge to start
+        ]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'start_no_incoming');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "exit_no_outgoing" fires (severity=error) when exit node has an outgoing edge', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work' }], [
+            { fromNode: 'start', toNode: 'work' },
+            { fromNode: 'work', toNode: 'exit' },
+            { fromNode: 'exit', toNode: 'work' }, // outgoing edge from exit
+        ]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'exit_no_outgoing');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "edge_target_exists" fires (severity=error) when edge targets non-existent node', () => {
+        // Build graph directly — DOT auto-creates referenced nodes, so we use in-memory construction
+        const nodeMap = new Map();
+        nodeMap.set('start', makeNode('start', { shape: 'Mdiamond', type: '' }));
+        nodeMap.set('work', makeNode('work', { type: 'codergen', prompt: 'work' }));
+        nodeMap.set('exit', makeNode('exit', { shape: 'Msquare', type: '' }));
+        const edges = [
+            makeEdge('start', 'work'),
+            makeEdge('work', 'exit'),
+            makeEdge('work', 'ghost_node'), // ghost_node does NOT exist in nodeMap
+        ];
+        const g = {
+            id: 'test', goal: '', label: '', modelStylesheet: '',
+            defaultMaxRetries: 0, retryTarget: '', fallbackRetryTarget: '', defaultFidelity: '',
+            nodes: nodeMap,
+            edges,
+            outgoingEdges: (id) => edges.filter((e) => e.fromNode === id),
+            startNode: () => nodeMap.get('start'),
+            exitNode: () => nodeMap.get('exit'),
+        };
+        const diags = createValidator().validate(g);
+        const rule = diags.find((d) => d.ruleId === 'edge_target_exists');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "reachability" fires (severity=error) when a node is unreachable', () => {
+        const graph = makeLintGraph([
+            { id: 'work', type: 'codergen', prompt: 'work' },
+            { id: 'unreachable', type: 'codergen', prompt: 'unreachable' },
+        ], [
+            { fromNode: 'start', toNode: 'work' },
+            { fromNode: 'work', toNode: 'exit' },
+            // 'unreachable' has no incoming edges from start
+        ]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'reachability');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "condition_syntax" fires (severity=error) for invalid condition expression', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work' }], [
+            { fromNode: 'start', toNode: 'work' },
+            { fromNode: 'work', toNode: 'exit', condition: 'a==b' }, // double-equals is invalid
+        ]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'condition_syntax');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    it('AC6 — lint rule "stylesheet_syntax" fires (severity=error) for invalid stylesheet content', () => {
+        // Build graph with invalid inline stylesheet
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work' }], [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }], { modelStylesheet: '!!! invalid stylesheet content !!!' });
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'stylesheet_syntax');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('error');
+    });
+    // -------------------------------------------------------------------------
+    // Lint rule coverage — 5 warning-level rules (stories 42-5)
+    // -------------------------------------------------------------------------
+    it('AC6 — lint rule "type_known" fires (severity=warning) for unknown node type', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'wizard_type', prompt: 'work' }], // wizard_type is unknown
+        [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'type_known');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('warning');
+    });
+    it('AC6 — lint rule "fidelity_valid" fires (severity=warning) for invalid fidelity value', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work', fidelity: 'ultra_high' }], // invalid fidelity
+        [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'fidelity_valid');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('warning');
+    });
+    it('AC6 — lint rule "retry_target_exists" fires (severity=warning) for missing retryTarget node', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work', retryTarget: 'nonexistent' }], [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'retry_target_exists');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('warning');
+    });
+    it('AC6 — lint rule "goal_gate_has_retry" fires (severity=warning) when goalGate=true node has no retryTarget', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: 'work', goalGate: true, retryTarget: '' }], [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'goal_gate_has_retry');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('warning');
+    });
+    it('AC6 — lint rule "prompt_on_llm_nodes" fires (severity=warning) for codergen node with no prompt or label', () => {
+        const graph = makeLintGraph([{ id: 'work', type: 'codergen', prompt: '', label: '' }], // no prompt AND no label
+        [{ fromNode: 'start', toNode: 'work' }, { fromNode: 'work', toNode: 'exit' }]);
+        const diags = createValidator().validate(graph);
+        const rule = diags.find((d) => d.ruleId === 'prompt_on_llm_nodes');
+        expect(rule).toBeDefined();
+        expect(rule.severity).toBe('warning');
+    });
+    // -------------------------------------------------------------------------
+    // Edge selection determinism — identical inputs always produce same output
+    // -------------------------------------------------------------------------
+    it('AC6 — selectEdge is deterministic: identical inputs always produce same edge', async () => {
+        const node = makeNode('origin');
+        const edgeA = makeEdge('origin', 'alpha', { weight: 5 });
+        const edgeB = makeEdge('origin', 'bravo', { weight: 5 });
+        const edgeC = makeEdge('origin', 'charlie', { weight: 3 });
+        const graph = makeGraph([node], [edgeA, edgeB, edgeC]);
+        const ctx = new GraphContext({ x: '1' });
+        const outcome = { status: 'SUCCESS' };
+        const first = await selectEdge(node, outcome, ctx, graph);
+        const second = await selectEdge(node, outcome, ctx, graph);
+        const third = await selectEdge(node, outcome, ctx, graph);
+        expect(first?.toNode).toBe(second?.toNode);
+        expect(second?.toNode).toBe(third?.toNode);
+        expect(first?.toNode).toBe('alpha'); // lexically first among weight-5 ties
+    });
+});
+//# sourceMappingURL=attractor-compliance.test.js.map