@weldr/runr 0.3.1 → 0.4.0

package/dist/context/__tests__/artifact.test.js

@@ -1,130 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { writeContextPackArtifact, readContextPackArtifact, formatContextPackStatus } from '../artifact.js';
-describe('writeContextPackArtifact', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'artifact-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    it('writes full pack when enabled', () => {
-        const pack = {
-            version: 1,
-            generated_at: '2025-12-24T01:00:00.000Z',
-            verification: {
-                tier0: ['pnpm lint'],
-                tier1: [],
-                tier2: []
-            },
-            reference_files: [],
-            scope: {
-                allowlist: ['src/**'],
-                denylist: []
-            },
-            patterns: {
-                tsconfig: null,
-                eslint: null,
-                package_json: null
-            },
-            blockers: {
-                scope_violations: [],
-                lockfile_restrictions: false,
-                common_errors: []
-            }
-        };
-        writeContextPackArtifact(tempDir, pack);
-        const artifactPath = path.join(tempDir, 'artifacts', 'context-pack.json');
-        expect(fs.existsSync(artifactPath)).toBe(true);
-        const content = JSON.parse(fs.readFileSync(artifactPath, 'utf-8'));
-        expect(content.enabled).toBe(true);
-        expect(content.pack_version).toBe(1);
-        expect(content.generated_at).toBe('2025-12-24T01:00:00.000Z');
-        expect(content.estimated_tokens).toBeGreaterThan(0);
-        expect(content.verification.tier0).toEqual(['pnpm lint']);
-    });
-    it('writes disabled stub when pack is null', () => {
-        writeContextPackArtifact(tempDir, null);
-        const artifactPath = path.join(tempDir, 'artifacts', 'context-pack.json');
-        expect(fs.existsSync(artifactPath)).toBe(true);
-        const content = JSON.parse(fs.readFileSync(artifactPath, 'utf-8'));
-        expect(content.enabled).toBe(false);
-        expect(content.pack_version).toBe(1);
-        expect(content.generated_at).toBeDefined();
-        expect(content.verification).toBeUndefined();
-    });
-    it('creates artifacts directory if missing', () => {
-        const artifactsDir = path.join(tempDir, 'artifacts');
-        expect(fs.existsSync(artifactsDir)).toBe(false);
-        writeContextPackArtifact(tempDir, null);
-        expect(fs.existsSync(artifactsDir)).toBe(true);
-    });
-});
-describe('readContextPackArtifact', () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'artifact-test-'));
-    });
-    afterEach(() => {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-    it('returns null for missing file', () => {
-        const result = readContextPackArtifact(tempDir);
-        expect(result).toBeNull();
-    });
-    it('parses existing artifact', () => {
-        const artifactsDir = path.join(tempDir, 'artifacts');
-        fs.mkdirSync(artifactsDir, { recursive: true });
-        const artifact = {
-            enabled: true,
-            pack_version: 1,
-            generated_at: '2025-12-24T01:00:00.000Z',
-            estimated_tokens: 500
-        };
-        fs.writeFileSync(path.join(artifactsDir, 'context-pack.json'), JSON.stringify(artifact));
-        const result = readContextPackArtifact(tempDir);
-        expect(result).not.toBeNull();
-        expect(result?.enabled).toBe(true);
-        expect(result?.estimated_tokens).toBe(500);
-    });
-    it('returns null for invalid JSON', () => {
-        const artifactsDir = path.join(tempDir, 'artifacts');
-        fs.mkdirSync(artifactsDir, { recursive: true });
-        fs.writeFileSync(path.join(artifactsDir, 'context-pack.json'), 'not json');
-        const result = readContextPackArtifact(tempDir);
-        expect(result).toBeNull();
-    });
-});
-describe('formatContextPackStatus', () => {
-    it('formats null as not found', () => {
-        expect(formatContextPackStatus(null)).toBe('context_pack: (not found)');
-    });
-    it('formats disabled artifact', () => {
-        const artifact = {
-            enabled: false,
-            pack_version: 1,
-            generated_at: '2025-12-24T01:00:00.000Z'
-        };
-        expect(formatContextPackStatus(artifact)).toBe('context_pack: disabled');
-    });
-    it('formats enabled artifact with tokens', () => {
-        const artifact = {
-            enabled: true,
-            pack_version: 1,
-            generated_at: '2025-12-24T01:00:00.000Z',
-            estimated_tokens: 493
-        };
-        expect(formatContextPackStatus(artifact)).toBe('context_pack: present (493 tokens)');
-    });
-    it('handles missing token count', () => {
-        const artifact = {
-            enabled: true,
-            pack_version: 1,
-            generated_at: '2025-12-24T01:00:00.000Z'
-        };
-        expect(formatContextPackStatus(artifact)).toBe('context_pack: present (? tokens)');
-    });
-});

package/dist/context/__tests__/pack.test.js

@@ -1,191 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import path from 'node:path';
-import { buildContextPack, formatContextPackForPrompt, estimatePackTokens } from '../pack.js';
-// Use the actual repo root for integration-style tests
-const REPO_ROOT = path.resolve(__dirname, '../../..');
-describe('buildContextPack', () => {
-    describe('verification commands', () => {
-        it('extracts verification commands from config', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {
-                    verification: {
-                        tier0: ['pnpm lint', 'pnpm typecheck'],
-                        tier1: ['pnpm test'],
-                        tier2: []
-                    }
-                }
-            });
-            expect(pack.verification.tier0).toEqual(['pnpm lint', 'pnpm typecheck']);
-            expect(pack.verification.tier1).toEqual(['pnpm test']);
-            expect(pack.verification.tier2).toEqual([]);
-        });
-        it('handles missing verification config', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {}
-            });
-            expect(pack.verification.tier0).toEqual([]);
-            expect(pack.verification.tier1).toEqual([]);
-        });
-    });
-    describe('reference files', () => {
-        it('resolves RNG pattern reference', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {},
-                references: [{ pattern: 'RNG pattern from deckbuilder' }]
-            });
-            expect(pack.reference_files.length).toBeGreaterThan(0);
-            const rngRef = pack.reference_files.find((r) => r.path.includes('rng.ts'));
-            expect(rngRef).toBeDefined();
-            expect(rngRef?.content).toContain('nextInt');
-            expect(rngRef?.content).toContain('1103515245'); // LCG constant
-        });
-        it('resolves explicit hint path', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {},
-                references: [
-                    {
-                        pattern: 'custom reference',
-                        hint: 'apps/deckbuilder/src/engine/rng.ts'
-                    }
-                ]
-            });
-            expect(pack.reference_files.length).toBe(1);
-            expect(pack.reference_files[0].path).toBe('apps/deckbuilder/src/engine/rng.ts');
-            expect(pack.reference_files[0].reason).toBe('custom reference');
-        });
-        it('handles unknown pattern gracefully', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {},
-                references: [{ pattern: 'nonexistent magic pattern' }]
-            });
-            expect(pack.reference_files).toEqual([]);
-        });
-    });
-    describe('scope constraints', () => {
-        it('extracts scope from config', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {
-                    scope: {
-                        allowlist: ['apps/tactical-grid/**'],
-                        denylist: ['**/node_modules/**']
-                    }
-                }
-            });
-            expect(pack.scope.allowlist).toEqual(['apps/tactical-grid/**']);
-            expect(pack.scope.denylist).toEqual(['**/node_modules/**']);
-        });
-    });
-    describe('config patterns', () => {
-        it('finds nearest tsconfig.json', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/deckbuilder',
-                config: {}
-            });
-            expect(pack.patterns.tsconfig).not.toBeNull();
-            expect(pack.patterns.tsconfig?.path).toContain('tsconfig.json');
-            expect(pack.patterns.tsconfig?.content).toContain('compilerOptions');
-        });
-        it('finds nearest eslint config', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/deckbuilder',
-                config: {}
-            });
-            expect(pack.patterns.eslint).not.toBeNull();
-            expect(pack.patterns.eslint?.path).toMatch(/eslint\.config/);
-        });
-        it('finds nearest package.json', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/deckbuilder',
-                config: {}
-            });
-            expect(pack.patterns.package_json).not.toBeNull();
-            expect(pack.patterns.package_json?.content).toContain('scripts');
-        });
-        it('finds config even for nonexistent target (upward search or fallback)', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/nonexistent-app',
-                config: {}
-            });
-            // Should find config via upward search (repo root) or fallback to deckbuilder
-            expect(pack.patterns.tsconfig).not.toBeNull();
-            expect(pack.patterns.tsconfig?.content).toContain('compilerOptions');
-        });
-    });
-    describe('version and metadata', () => {
-        it('includes version 1', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {}
-            });
-            expect(pack.version).toBe(1);
-        });
-        it('includes generated_at timestamp', () => {
-            const pack = buildContextPack({
-                repoRoot: REPO_ROOT,
-                targetRoot: 'apps/tactical-grid',
-                config: {}
-            });
-            expect(pack.generated_at).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-        });
-    });
-});
-describe('formatContextPackForPrompt', () => {
-    it('formats verification commands', () => {
-        const pack = buildContextPack({
-            repoRoot: REPO_ROOT,
-            targetRoot: 'apps/tactical-grid',
-            config: {
-                verification: {
-                    tier0: ['pnpm lint', 'pnpm typecheck'],
-                    tier1: ['pnpm test']
-                }
-            }
-        });
-        const formatted = formatContextPackForPrompt(pack);
-        expect(formatted).toContain('Verification Commands');
-        expect(formatted).toContain('tier0: pnpm lint && pnpm typecheck');
-        expect(formatted).toContain('tier1: pnpm test');
-    });
-    it('includes reference file content', () => {
-        const pack = buildContextPack({
-            repoRoot: REPO_ROOT,
-            targetRoot: 'apps/tactical-grid',
-            config: {},
-            references: [{ pattern: 'RNG pattern' }]
-        });
-        const formatted = formatContextPackForPrompt(pack);
-        expect(formatted).toContain('Reference Files');
-        expect(formatted).toContain('nextInt');
-    });
-});
-describe('estimatePackTokens', () => {
-    it('estimates token count based on character length', () => {
-        const pack = buildContextPack({
-            repoRoot: REPO_ROOT,
-            targetRoot: 'apps/tactical-grid',
-            config: {
-                verification: { tier0: ['pnpm lint'] }
-            }
-        });
-        const tokens = estimatePackTokens(pack);
-        expect(tokens).toBeGreaterThan(0);
-        expect(tokens).toBeLessThan(10000); // Sanity check
-    });
-});

package/dist/env/__tests__/fingerprint.test.js

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { compareFingerprints } from '../fingerprint.js';
-function makeFingerprint(overrides = {}) {
-    return {
-        node_version: 'v20.0.0',
-        package_manager: 'npm',
-        lockfile_hash: 'abc123def456',
-        worker_versions: {
-            codex: 'codex-cli 0.70.0',
-            claude: '2.0.50 (Claude Code)'
-        },
-        created_at: '2025-01-01T00:00:00.000Z',
-        ...overrides
-    };
-}
-describe('compareFingerprints', () => {
-    it('returns empty array when fingerprints match', () => {
-        const original = makeFingerprint();
-        const current = makeFingerprint();
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toEqual([]);
-    });
-    it('detects node version change', () => {
-        const original = makeFingerprint({ node_version: 'v20.0.0' });
-        const current = makeFingerprint({ node_version: 'v22.0.0' });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0]).toEqual({
-            field: 'node_version',
-            original: 'v20.0.0',
-            current: 'v22.0.0'
-        });
-    });
-    it('detects package manager change', () => {
-        const original = makeFingerprint({ package_manager: 'npm' });
-        const current = makeFingerprint({ package_manager: 'pnpm' });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0].field).toBe('package_manager');
-    });
-    it('detects lockfile hash change', () => {
-        const original = makeFingerprint({ lockfile_hash: 'abc123' });
-        const current = makeFingerprint({ lockfile_hash: 'def456' });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0].field).toBe('lockfile_hash');
-    });
-    it('detects worker version change', () => {
-        const original = makeFingerprint({
-            worker_versions: { codex: '0.70.0', claude: '2.0.50' }
-        });
-        const current = makeFingerprint({
-            worker_versions: { codex: '0.80.0', claude: '2.0.50' }
-        });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0].field).toBe('worker:codex');
-        expect(diffs[0].original).toBe('0.70.0');
-        expect(diffs[0].current).toBe('0.80.0');
-    });
-    it('handles null lockfile gracefully', () => {
-        const original = makeFingerprint({ lockfile_hash: null });
-        const current = makeFingerprint({ lockfile_hash: 'abc123' });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0].field).toBe('lockfile_hash');
-        expect(diffs[0].original).toBeNull();
-    });
-    it('handles null package manager gracefully', () => {
-        const original = makeFingerprint({ package_manager: null });
-        const current = makeFingerprint({ package_manager: null });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toEqual([]);
-    });
-    it('handles null worker version gracefully', () => {
-        const original = makeFingerprint({
-            worker_versions: { codex: null, claude: '2.0.50' }
-        });
-        const current = makeFingerprint({
-            worker_versions: { codex: '0.80.0', claude: '2.0.50' }
-        });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(1);
-        expect(diffs[0].original).toBeNull();
-        expect(diffs[0].current).toBe('0.80.0');
-    });
-    it('detects multiple changes at once', () => {
-        const original = makeFingerprint({
-            node_version: 'v20.0.0',
-            lockfile_hash: 'old-hash',
-            worker_versions: { codex: '0.70.0', claude: '2.0.50' }
-        });
-        const current = makeFingerprint({
-            node_version: 'v22.0.0',
-            lockfile_hash: 'new-hash',
-            worker_versions: { codex: '0.80.0', claude: '2.0.50' }
-        });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toHaveLength(3);
-        expect(diffs.map((d) => d.field).sort()).toEqual([
-            'lockfile_hash',
-            'node_version',
-            'worker:codex'
-        ]);
-    });
-    it('ignores created_at timestamp differences', () => {
-        const original = makeFingerprint({
-            created_at: '2025-01-01T00:00:00.000Z'
-        });
-        const current = makeFingerprint({
-            created_at: '2025-06-15T12:30:00.000Z'
-        });
-        const diffs = compareFingerprints(original, current);
-        expect(diffs).toEqual([]);
-    });
-});

package/dist/orchestrator/__tests__/policy.test.js

@@ -1,185 +0,0 @@
-/**
- * Policy block tests for Phase 7B.
- *
- * These tests verify:
- * 1. Run creates state.policy correctly from CLI/config
- * 2. Resume without overrides keeps policy unchanged (via getEffectivePolicy)
- * 3. Legacy states (without policy block) are handled correctly
- */
-import { describe, it, expect } from 'vitest';
-import { createInitialOrchestratorState, getEffectivePolicy } from '../state-machine.js';
-// Sample config for testing
-const sampleConfig = {
-    tracks: [
-        {
-            name: 'Track A',
-            steps: [{ task: 'tasks/a.md' }]
-        },
-        {
-            name: 'Track B',
-            steps: [{ task: 'tasks/b.md' }]
-        }
-    ]
-};
-describe('Policy Block', () => {
-    describe('createInitialOrchestratorState', () => {
-        it('creates state.policy correctly from CLI options', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 60,
-                maxTicks: 25,
-                collisionPolicy: 'serialize',
-                fast: true,
-                autoResume: true,
-                parallel: 1,
-                ownershipRequired: true
-            });
-            // Policy block should exist
-            expect(state.policy).toBeDefined();
-            // Policy values should match options
-            expect(state.policy.time_budget_minutes).toBe(60);
-            expect(state.policy.max_ticks).toBe(25);
-            expect(state.policy.collision_policy).toBe('serialize');
-            expect(state.policy.fast).toBe(true);
-            expect(state.policy.auto_resume).toBe(true);
-            expect(state.policy.parallel).toBe(1);
-            expect(state.policy.ownership_required).toBe(true);
-        });
-        it('sets default values for optional policy fields', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 120,
-                maxTicks: 50,
-                collisionPolicy: 'force'
-                // fast, autoResume, parallel not provided
-            });
-            expect(state.policy).toBeDefined();
-            expect(state.policy.fast).toBe(false);
-            expect(state.policy.auto_resume).toBe(false);
-            expect(state.policy.parallel).toBe(2); // Default: track count
-            expect(state.policy.ownership_required).toBe(false);
-        });
-        it('writes both policy block and legacy fields for backward compatibility', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 90,
-                maxTicks: 30,
-                collisionPolicy: 'fail',
-                fast: true
-            });
-            // Policy block
-            expect(state.policy.time_budget_minutes).toBe(90);
-            expect(state.policy.max_ticks).toBe(30);
-            expect(state.policy.collision_policy).toBe('fail');
-            expect(state.policy.fast).toBe(true);
-            // Legacy fields (should match)
-            expect(state.time_budget_minutes).toBe(90);
-            expect(state.max_ticks).toBe(30);
-            expect(state.collision_policy).toBe('fail');
-            expect(state.fast).toBe(true);
-        });
-    });
-    describe('getEffectivePolicy', () => {
-        it('returns policy block when present', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 45,
-                maxTicks: 15,
-                collisionPolicy: 'serialize',
-                fast: true,
-                autoResume: true
-            });
-            const policy = getEffectivePolicy(state);
-            expect(policy.time_budget_minutes).toBe(45);
-            expect(policy.max_ticks).toBe(15);
-            expect(policy.collision_policy).toBe('serialize');
-            expect(policy.fast).toBe(true);
-            expect(policy.auto_resume).toBe(true);
-        });
-        it('falls back to legacy fields when policy block is missing (v0 state)', () => {
-            // Simulate a legacy v0 state without policy block
-            const legacyState = {
-                orchestrator_id: 'orch20240101120000',
-                repo_path: '/test/repo',
-                tracks: [
-                    {
-                        id: 'track-1',
-                        name: 'Track A',
-                        steps: [{ task_path: 'tasks/a.md' }],
-                        current_step: 0,
-                        status: 'pending'
-                    }
-                ],
-                active_runs: {},
-                file_claims: {},
-                status: 'running',
-                started_at: '2024-01-01T12:00:00Z',
-                // No policy block - legacy v0 state
-                collision_policy: 'force',
-                time_budget_minutes: 180,
-                max_ticks: 100,
-                fast: true
-            };
-            const policy = getEffectivePolicy(legacyState);
-            // Should extract from legacy fields
-            expect(policy.time_budget_minutes).toBe(180);
-            expect(policy.max_ticks).toBe(100);
-            expect(policy.collision_policy).toBe('force');
-            expect(policy.fast).toBe(true);
-            // Defaults for fields not in v0
-            expect(policy.auto_resume).toBe(false);
-            expect(policy.parallel).toBe(1); // track count
-        });
-        it('handles legacy state with fast=undefined', () => {
-            const legacyState = {
-                orchestrator_id: 'orch20240101120000',
-                repo_path: '/test/repo',
-                tracks: [],
-                active_runs: {},
-                file_claims: {},
-                status: 'running',
-                started_at: '2024-01-01T12:00:00Z',
-                collision_policy: 'serialize',
-                time_budget_minutes: 60,
-                max_ticks: 25
-                // fast is undefined (missing in v0)
-            };
-            const policy = getEffectivePolicy(legacyState);
-            expect(policy.fast).toBe(false); // Default when undefined
-        });
-    });
-    describe('Resume policy immutability', () => {
-        it('resume without overrides keeps policy unchanged', () => {
-            // Create initial state
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 60,
-                maxTicks: 25,
-                collisionPolicy: 'serialize',
-                fast: true
-            });
-            // Simulate "resuming" by getting effective policy
-            const policyBeforeResume = getEffectivePolicy(state);
-            const policyAfterResume = getEffectivePolicy(state);
-            // Policy should be identical
-            expect(policyAfterResume).toEqual(policyBeforeResume);
-        });
-        it('policy values remain stable across multiple reads', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 42,
-                maxTicks: 17,
-                collisionPolicy: 'force',
-                fast: false,
-                autoResume: true
-            });
-            // Read policy multiple times
-            const policy1 = getEffectivePolicy(state);
-            const policy2 = getEffectivePolicy(state);
-            const policy3 = getEffectivePolicy(state);
-            // All reads should return identical values
-            expect(policy1).toEqual(policy2);
-            expect(policy2).toEqual(policy3);
-            // And match original options
-            expect(policy1.time_budget_minutes).toBe(42);
-            expect(policy1.max_ticks).toBe(17);
-            expect(policy1.collision_policy).toBe('force');
-            expect(policy1.fast).toBe(false);
-            expect(policy1.auto_resume).toBe(true);
-        });
-    });
-});

package/dist/orchestrator/__tests__/schema-version.test.js

@@ -1,65 +0,0 @@
-/**
- * Schema version tests for Phase 7C.
- *
- * These tests verify:
- * 1. Artifacts include schema_version field
- * 2. Schema version is the expected value
- */
-import { describe, it, expect } from 'vitest';
-import { buildWaitResult, buildSummaryArtifact, buildStopArtifact } from '../artifacts.js';
-import { createInitialOrchestratorState } from '../state-machine.js';
-import { ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION } from '../types.js';
-const sampleConfig = {
-    tracks: [
-        {
-            name: 'Test Track',
-            steps: [{ task: 'tasks/test.md' }]
-        }
-    ]
-};
-describe('Schema Versioning', () => {
-    describe('Orchestration Artifacts', () => {
-        it('buildWaitResult includes schema_version', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 60,
-                maxTicks: 25,
-                collisionPolicy: 'serialize'
-            });
-            // Mark as complete for testing
-            state.status = 'complete';
-            state.ended_at = new Date().toISOString();
-            const result = buildWaitResult(state, '/test/repo');
-            expect(result.schema_version).toBe(ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION);
-            expect(result.schema_version).toBe(1);
-        });
-        it('buildSummaryArtifact includes schema_version', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 60,
-                maxTicks: 25,
-                collisionPolicy: 'serialize'
-            });
-            state.status = 'complete';
-            state.ended_at = new Date().toISOString();
-            const summary = buildSummaryArtifact(state, '/test/repo');
-            expect(summary.schema_version).toBe(ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION);
-            expect(summary.schema_version).toBe(1);
-        });
-        it('buildStopArtifact includes schema_version', () => {
-            const state = createInitialOrchestratorState(sampleConfig, '/test/repo', {
-                timeBudgetMinutes: 60,
-                maxTicks: 25,
-                collisionPolicy: 'serialize'
-            });
-            state.status = 'stopped';
-            state.ended_at = new Date().toISOString();
-            const stopArtifact = buildStopArtifact(state, '/test/repo');
-            expect(stopArtifact.schema_version).toBe(ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION);
-            expect(stopArtifact.schema_version).toBe(1);
-        });
-    });
-    describe('Schema version constant', () => {
-        it('ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION is 1', () => {
-            expect(ORCHESTRATOR_ARTIFACT_SCHEMA_VERSION).toBe(1);
-        });
-    });
-});