@diff-review-system/drs 3.3.0 → 4.0.0-rc.4

package/dist/cli/workflow.test.js

@@ -0,0 +1,1410 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { loadConfig } from '../lib/config.js';
+import { exitProcess } from '../lib/exit.js';
+import { runWorkflow, listWorkflows } from './workflow.js';
+const mocks = vi.hoisted(() => {
+    const githubAdapter = {
+        getPullRequest: vi.fn(),
+        getChangedFiles: vi.fn(),
+        getComments: vi.fn(),
+        getInlineComments: vi.fn(),
+        createComment: vi.fn(),
+        updateComment: vi.fn(),
+        deleteComment: vi.fn(),
+        createBulkInlineComments: vi.fn(),
+        addLabels: vi.fn(),
+    };
+    const gitlabAdapter = {
+        getPullRequest: vi.fn(),
+        getChangedFiles: vi.fn(),
+        getComments: vi.fn(),
+        getInlineComments: vi.fn(),
+        createComment: vi.fn(),
+        updateComment: vi.fn(),
+        deleteComment: vi.fn(),
+        createBulkInlineComments: vi.fn(),
+        addLabels: vi.fn(),
+    };
+    return {
+        git: {
+            checkIsRepo: vi.fn(async () => true),
+            diff: vi.fn(async () => 'diff --git a/src/app.ts b/src/app.ts'),
+            raw: vi.fn(async (_args) => ''),
+            add: vi.fn(async () => ''),
+            commit: vi.fn(async () => ({
+                commit: 'abc1234',
+                summary: {
+                    changes: 1,
+                    insertions: 2,
+                    deletions: 0,
+                },
+            })),
+        },
+        simpleGit: vi.fn(),
+        createGitHubClient: vi.fn(() => ({ platform: 'github' })),
+        GitHubPlatformAdapter: vi.fn(() => githubAdapter),
+        githubAdapter,
+        createGitLabClient: vi.fn(() => ({ platform: 'gitlab' })),
+        GitLabPlatformAdapter: vi.fn(() => gitlabAdapter),
+        gitlabAdapter,
+        parseDiff: vi.fn(() => [{ filename: 'src/app.ts', patch: '@@ +1 @@\n+change' }]),
+        getChangedFiles: vi.fn(() => ['src/app.ts']),
+        getFilesWithDiffs: vi.fn(() => [{ filename: 'src/app.ts', patch: '@@ +1 @@\n+change' }]),
+        runtimeClient: {
+            shutdown: vi.fn(async () => undefined),
+        },
+        connectToRuntime: vi.fn(),
+        runDescribeIfEnabled: vi.fn(),
+        enforceRepoBranchMatch: vi.fn(async () => undefined),
+        executeReview: vi.fn(async (_config, source) => ({
+            issues: [],
+            summary: {
+                filesReviewed: source.files.length,
+                issuesFound: 0,
+                bySeverity: {},
+                byCategory: {},
+            },
+            filesReviewed: source.files.length,
+        })),
+        runAgent: vi.fn(async (_config, agent, options) => ({
+            timestamp: '2026-06-16T00:00:00.000Z',
+            agent,
+            response: `${agent}: ${options.prompt ?? 'configured prompt'}`,
+            usage: {
+                agent,
+                success: true,
+                inputTokens: 1,
+                outputTokens: 1,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+                totalTokens: 2,
+                cost: 0,
+                messages: 1,
+            },
+        })),
+    };
+});
+mocks.simpleGit.mockReturnValue(mocks.git);
+vi.mock('simple-git', () => ({
+    default: mocks.simpleGit,
+}));
+vi.mock('../github/client.js', () => ({
+    createGitHubClient: mocks.createGitHubClient,
+}));
+vi.mock('../github/platform-adapter.js', () => ({
+    GitHubPlatformAdapter: mocks.GitHubPlatformAdapter,
+}));
+vi.mock('../gitlab/client.js', () => ({
+    createGitLabClient: mocks.createGitLabClient,
+}));
+vi.mock('../gitlab/platform-adapter.js', () => ({
+    GitLabPlatformAdapter: mocks.GitLabPlatformAdapter,
+}));
+vi.mock('./run-agent.js', () => ({
+    runAgent: mocks.runAgent,
+}));
+vi.mock('../lib/diff-parser.js', () => ({
+    parseDiff: mocks.parseDiff,
+    getChangedFiles: mocks.getChangedFiles,
+    getFilesWithDiffs: mocks.getFilesWithDiffs,
+}));
+vi.mock('../lib/review-orchestrator.js', () => ({
+    connectToRuntime: mocks.connectToRuntime,
+    executeReview: mocks.executeReview,
+    filterIgnoredFiles: (files, config) => files.filter((file) => !(config.review.ignorePatterns ?? []).includes(file)),
+}));
+vi.mock('../lib/description-executor.js', () => ({
+    runDescribeIfEnabled: mocks.runDescribeIfEnabled,
+}));
+vi.mock('../lib/repository-validator.js', () => ({
+    enforceRepoBranchMatch: mocks.enforceRepoBranchMatch,
+    resolveBaseBranch: (_baseBranch, targetBranch) => ({
+        resolvedBaseBranch: targetBranch ? `origin/${targetBranch}` : undefined,
+        source: targetBranch ? 'pr:targetBranch' : undefined,
+    }),
+    getCanonicalDiffCommand: () => 'git diff origin/main origin/feature -- <file>',
+}));
+const baseConfig = {
+    pi: {},
+    agents: { default: { model: 'provider/default-model', skills: [] } },
+    gitlab: { url: '', token: '' },
+    github: { token: '' },
+    review: {
+        agents: ['review/security'],
+        ignorePatterns: [],
+    },
+};
+describe('workflow runner', () => {
+    const tempDirs = [];
+    function createTempDir(prefix) {
+        const dir = mkdtempSync(join(tmpdir(), prefix));
+        tempDirs.push(dir);
+        return dir;
+    }
+    function createMockAgentResult(agent, response) {
+        return {
+            timestamp: '2026-06-16T00:00:00.000Z',
+            agent,
+            response,
+            usage: {
+                agent,
+                success: true,
+                inputTokens: 1,
+                outputTokens: 1,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+                totalTokens: 2,
+                cost: 0,
+                messages: 1,
+            },
+        };
+    }
+    function timeoutAfter(ms) {
+        return new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`Timed out after ${ms}ms`)), ms);
+        });
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.simpleGit.mockReturnValue(mocks.git);
+        mocks.git.checkIsRepo.mockResolvedValue(true);
+        mocks.git.diff.mockResolvedValue('diff --git a/src/app.ts b/src/app.ts');
+        mocks.git.raw.mockResolvedValue('');
+        mocks.git.add.mockResolvedValue('');
+        mocks.git.commit.mockResolvedValue({
+            commit: 'abc1234',
+            summary: {
+                changes: 1,
+                insertions: 2,
+                deletions: 0,
+            },
+        });
+        mocks.parseDiff.mockReturnValue([{ filename: 'src/app.ts', patch: '@@ +1 @@\n+change' }]);
+        mocks.getChangedFiles.mockReturnValue(['src/app.ts']);
+        mocks.getFilesWithDiffs.mockReturnValue([
+            { filename: 'src/app.ts', patch: '@@ +1 @@\n+change' },
+        ]);
+        mocks.runtimeClient.shutdown.mockResolvedValue(undefined);
+        mocks.connectToRuntime.mockResolvedValue(mocks.runtimeClient);
+        mocks.runDescribeIfEnabled.mockResolvedValue({
+            type: 'feature',
+            title: 'Generated description',
+            summary: ['Describe the change'],
+        });
+        mocks.enforceRepoBranchMatch.mockResolvedValue(undefined);
+        mocks.createGitHubClient.mockReturnValue({ platform: 'github' });
+        mocks.GitHubPlatformAdapter.mockReturnValue(mocks.githubAdapter);
+        mocks.githubAdapter.getPullRequest.mockResolvedValue({
+            number: 7,
+            title: 'GitHub PR',
+            author: 'octocat',
+            sourceBranch: 'feature',
+            targetBranch: 'main',
+            headSha: 'abc123',
+        });
+        mocks.githubAdapter.getChangedFiles.mockResolvedValue([
+            {
+                filename: 'src/github.ts',
+                status: 'modified',
+                additions: 2,
+                deletions: 1,
+                patch: '@@ +1 @@\n+github',
+            },
+        ]);
+        mocks.githubAdapter.getComments.mockResolvedValue([]);
+        mocks.githubAdapter.getInlineComments.mockResolvedValue([]);
+        mocks.githubAdapter.createComment.mockResolvedValue(undefined);
+        mocks.githubAdapter.updateComment.mockResolvedValue(undefined);
+        mocks.githubAdapter.deleteComment.mockResolvedValue(undefined);
+        mocks.githubAdapter.createBulkInlineComments.mockResolvedValue(undefined);
+        mocks.githubAdapter.addLabels.mockResolvedValue(undefined);
+        mocks.createGitLabClient.mockReturnValue({ platform: 'gitlab' });
+        mocks.GitLabPlatformAdapter.mockReturnValue(mocks.gitlabAdapter);
+        mocks.gitlabAdapter.getPullRequest.mockResolvedValue({
+            number: 8,
+            title: 'GitLab MR',
+            author: 'gitlab-user',
+            sourceBranch: 'feature',
+            targetBranch: 'main',
+            headSha: 'def456',
+        });
+        mocks.gitlabAdapter.getChangedFiles.mockResolvedValue([
+            {
+                filename: 'src/gitlab.ts',
+                status: 'modified',
+                additions: 3,
+                deletions: 1,
+                patch: '@@ +1 @@\n+gitlab',
+            },
+        ]);
+        mocks.gitlabAdapter.getComments.mockResolvedValue([]);
+        mocks.gitlabAdapter.getInlineComments.mockResolvedValue([]);
+        mocks.gitlabAdapter.createComment.mockResolvedValue(undefined);
+        mocks.gitlabAdapter.updateComment.mockResolvedValue(undefined);
+        mocks.gitlabAdapter.deleteComment.mockResolvedValue(undefined);
+        mocks.gitlabAdapter.createBulkInlineComments.mockResolvedValue(undefined);
+        mocks.gitlabAdapter.addLabels.mockResolvedValue(undefined);
+        mocks.executeReview.mockImplementation(async (_config, source) => ({
+            issues: [],
+            summary: {
+                filesReviewed: source.files.length,
+                issuesFound: 0,
+                bySeverity: {},
+                byCategory: {},
+            },
+            filesReviewed: source.files.length,
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        for (const dir of tempDirs.splice(0, tempDirs.length)) {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it('runs agent and write nodes in dependency order', async () => {
+        const projectRoot = createTempDir('drs-workflow-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                release: {
+                    inputs: {
+                        diff: 'Diff text',
+                    },
+                    nodes: {
+                        summarize: {
+                            agent: 'task/summarizer',
+                            input: 'Summarize {{inputs.diff}}',
+                            output: 'summary',
+                        },
+                        writeSummary: {
+                            action: 'write',
+                            needs: ['summarize'],
+                            input: 'Summary:\n{{artifacts.summary}}',
+                            writes: 'out/summary.md',
+                            output: 'written',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'release', {
+            workingDir: projectRoot,
+        });
+        expect(mocks.runAgent).toHaveBeenCalledWith(config, 'task/summarizer', expect.objectContaining({
+            prompt: 'Summarize Diff text',
+            quiet: true,
+            allowImplicitStdin: false,
+            ignoreConfiguredOutput: true,
+        }));
+        expect(readFileSync(join(projectRoot, 'out/summary.md'), 'utf-8')).toBe('Summary:\ntask/summarizer: Summarize Diff text');
+        expect(result.output).toBe('Summary:\ntask/summarizer: Summarize Diff text');
+    });
+    it('rejects writes paths that render to empty strings', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                emptyWrite: {
+                    inputs: {
+                        outputPath: '',
+                    },
+                    nodes: {
+                        writeSummary: {
+                            action: 'write',
+                            input: 'content',
+                            writes: '{{inputs.outputPath}}',
+                        },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'emptyWrite')).rejects.toThrow('Workflow node "writeSummary" writes resolved to an empty path.');
+    });
+    it('uses strict boolean checks for node JSON writes', async () => {
+        const projectRoot = createTempDir('drs-workflow-json-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                jsonFlag: {
+                    nodes: {
+                        summarize: {
+                            agent: 'task/summarizer',
+                            input: 'Summarize',
+                            writes: 'summary.txt',
+                            json: 'false',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'jsonFlag', { workingDir: projectRoot });
+        expect(readFileSync(join(projectRoot, 'summary.txt'), 'utf-8')).toBe('task/summarizer: Summarize');
+    });
+    it('lets CLI-style inputs override configured inputs', async () => {
+        const projectRoot = createTempDir('drs-workflow-inputs-');
+        writeFileSync(join(projectRoot, 'diff.md'), 'File diff');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                describe: {
+                    inputs: {
+                        diff: 'Configured diff',
+                        title: 'Configured title',
+                    },
+                    nodes: {
+                        summarize: {
+                            agent: 'task/summarizer',
+                            input: '{{inputs.title}}\n{{inputs.diff}}',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'describe', {
+            inputs: { title: 'CLI title' },
+            inputFiles: { diff: 'diff.md' },
+            workingDir: projectRoot,
+        });
+        expect(mocks.runAgent).toHaveBeenCalledWith(config, 'task/summarizer', expect.objectContaining({
+            prompt: 'CLI title\nFile diff',
+        }));
+    });
+    it('runs agentsFrom review.agents as a multi-agent node', async () => {
+        const config = {
+            ...baseConfig,
+            review: {
+                agents: ['review/security', { name: 'review/quality' }],
+                ignorePatterns: [],
+            },
+            workflows: {
+                review: {
+                    inputs: {
+                        diff: 'Diff text',
+                    },
+                    nodes: {
+                        reviewers: {
+                            agentsFrom: 'review.agents',
+                            input: 'Review {{inputs.diff}}',
+                            output: 'reviewResult',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'review', {
+            workingDir: process.cwd(),
+        });
+        expect(mocks.runAgent).toHaveBeenNthCalledWith(1, config, 'review/security', expect.objectContaining({ prompt: 'Review Diff text' }));
+        expect(mocks.runAgent).toHaveBeenNthCalledWith(2, config, 'review/quality', expect.objectContaining({ prompt: 'Review Diff text' }));
+        expect(result.artifacts.reviewResult).toContain('## review/security');
+        expect(result.artifacts.reviewResult).toContain('## review/quality');
+    });
+    it('runs agentsFrom agents concurrently', async () => {
+        let resolveSecurity = () => { };
+        let resolveQuality = () => { };
+        let resolveBothStarted = () => { };
+        const starts = [];
+        const securityDone = new Promise((resolve) => {
+            resolveSecurity = resolve;
+        });
+        const qualityDone = new Promise((resolve) => {
+            resolveQuality = resolve;
+        });
+        const bothStarted = new Promise((resolve) => {
+            resolveBothStarted = resolve;
+        });
+        mocks.runAgent.mockImplementation(async (_config, agent) => {
+            starts.push(agent);
+            if (starts.length === 2) {
+                resolveBothStarted();
+            }
+            await (agent === 'review/security' ? securityDone : qualityDone);
+            return createMockAgentResult(agent, `${agent} done`);
+        });
+        const config = {
+            ...baseConfig,
+            review: {
+                agents: ['review/security', 'review/quality'],
+                ignorePatterns: [],
+            },
+            workflows: {
+                review: {
+                    inputs: {
+                        diff: 'Diff text',
+                    },
+                    nodes: {
+                        reviewers: {
+                            agentsFrom: 'review.agents',
+                            input: 'Review {{inputs.diff}}',
+                            output: 'reviewResult',
+                        },
+                    },
+                },
+            },
+        };
+        const runPromise = runWorkflow(config, 'review', { workingDir: process.cwd() });
+        await Promise.race([bothStarted, timeoutAfter(250)]);
+        resolveSecurity();
+        resolveQuality();
+        const result = await runPromise;
+        expect(starts).toEqual(['review/security', 'review/quality']);
+        expect(result.artifacts.reviewResult).toContain('review/security done');
+        expect(result.artifacts.reviewResult).toContain('review/quality done');
+    });
+    it('runs independent workflow nodes concurrently', async () => {
+        let resolveOne = () => { };
+        let resolveTwo = () => { };
+        let resolveBothStarted = () => { };
+        const starts = [];
+        const oneDone = new Promise((resolve) => {
+            resolveOne = resolve;
+        });
+        const twoDone = new Promise((resolve) => {
+            resolveTwo = resolve;
+        });
+        const bothStarted = new Promise((resolve) => {
+            resolveBothStarted = resolve;
+        });
+        mocks.runAgent.mockImplementation(async (_config, agent) => {
+            starts.push(agent);
+            if (starts.length === 2) {
+                resolveBothStarted();
+            }
+            await (agent === 'task/one' ? oneDone : twoDone);
+            return createMockAgentResult(agent, `${agent} done`);
+        });
+        const config = {
+            ...baseConfig,
+            workflows: {
+                parallel: {
+                    nodes: {
+                        one: { agent: 'task/one', input: 'one', output: 'one' },
+                        two: { agent: 'task/two', input: 'two', output: 'two' },
+                        join: {
+                            action: 'write',
+                            needs: ['one', 'two'],
+                            input: '{{artifacts.one}}\n{{artifacts.two}}',
+                            writes: 'joined.txt',
+                        },
+                    },
+                },
+            },
+        };
+        const projectRoot = createTempDir('drs-workflow-parallel-');
+        const runPromise = runWorkflow(config, 'parallel', { workingDir: projectRoot });
+        await Promise.race([bothStarted, timeoutAfter(250)]);
+        resolveOne();
+        resolveTwo();
+        await runPromise;
+        expect(starts).toEqual(['task/one', 'task/two']);
+        expect(readFileSync(join(projectRoot, 'joined.txt'), 'utf-8')).toBe('task/one done\ntask/two done');
+    });
+    it('loads local git diff as an action artifact', async () => {
+        const projectRoot = createTempDir('drs-workflow-git-diff-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                localReview: {
+                    nodes: {
+                        diff: {
+                            action: 'git-diff',
+                            with: { staged: true },
+                            output: 'localDiff',
+                        },
+                        summarize: {
+                            agent: 'task/summarizer',
+                            needs: ['diff'],
+                            input: 'Summarize {{artifacts.localDiff}}',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'localReview', {
+            workingDir: projectRoot,
+        });
+        expect(mocks.simpleGit).toHaveBeenCalledWith({ baseDir: projectRoot });
+        expect(mocks.git.diff).toHaveBeenCalledWith(['--cached']);
+        expect(mocks.runAgent).toHaveBeenCalledWith(config, 'task/summarizer', expect.objectContaining({
+            prompt: 'Summarize diff --git a/src/app.ts b/src/app.ts',
+        }));
+    });
+    it('stages paths with a git-add action', async () => {
+        const projectRoot = createTempDir('drs-workflow-git-add-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                stageChangelog: {
+                    nodes: {
+                        stage: {
+                            action: 'git-add',
+                            with: { paths: 'CHANGELOG.md, README.md' },
+                            output: 'stagedPaths',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'stageChangelog', {
+            workingDir: projectRoot,
+        });
+        expect(mocks.git.add).toHaveBeenCalledWith(['CHANGELOG.md', 'README.md']);
+        expect(result.artifacts.stagedPaths).toEqual(['CHANGELOG.md', 'README.md']);
+    });
+    it('commits only configured paths with a git-commit action', async () => {
+        const projectRoot = createTempDir('drs-workflow-git-commit-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                commitChangelog: {
+                    nodes: {
+                        commit: {
+                            action: 'git-commit',
+                            with: {
+                                paths: 'CHANGELOG.md',
+                                message: 'docs: update changelog',
+                            },
+                            output: 'commitResult',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'commitChangelog', {
+            workingDir: projectRoot,
+        });
+        expect(mocks.git.add).toHaveBeenCalledWith(['CHANGELOG.md']);
+        expect(mocks.git.commit).toHaveBeenCalledWith('docs: update changelog', ['CHANGELOG.md']);
+        expect(result.artifacts.commitResult).toMatchObject({
+            commit: 'abc1234',
+            message: 'docs: update changelog',
+            paths: ['CHANGELOG.md'],
+        });
+    });
+    it('rejects git action paths outside the working directory', async () => {
+        const projectRoot = createTempDir('drs-workflow-git-path-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                unsafeStage: {
+                    nodes: {
+                        stage: {
+                            action: 'git-add',
+                            with: { path: '../outside.md' },
+                        },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'unsafeStage', {
+            workingDir: projectRoot,
+        })).rejects.toThrow('Refusing to access outside working directory');
+        expect(mocks.git.add).not.toHaveBeenCalled();
+    });
+    it('loads a local change source and reviews it', async () => {
+        const projectRoot = createTempDir('drs-workflow-review-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                localReview: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: { type: 'local', staged: true },
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewResult',
+                            writes: '.drs/review-result.json',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'localReview', {
+            workingDir: projectRoot,
+            debug: true,
+            thinkingLevel: 'high',
+        });
+        expect(mocks.git.diff).toHaveBeenCalledWith(['--cached']);
+        expect(mocks.parseDiff).toHaveBeenCalledWith('diff --git a/src/app.ts b/src/app.ts');
+        expect(mocks.executeReview).toHaveBeenCalledWith(config, expect.objectContaining({
+            name: 'Local staged diff',
+            files: ['src/app.ts'],
+            filesWithDiffs: [{ filename: 'src/app.ts', patch: '@@ +1 @@\n+change' }],
+            workingDir: projectRoot,
+            staged: true,
+            debug: true,
+            thinkingLevel: 'high',
+        }));
+        expect(result.artifacts.reviewResult).toMatchObject({ filesReviewed: 1 });
+        expect(JSON.parse(readFileSync(join(projectRoot, '.drs/review-result.json'), 'utf-8'))).toMatchObject({
+            filesReviewed: 1,
+        });
+    });
+    it('loads a git range change source from explicit refs', async () => {
+        const projectRoot = createTempDir('drs-workflow-git-range-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                releaseChanges: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: { type: 'git-range', from: 'v3.3.1', to: 'v4.0.0-rc.1' },
+                            output: 'change',
+                        },
+                    },
+                },
+            },
+        };
+        mocks.git.raw.mockResolvedValue('abc123\x1fAda Lovelace\x1f2026-06-16T00:00:00Z\x1fAdd workflow runtime\n');
+        const result = await runWorkflow(config, 'releaseChanges', {
+            workingDir: projectRoot,
+        });
+        expect(mocks.git.diff).toHaveBeenCalledWith(['v3.3.1..v4.0.0-rc.1']);
+        expect(mocks.git.raw).toHaveBeenCalledWith([
+            'log',
+            '--format=%H%x1f%an%x1f%aI%x1f%s',
+            '--no-merges',
+            'v3.3.1..v4.0.0-rc.1',
+        ]);
+        expect(result.artifacts.change).toMatchObject({
+            name: 'Git range v3.3.1..v4.0.0-rc.1',
+            files: ['src/app.ts'],
+            context: {
+                sourceType: 'git-range',
+                fromRef: 'v3.3.1',
+                toRef: 'v4.0.0-rc.1',
+                range: 'v3.3.1..v4.0.0-rc.1',
+                commits: [
+                    {
+                        sha: 'abc123',
+                        author: 'Ada Lovelace',
+                        date: '2026-06-16T00:00:00Z',
+                        subject: 'Add workflow runtime',
+                    },
+                ],
+            },
+        });
+    });
+    it('infers git range refs from a GitHub Actions tag event', async () => {
+        const previousRefType = process.env.GITHUB_REF_TYPE;
+        const previousRefName = process.env.GITHUB_REF_NAME;
+        process.env.GITHUB_REF_TYPE = 'tag';
+        process.env.GITHUB_REF_NAME = 'v4.0.0-rc.1';
+        const projectRoot = createTempDir('drs-workflow-github-tag-range-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                releaseChanges: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: { type: 'git-range' },
+                            output: 'change',
+                        },
+                    },
+                },
+            },
+        };
+        mocks.git.raw.mockImplementation(async (args) => {
+            if (args?.[0] === 'tag') {
+                return 'v4.0.0-rc.1\nv3.3.1\nv3.3.0\n';
+            }
+            return 'def456\x1fGrace Hopper\x1f2026-06-16T00:00:00Z\x1fPrepare 4.0\n';
+        });
+        try {
+            const result = await runWorkflow(config, 'releaseChanges', {
+                workingDir: projectRoot,
+            });
+            expect(mocks.git.raw).toHaveBeenCalledWith([
+                'tag',
+                '--merged',
+                'v4.0.0-rc.1',
+                '--sort=-v:refname',
+            ]);
+            expect(mocks.git.diff).toHaveBeenCalledWith(['v3.3.1..v4.0.0-rc.1']);
+            expect(result.artifacts.change).toMatchObject({
+                name: 'Git range v3.3.1..v4.0.0-rc.1',
+                context: {
+                    fromRef: 'v3.3.1',
+                    toRef: 'v4.0.0-rc.1',
+                },
+            });
+        }
+        finally {
+            if (previousRefType === undefined) {
+                delete process.env.GITHUB_REF_TYPE;
+            }
+            else {
+                process.env.GITHUB_REF_TYPE = previousRefType;
+            }
+            if (previousRefName === undefined) {
+                delete process.env.GITHUB_REF_NAME;
+            }
+            else {
+                process.env.GITHUB_REF_NAME = previousRefName;
+            }
+        }
+    });
+    it('suppresses review action logs when workflow JSON output is enabled', async () => {
+        const logSpy = vi.mocked(console.log);
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        mocks.executeReview.mockImplementation(async (_config, source) => {
+            console.log('review progress');
+            console.warn('review warning');
+            return {
+                issues: [],
+                summary: {
+                    filesReviewed: source.files.length,
+                    issuesFound: 0,
+                    bySeverity: {},
+                    byCategory: {},
+                },
+                filesReviewed: source.files.length,
+            };
+        });
+        const config = {
+            ...baseConfig,
+            workflows: {
+                localReview: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewResult',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'localReview', {
+            jsonOutput: true,
+            workingDir: process.cwd(),
+        });
+        expect(warnSpy).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenCalledTimes(1);
+        expect(() => JSON.parse(String(logSpy.mock.calls[0][0]))).not.toThrow();
+    });
+    it('keeps review action log suppression isolated for concurrent JSON nodes', async () => {
+        const logSpy = vi.mocked(console.log);
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        let resolveFirstStarted = () => { };
+        let resolveFirstCanReturn = () => { };
+        const firstStarted = new Promise((resolve) => {
+            resolveFirstStarted = resolve;
+        });
+        const firstCanReturn = new Promise((resolve) => {
+            resolveFirstCanReturn = resolve;
+        });
+        let reviewCalls = 0;
+        mocks.executeReview.mockImplementation(async (_config, source) => {
+            const callNumber = ++reviewCalls;
+            if (callNumber === 1) {
+                console.log('first review progress');
+                resolveFirstStarted();
+                await firstCanReturn;
+            }
+            else {
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 0);
+                });
+                console.log('second review progress');
+                console.warn('second review warning');
+            }
+            return {
+                issues: [],
+                summary: {
+                    filesReviewed: source.files.length,
+                    issuesFound: 0,
+                    bySeverity: {},
+                    byCategory: {},
+                },
+                filesReviewed: source.files.length,
+            };
+        });
+        const config = {
+            ...baseConfig,
+            workflows: {
+                concurrentReview: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            output: 'change',
+                        },
+                        reviewOne: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewOneResult',
+                        },
+                        reviewTwo: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewTwoResult',
+                        },
+                    },
+                },
+            },
+        };
+        const runPromise = runWorkflow(config, 'concurrentReview', {
+            jsonOutput: true,
+            workingDir: process.cwd(),
+        });
+        await Promise.race([firstStarted, timeoutAfter(250)]);
+        resolveFirstCanReturn();
+        await runPromise;
+        expect(reviewCalls).toBe(2);
+        expect(warnSpy).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenCalledTimes(1);
+        expect(() => JSON.parse(String(logSpy.mock.calls[0][0]))).not.toThrow();
+        expect(console.log).toBe(logSpy);
+    });
+    it('converts review action process exits into workflow errors', async () => {
+        mocks.executeReview.mockImplementation(async () => {
+            exitProcess(1);
+        });
+        const config = {
+            ...baseConfig,
+            workflows: {
+                localReview: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                        },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'localReview')).rejects.toThrow('Workflow review node "review" failed: all review agents failed.');
+    });
+    it('loads a GitHub PR change source and reviews it', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                githubReview: {
+                    inputs: {
+                        owner: '',
+                        repo: '',
+                        pr: '',
+                    },
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'github-pr',
+                                owner: '{{inputs.owner}}',
+                                repo: '{{inputs.repo}}',
+                                pr: '{{inputs.pr}}',
+                            },
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewResult',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'githubReview', {
+            inputs: { owner: 'octocat', repo: 'hello-world', pr: '7' },
+            workingDir: process.cwd(),
+        });
+        expect(mocks.createGitHubClient).toHaveBeenCalled();
+        expect(mocks.GitHubPlatformAdapter).toHaveBeenCalled();
+        expect(mocks.githubAdapter.getPullRequest).toHaveBeenCalledWith('octocat/hello-world', 7);
+        expect(mocks.githubAdapter.getChangedFiles).toHaveBeenCalledWith('octocat/hello-world', 7);
+        expect(mocks.enforceRepoBranchMatch).toHaveBeenCalledWith(process.cwd(), 'octocat/hello-world', expect.objectContaining({ number: 7 }), {
+            skipRepoCheck: undefined,
+            skipBranchCheck: undefined,
+        });
+        expect(mocks.executeReview).toHaveBeenCalledWith(config, expect.objectContaining({
+            name: 'GitHub PR octocat/hello-world#7',
+            files: ['src/github.ts'],
+            filesWithDiffs: [{ filename: 'src/github.ts', patch: '@@ +1 @@\n+github' }],
+            context: expect.objectContaining({
+                platform: 'github',
+                projectId: 'octocat/hello-world',
+            }),
+        }));
+    });
+    it('shows GitHub PR review context with embedded diff content', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                githubContext: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'github-pr',
+                                owner: 'octocat',
+                                repo: 'hello-world',
+                                pr: 7,
+                            },
+                            output: 'change',
+                        },
+                        context: {
+                            action: 'review-context',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewContext',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'githubContext', { workingDir: process.cwd() });
+        expect(result.output).toEqual(expect.stringContaining('## Diff Content'));
+        expect(result.output).toEqual(expect.stringContaining('### src/github.ts'));
+        expect(result.output).toEqual(expect.stringContaining('+github'));
+    });
+    it('filters review context to a requested file', async () => {
+        mocks.gitlabAdapter.getChangedFiles.mockResolvedValue([
+            {
+                filename: 'src/one.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                patch: '@@ +1 @@\n+one',
+            },
+            {
+                filename: 'src/two.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                patch: '@@ +1 @@\n+two',
+            },
+        ]);
+        const config = {
+            ...baseConfig,
+            workflows: {
+                gitlabContext: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'gitlab-mr',
+                                project: 'group/repo',
+                                mr: 8,
+                            },
+                            output: 'change',
+                        },
+                        context: {
+                            action: 'review-context',
+                            needs: ['change'],
+                            with: { source: 'change', file: 'src/two.ts' },
+                            output: 'reviewContext',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'gitlabContext', { workingDir: process.cwd() });
+        expect(result.output).toEqual(expect.stringContaining('### src/two.ts'));
+        expect(result.output).toEqual(expect.stringContaining('+two'));
+        expect(result.output).not.toEqual(expect.stringContaining('### src/one.ts'));
+    });
+    it('generates and posts a GitHub PR description from workflow artifacts', async () => {
+        const projectRoot = createTempDir('drs-workflow-describe-');
+        const config = {
+            ...baseConfig,
+            workflows: {
+                githubDescribe: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'github-pr',
+                                owner: 'octocat',
+                                repo: 'hello-world',
+                                pr: 7,
+                            },
+                            output: 'change',
+                        },
+                        describe: {
+                            action: 'describe',
+                            needs: ['change'],
+                            with: { source: 'change', post: true },
+                            output: 'description',
+                            writes: '.drs/description.json',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'githubDescribe', {
+            workingDir: projectRoot,
+            debug: true,
+            thinkingLevel: 'high',
+        });
+        expect(mocks.connectToRuntime).toHaveBeenCalledWith(config, projectRoot, expect.objectContaining({
+            debug: true,
+            thinkingLevel: 'high',
+        }));
+        expect(mocks.runDescribeIfEnabled).toHaveBeenCalledWith(mocks.runtimeClient, config, mocks.githubAdapter, 'octocat/hello-world', expect.objectContaining({ number: 7 }), [{ filename: 'src/github.ts', patch: '@@ +1 @@\n+github' }], true, projectRoot, true);
+        expect(mocks.runtimeClient.shutdown).toHaveBeenCalled();
+        expect(result.artifacts.description).toMatchObject({ title: 'Generated description' });
+        expect(JSON.parse(readFileSync(join(projectRoot, '.drs/description.json'), 'utf-8'))).toEqual(result.artifacts.description);
+    });
+    it('updates an existing marked platform comment', async () => {
+        mocks.githubAdapter.getComments.mockResolvedValue([
+            { id: 9, body: '<!-- drs-comment-id: release-notes -->\nold body' },
+        ]);
+        const config = {
+            ...baseConfig,
+            workflows: {
+                postComment: {
+                    nodes: {
+                        comment: {
+                            action: 'post-comment',
+                            input: 'new body',
+                            with: {
+                                platform: 'github',
+                                owner: 'octocat',
+                                repo: 'hello-world',
+                                pr: 7,
+                                marker: 'release-notes',
+                            },
+                            output: 'commentResult',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'postComment', { workingDir: process.cwd() });
+        expect(mocks.githubAdapter.updateComment).toHaveBeenCalledWith('octocat/hello-world', 7, 9, '<!-- drs-comment-id: release-notes -->\nnew body');
+        expect(mocks.githubAdapter.createComment).not.toHaveBeenCalled();
+        expect(result.artifacts.commentResult).toMatchObject({
+            platform: 'github',
+            projectId: 'octocat/hello-world',
+            prNumber: 7,
+            marker: 'release-notes',
+            operation: 'updated',
+        });
+    });
+    it('posts GitHub review comments from workflow review artifacts', async () => {
+        mocks.githubAdapter.getChangedFiles.mockResolvedValue([
+            {
+                filename: 'src/github.ts',
+                status: 'modified',
+                additions: 1,
+                deletions: 0,
+                patch: '@@ -0,0 +1 @@\n+github',
+            },
+        ]);
+        mocks.executeReview.mockImplementation(async () => ({
+            issues: [
+                {
+                    category: 'QUALITY',
+                    severity: 'HIGH',
+                    title: 'Validate input',
+                    file: 'src/github.ts',
+                    line: 1,
+                    problem: 'Input is not validated.',
+                    solution: 'Validate it before use.',
+                    agent: 'review/quality',
+                },
+            ],
+            summary: {
+                filesReviewed: 1,
+                issuesFound: 1,
+                bySeverity: { CRITICAL: 0, HIGH: 1, MEDIUM: 0, LOW: 0 },
+                byCategory: { SECURITY: 0, QUALITY: 1, STYLE: 0, PERFORMANCE: 0, DOCUMENTATION: 0 },
+            },
+            filesReviewed: 1,
+        }));
+        const config = {
+            ...baseConfig,
+            workflows: {
+                githubReview: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'github-pr',
+                                owner: 'octocat',
+                                repo: 'hello-world',
+                                pr: 7,
+                            },
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'review',
+                        },
+                        post: {
+                            action: 'post-review-comments',
+                            needs: ['review'],
+                            with: {
+                                source: 'change',
+                                review: 'review',
+                            },
+                            output: 'postResult',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'githubReview', { workingDir: process.cwd() });
+        expect(mocks.githubAdapter.deleteComment).not.toHaveBeenCalled();
+        expect(mocks.githubAdapter.createComment).toHaveBeenCalledWith('octocat/hello-world', 7, expect.stringContaining('<!-- drs-comment-id: drs-review-summary -->'));
+        expect(mocks.githubAdapter.createBulkInlineComments).toHaveBeenCalledWith('octocat/hello-world', 7, [
+            expect.objectContaining({
+                body: expect.stringContaining('<!-- issue-fp: src/github.ts:1:QUALITY:Validate input -->'),
+                position: {
+                    path: 'src/github.ts',
+                    line: 1,
+                    commitSha: 'abc123',
+                },
+            }),
+        ]);
+        expect(mocks.githubAdapter.addLabels).toHaveBeenCalledWith('octocat/hello-world', 7, [
+            'ai-reviewed',
+        ]);
+        expect(result.artifacts.postResult).toMatchObject({
+            platform: 'github',
+            projectId: 'octocat/hello-world',
+            prNumber: 7,
+            issues: 1,
+        });
+    });
+    it('writes a GitLab code quality report from workflow review artifacts', async () => {
+        const projectRoot = createTempDir('drs-workflow-code-quality-');
+        mocks.executeReview.mockImplementation(async () => ({
+            issues: [
+                {
+                    category: 'QUALITY',
+                    severity: 'HIGH',
+                    title: 'Validate input',
+                    file: 'src/gitlab.ts',
+                    line: 1,
+                    problem: 'Input is not validated.',
+                    solution: 'Validate it before use.',
+                    agent: 'review/quality',
+                },
+            ],
+            summary: {
+                filesReviewed: 1,
+                issuesFound: 1,
+                bySeverity: { CRITICAL: 0, HIGH: 1, MEDIUM: 0, LOW: 0 },
+                byCategory: { SECURITY: 0, QUALITY: 1, STYLE: 0, PERFORMANCE: 0, DOCUMENTATION: 0 },
+            },
+            filesReviewed: 1,
+        }));
+        const config = {
+            ...baseConfig,
+            workflows: {
+                codeQuality: {
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'gitlab-mr',
+                                project: 'group/repo',
+                                mr: 8,
+                            },
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'review',
+                        },
+                        report: {
+                            action: 'code-quality-report',
+                            needs: ['review'],
+                            with: {
+                                review: 'review',
+                                path: 'gl-code-quality-report.json',
+                            },
+                            output: 'codeQualityReport',
+                        },
+                    },
+                },
+            },
+        };
+        const result = await runWorkflow(config, 'codeQuality', { workingDir: projectRoot });
+        const report = JSON.parse(readFileSync(join(projectRoot, 'gl-code-quality-report.json'), 'utf-8'));
+        expect(report).toEqual([
+            expect.objectContaining({
+                check_name: 'drs-quality',
+                severity: 'critical',
+                location: {
+                    path: 'src/gitlab.ts',
+                    lines: { begin: 1 },
+                },
+            }),
+        ]);
+        expect(result.artifacts.codeQualityReport).toMatchObject({
+            path: 'gl-code-quality-report.json',
+            issues: 1,
+        });
+    });
+    it('loads a GitLab MR change source and reviews it', async () => {
+        const config = {
+            ...baseConfig,
+            review: {
+                ...baseConfig.review,
+                skipRepoCheck: true,
+                skipBranchCheck: true,
+            },
+            workflows: {
+                gitlabReview: {
+                    inputs: {
+                        project: '',
+                        mr: '',
+                    },
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'gitlab-mr',
+                                project: '{{inputs.project}}',
+                                mr: '{{inputs.mr}}',
+                            },
+                            output: 'change',
+                        },
+                        review: {
+                            action: 'review',
+                            needs: ['change'],
+                            with: { source: 'change' },
+                            output: 'reviewResult',
+                        },
+                    },
+                },
+            },
+        };
+        await runWorkflow(config, 'gitlabReview', {
+            inputs: { project: 'group/repo', mr: '8' },
+            workingDir: process.cwd(),
+        });
+        expect(mocks.createGitLabClient).toHaveBeenCalled();
+        expect(mocks.GitLabPlatformAdapter).toHaveBeenCalled();
+        expect(mocks.gitlabAdapter.getPullRequest).toHaveBeenCalledWith('group/repo', 8);
+        expect(mocks.gitlabAdapter.getChangedFiles).toHaveBeenCalledWith('group/repo', 8);
+        expect(mocks.enforceRepoBranchMatch).toHaveBeenCalledWith(process.cwd(), 'group/repo', expect.objectContaining({ number: 8 }), {
+            skipRepoCheck: true,
+            skipBranchCheck: true,
+        });
+        expect(mocks.executeReview).toHaveBeenCalledWith(config, expect.objectContaining({
+            name: 'GitLab MR group/repo!8',
+            files: ['src/gitlab.ts'],
+            filesWithDiffs: [{ filename: 'src/gitlab.ts', patch: '@@ +1 @@\n+gitlab' }],
+            context: expect.objectContaining({
+                platform: 'gitlab',
+                projectId: 'group/repo',
+            }),
+        }));
+    });
+    it('rejects empty GitLab MR aliases without falling through to mrIid', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                gitlabReview: {
+                    inputs: {
+                        project: 'group/repo',
+                        mr: '',
+                    },
+                    nodes: {
+                        change: {
+                            action: 'change-source',
+                            with: {
+                                type: 'gitlab-mr',
+                                project: '{{inputs.project}}',
+                                mr: '{{inputs.mr}}',
+                            },
+                            output: 'change',
+                        },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'gitlabReview')).rejects.toThrow('Workflow node "change" must define with.mr.');
+        expect(mocks.gitlabAdapter.getPullRequest).not.toHaveBeenCalled();
+    });
+    it('rejects dependency cycles', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                cyclic: {
+                    nodes: {
+                        first: { agent: 'task/first', input: 'first', needs: ['second'] },
+                        second: { agent: 'task/second', input: 'second', needs: ['first'] },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'cyclic')).rejects.toThrow('dependency cycle');
+        expect(mocks.runAgent).not.toHaveBeenCalled();
+    });
+    it('rejects workflows with invalid nodes config', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                invalid: {
+                    nodes: 'not an object',
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'invalid')).rejects.toThrow('Workflow "invalid" must define at least one node.');
+    });
+    it('rejects unknown template references', async () => {
+        const config = {
+            ...baseConfig,
+            workflows: {
+                badTemplate: {
+                    nodes: {
+                        summarize: { agent: 'task/summarizer', input: '{{inputs.missing}}' },
+                    },
+                },
+            },
+        };
+        await expect(runWorkflow(config, 'badTemplate')).rejects.toThrow('Unknown workflow template value "{{inputs.missing}}"');
+        expect(mocks.runAgent).not.toHaveBeenCalled();
+    });
+    it('lists workflows with packaged source by default', () => {
+        const config = loadConfig(process.cwd());
+        const entries = listWorkflows(config, { workingDir: process.cwd() });
+        expect(entries.some((entry) => entry.source === 'packaged' && !entry.overridden)).toBe(true);
+    });
+    it('lists project workflows that override packaged ones', () => {
+        const projectRoot = createTempDir('drs-workflow-list-');
+        mkdirSync(join(projectRoot, '.drs', 'workflows'), { recursive: true });
+        writeFileSync(join(projectRoot, '.drs', 'workflows', 'local-review.yaml'), 'description: Project override\nnodes:\n  step:\n    action: write\n    input: hi\n    writes: out.txt\n', 'utf-8');
+        const config = loadConfig(projectRoot);
+        const entries = listWorkflows(config, { workingDir: projectRoot });
+        const localReview = entries.find((entry) => entry.name === 'local-review');
+        expect(localReview).toMatchObject({
+            source: 'project',
+            overridden: true,
+            description: 'Project override',
+        });
+    });
+});
+//# sourceMappingURL=workflow.test.js.map