@taskforcehq/taskforce 0.3.168

package/dist/__tests__/structuredDocValidation.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { validateStructuredDocForAttach } from '../mcp/structuredDocValidation';
+describe('structured doc attach validation', () => {
+    it('passes non-structured paths', () => {
+        const result = validateStructuredDocForAttach('notes/random.md', '# anything');
+        expect(result).toEqual({ ok: true });
+    });
+    it('passes evaluation docs with all required headings', () => {
+        const content = [
+            '## Evaluation Summary',
+            '### Recommendation (Proceed | Pivot | Kill)',
+            '### Value Score (1-5)',
+            '### Risk Score (1-5)',
+            '### Alternatives Considered',
+            '### Key Tradeoffs',
+            '### Next Step'
+        ].join('\n');
+        const result = validateStructuredDocForAttach('.taskforce/task-data/task-1/evaluations/evaluation.md', content);
+        expect(result).toEqual({ ok: true });
+    });
+    it('fails review docs missing required headings', () => {
+        const content = ['## Review Verdict', '### Findings'].join('\n');
+        const result = validateStructuredDocForAttach('.taskforce/task-data/task-1/reviews/review.md', content);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.message).toContain('### Verdict (PASS | WARN | FAIL)');
+            expect(result.message).toContain('### Regression Risks');
+        }
+    });
+});

package/dist/__tests__/templateEngine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/templateEngine.test.js

@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TemplateEngine } from '../services/templateEngine';
+import fs from 'fs';
+// Explicitly mock fs
+vi.mock('fs', () => ({
+    default: {
+        existsSync: vi.fn(),
+        readFileSync: vi.fn()
+    },
+    existsSync: vi.fn(),
+    readFileSync: vi.fn()
+}));
+// Mock formatTransformers
+vi.mock('../services/formatTransformers', () => ({
+    formatTransformers: {
+        toToml: (content, metadata) => `prompt = """${content}"""\ndescription = "${metadata.description}"`,
+        toMarkdown: (content) => content
+    }
+}));
+describe('TemplateEngine', () => {
+    let engine;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        // Inject a mock base directory
+        engine = new TemplateEngine('/templates');
+    });
+    it('should load and process a template with default content', () => {
+        const mockTemplate = `
+name: test-workflow
+description: Test Description
+type: workflow
+content:
+  default: |
+    # Test Workflow
+    Step 1
+`;
+        const mockEnv = `
+id: test-env
+name: Test Env
+workflows:
+  directory: .test/workflows
+  format: markdown
+  filenamePattern: "{name}.md"
+mcp:
+  prefix: "mcp_"
+`;
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            const p = filePath.toString();
+            // path.join might use platform specific separators, normalize for check
+            if (p.includes('test-workflow.yaml'))
+                return mockTemplate;
+            if (p.includes('test-env.yaml'))
+                return mockEnv;
+            return '';
+        });
+        const result = engine.processTemplate('test-workflow', 'test-env');
+        expect(result.filename).toBe('test-workflow.md');
+        expect(result.content).toContain('# Test Workflow');
+    });
+    it('should substitute variables', () => {
+        const mockTemplate = `
+name: vars-workflow
+description: Desc
+type: workflow
+content:
+  default: "Run {{MCP_PREFIX}}command with {{CUSTOM_VAR}}"
+`;
+        const mockEnv = `
+id: env-1
+name: Env 1
+workflows:
+  directory: .dir
+  format: markdown
+  filenamePattern: "{name}.md"
+mcp:
+  prefix: "my_prefix_"
+`;
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            const p = filePath.toString();
+            if (p.includes('vars-workflow.yaml'))
+                return mockTemplate;
+            if (p.includes('env-1.yaml'))
+                return mockEnv;
+            return '';
+        });
+        const result = engine.processTemplate('vars-workflow', 'env-1', { CUSTOM_VAR: 'custom_value' });
+        expect(result.content).toBe('Run my_prefix_command with custom_value');
+    });
+    it('should use environment-specific content if available', () => {
+        const mockTemplate = `
+name: multi-env
+description: Desc
+type: workflow
+content:
+  default: "Default Content"
+  special-env: "Special Content"
+`;
+        const mockEnv = `
+id: special-env
+name: Special Env
+workflows:
+  directory: .dir
+  format: markdown
+  filenamePattern: "{name}.md"
+`;
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            const p = filePath.toString();
+            if (p.includes('multi-env.yaml'))
+                return mockTemplate;
+            if (p.includes('special-env.yaml'))
+                return mockEnv;
+            return '';
+        });
+        const result = engine.processTemplate('multi-env', 'special-env');
+        expect(result.content).toBe('Special Content');
+    });
+    it('should apply TOML transformation', () => {
+        const mockTemplate = `
+name: toml-test
+description: My Description
+type: workflow
+content:
+  default: "Simple Content"
+`;
+        const mockEnv = `
+id: gemini
+name: Gemini
+workflows:
+  directory: .gemini
+  format: toml
+  filenamePattern: "{name}.toml"
+`;
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            const p = filePath.toString();
+            if (p.includes('toml-test.yaml'))
+                return mockTemplate;
+            if (p.includes('gemini.yaml'))
+                return mockEnv;
+            return '';
+        });
+        const result = engine.processTemplate('toml-test', 'gemini');
+        expect(result.filename).toBe('toml-test.toml');
+        expect(result.content).toContain('prompt = """Simple Content"""');
+        expect(result.content).toContain('description = "My Description"');
+    });
+});

package/dist/__tests__/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/templates.test.js

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { TemplateEngine } from '../services/templateEngine';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Compute the real path to templates
+// src/__tests__/templates.test.ts -> src/resources/templates
+const realTemplatesDir = path.resolve(__dirname, '../resources/templates');
+describe('Workflow Templates Integration', () => {
+    const engine = new TemplateEngine(realTemplatesDir);
+    // Workflows that use MCP tools
+    const mcpWorkflows = ['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review'];
+    mcpWorkflows.forEach(name => {
+        it(`should successfully load and process '${name}' template`, () => {
+            // 1. Load raw template
+            const template = engine.loadTemplate(name);
+            expect(template.name).toBe(name);
+            expect(template.content.default).toBeDefined();
+            expect(template.content.default.length).toBeGreaterThan(10);
+            // 2. Process for Antigravity (Markdown)
+            // Note: Environment config dictates MCP_PREFIX, so we expect the one from antigravity.yaml
+            const mdResult = engine.processTemplate(name, 'antigravity');
+            expect(mdResult.filename).toBe(`${name}.md`);
+            expect(mdResult.content).toContain('mcp_taskforce-taskforce_'); // default prefix
+            // 3. Process for Gemini (TOML)
+            const tomlResult = engine.processTemplate(name, 'gemini');
+            expect(tomlResult.filename).toBe(`${name}.toml`);
+            expect(tomlResult.content).toContain('prompt = """');
+            expect(tomlResult.content).toContain('description = "');
+            expect(tomlResult.content).toContain('mcp_taskforce-taskforce_');
+        });
+    });
+    // Release workflow template was removed; build identity is now metadata-driven.
+    it('codex environment routes do workflow into AGENTS.md via inject override', () => {
+        const result = engine.processTemplate('do', 'codex');
+        expect(result.filename).toBe('AGENTS.md');
+        expect(result.strategy).toBe('inject');
+        expect(result.content).toContain('mcp_taskforce-taskforce_');
+    });
+    it('sanitizes invalid projectName characters in MCP prefix variables', () => {
+        const result = engine.processTemplate('do', 'codex', { projectName: '@taskforcehq/taskforce' });
+        expect(result.content).toContain('mcp_taskforce-taskforcehq-taskforce_');
+        expect(result.content).not.toContain('mcp_taskforce-@taskforcehq/taskforce_');
+    });
+});

package/dist/__tests__/workflowDocumentFixtures.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowDocumentFixtures.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { validateStructuredDocForAttach } from '../mcp/structuredDocValidation';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.resolve(__dirname, 'fixtures/workflow-docs');
+function assertOrderedAndNonEmpty(content, headings) {
+    let cursor = 0;
+    for (let i = 0; i < headings.length; i++) {
+        const heading = headings[i];
+        const start = content.indexOf(heading, cursor);
+        expect(start, `Missing heading: ${heading}`).toBeGreaterThanOrEqual(0);
+        const nextHeading = headings[i + 1];
+        const end = nextHeading ? content.indexOf(nextHeading, start + heading.length) : content.length;
+        const body = content.slice(start + heading.length, end >= 0 ? end : content.length).trim();
+        if (heading.startsWith('### ')) {
+            expect(body.length, `Section body is empty for: ${heading}`).toBeGreaterThan(0);
+        }
+        cursor = start + heading.length;
+    }
+}
+describe('Workflow document fixtures', () => {
+    it('sample implementation plan is complete and valid for attach', () => {
+        const relativePath = '.taskforce/task-data/task-1/implementation_plans/implementation-plan.md';
+        const content = fs.readFileSync(path.join(fixturesDir, 'sample-implementation-plan.md'), 'utf8');
+        expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
+        assertOrderedAndNonEmpty(content, [
+            '## Implementation Plan',
+            '### Goal',
+            '### Change Plan',
+            '### Risk Analysis',
+            '### Verification Checklist'
+        ]);
+    });
+    it('sample evaluation is complete and valid for attach', () => {
+        const relativePath = '.taskforce/task-data/task-1/evaluations/evaluation.md';
+        const content = fs.readFileSync(path.join(fixturesDir, 'sample-evaluation.md'), 'utf8');
+        expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
+        assertOrderedAndNonEmpty(content, [
+            '## Evaluation Summary',
+            '### Recommendation (Proceed | Pivot | Kill)',
+            '### Value Score (1-5)',
+            '### Risk Score (1-5)',
+            '### Alternatives Considered',
+            '### Key Tradeoffs',
+            '### Next Step'
+        ]);
+    });
+    it('sample review is complete and valid for attach', () => {
+        const relativePath = '.taskforce/task-data/task-1/reviews/review.md';
+        const content = fs.readFileSync(path.join(fixturesDir, 'sample-review.md'), 'utf8');
+        expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
+        assertOrderedAndNonEmpty(content, [
+            '## Review Verdict',
+            '### Verdict (PASS | WARN | FAIL)',
+            '### Findings',
+            '### Regression Risks',
+            '### Required Fixes',
+            '### Recommended Next Status'
+        ]);
+    });
+    it('sample collaboration blueprint is complete and valid for attach', () => {
+        const relativePath = '.taskforce/task-data/task-1/collaborations/collaboration-blueprint.md';
+        const content = fs.readFileSync(path.join(fixturesDir, 'sample-collaboration-blueprint.md'), 'utf8');
+        expect(validateStructuredDocForAttach(relativePath, content)).toEqual({ ok: true });
+        assertOrderedAndNonEmpty(content, [
+            '## Collaboration Blueprint',
+            '### Problem Statement',
+            '### Constraints',
+            '### Proposed Architecture',
+            '### Must-Haves',
+            '### Non-Goals',
+            '### Risks & Open Questions',
+            '### Recommended Next Step'
+        ]);
+    });
+});

package/dist/__tests__/workflowExportMatrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowExportMatrix.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import { TemplateEngine } from '../services/templateEngine';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const templatesDir = path.resolve(__dirname, '../resources/templates');
+const engine = new TemplateEngine(templatesDir);
+const workflowNames = ['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review'];
+const contractHeadings = {
+    plan: [
+        '## Implementation Plan',
+        '### Goal',
+        '### Change Plan',
+        '### Risk Analysis',
+        '### Verification Checklist'
+    ],
+    collaborate: [
+        '## Collaboration Blueprint',
+        '### Problem Statement',
+        '### Constraints',
+        '### Proposed Architecture',
+        '### Must-Haves',
+        '### Non-Goals',
+        '### Risks & Open Questions',
+        '### Recommended Next Step'
+    ],
+    evaluate: [
+        '## Evaluation Summary',
+        '### Recommendation (Proceed | Pivot | Kill)',
+        '### Value Score (1-5)',
+        '### Risk Score (1-5)',
+        '### Alternatives Considered',
+        '### Key Tradeoffs',
+        '### Next Step'
+    ],
+    review: [
+        '## Review Verdict',
+        '### Verdict (PASS | WARN | FAIL)',
+        '### Findings',
+        '### Regression Risks',
+        '### Required Fixes',
+        '### Recommended Next Status'
+    ]
+};
+const summaryCommentHeadings = {
+    plan: [
+        '## Plan Summary',
+        '### Goal',
+        '### Scope',
+        '### Next Action'
+    ],
+    collaborate: [
+        '## Collaboration Summary',
+        '### Architecture Direction',
+        '### Key Constraints',
+        '### Next Step'
+    ],
+    evaluate: [
+        '## Evaluation Summary',
+        '### Recommendation (Proceed | Pivot | Kill)',
+        '### Value Score (1-5)',
+        '### Risk Score (1-5)',
+        '### Next Step'
+    ],
+    review: [
+        '## Review Summary',
+        '### Verdict (PASS | WARN | FAIL)',
+        '### Findings',
+        '### Next Status'
+    ]
+};
+describe('Workflow export matrix', () => {
+    const envDir = path.resolve(templatesDir, 'environments');
+    const envIds = fs.readdirSync(envDir).filter((f) => f.endsWith('.yaml')).map((f) => f.replace('.yaml', ''));
+    it('exports every workflow for every environment with correct format and MCP substitution', () => {
+        for (const envId of envIds) {
+            const env = engine.loadEnvironment(envId);
+            const expectedPrefix = env.mcp?.prefix?.replace('{projectName}', 'taskforce');
+            const expectedExt = env.workflows.format === 'toml' ? '.toml' : env.workflows.format === 'mdc' ? '.mdc' : '.md';
+            for (const workflowName of workflowNames) {
+                const result = engine.processTemplate(workflowName, envId);
+                expect(result.filename.endsWith(expectedExt), `${envId}/${workflowName} extension mismatch`).toBe(true);
+                expect(result.content.includes('{{MCP_PREFIX}}'), `${envId}/${workflowName} has unresolved MCP variable`).toBe(false);
+                if (expectedPrefix) {
+                    expect(result.content.includes(expectedPrefix), `${envId}/${workflowName} missing MCP prefix`).toBe(true);
+                }
+                if (env.workflows.format === 'toml') {
+                    expect(result.content.includes('prompt = """'), `${envId}/${workflowName} expected TOML prompt block`).toBe(true);
+                }
+                else {
+                    expect(result.content.startsWith('---\n'), `${envId}/${workflowName} expected frontmatter`).toBe(true);
+                }
+            }
+        }
+    });
+    it('keeps structured comment output contracts in master templates', () => {
+        for (const [workflowName, headings] of Object.entries(contractHeadings)) {
+            const template = engine.loadTemplate(workflowName);
+            for (const heading of headings) {
+                expect(template.content.default.includes(heading), `${workflowName} missing heading: ${heading}`).toBe(true);
+            }
+        }
+    });
+    it('keeps structured summary comment contracts in master templates', () => {
+        for (const [workflowName, headings] of Object.entries(summaryCommentHeadings)) {
+            const template = engine.loadTemplate(workflowName);
+            for (const heading of headings) {
+                expect(template.content.default.includes(heading), `${workflowName} missing summary heading: ${heading}`).toBe(true);
+            }
+        }
+    });
+});

package/dist/__tests__/workflowExportSnapshots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowExportSnapshots.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { TemplateEngine } from '../services/templateEngine';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const templatesDir = path.resolve(__dirname, '../resources/templates');
+const engine = new TemplateEngine(templatesDir);
+const workflowNames = ['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review'];
+describe('Workflow export snapshots', () => {
+    const envDir = path.resolve(templatesDir, 'environments');
+    const envIds = fs.readdirSync(envDir)
+        .filter((f) => f.endsWith('.yaml'))
+        .map((f) => f.replace('.yaml', ''))
+        .sort();
+    for (const envId of envIds) {
+        for (const workflowName of workflowNames) {
+            it(`${envId}/${workflowName} export snapshot`, () => {
+                const result = engine.processTemplate(workflowName, envId);
+                expect({
+                    filename: result.filename,
+                    strategy: result.strategy,
+                    content: result.content
+                }).toMatchSnapshot();
+            });
+        }
+    }
+});

package/dist/__tests__/workflowGeneration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowGeneration.test.js

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import path from 'path';
+describe('Workflow template generation', () => {
+    it('generated workflow YAML files are up to date', () => {
+        const scriptPath = path.resolve(process.cwd(), 'scripts/generate-workflow-templates.mjs');
+        expect(() => execFileSync('node', [scriptPath, '--check'], {
+            cwd: process.cwd(),
+            stdio: 'pipe'
+        })).not.toThrow();
+    });
+});

package/dist/__tests__/workflowSimulation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/workflowSimulation.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+const workflowsDir = path.resolve(process.cwd(), 'src/resources/templates/workflows');
+function loadWorkflow(name) {
+    const raw = fs.readFileSync(path.join(workflowsDir, `${name}.yaml`), 'utf8');
+    return yaml.load(raw);
+}
+function buildAliasMap(names) {
+    const map = new Map();
+    for (const name of names) {
+        const workflow = loadWorkflow(name);
+        for (const alias of workflow.dispatch?.aliases || []) {
+            map.set(alias, name);
+        }
+    }
+    return map;
+}
+function simulateDoDispatch(params) {
+    const doWorkflow = loadWorkflow('do');
+    const aliasMap = buildAliasMap(['do', 'execute', 'plan', 'evaluate', 'collaborate', 'review']);
+    const calls = [];
+    if (params.knownTaskId) {
+        calls.push({ tool: 'get_task' });
+    }
+    else {
+        calls.push({ tool: 'list_tasks' });
+        calls.push({ tool: 'get_task' });
+    }
+    const explicitRoute = aliasMap.get(params.command);
+    if (explicitRoute && explicitRoute !== 'do') {
+        return { routedTo: explicitRoute, calls };
+    }
+    const mapped = params.approach ? doWorkflow.dispatch?.approachMap?.[params.approach] : undefined;
+    return {
+        routedTo: mapped || doWorkflow.dispatch?.default || 'execute',
+        calls
+    };
+}
+function simulateExecuteFlow(params) {
+    const calls = [{ tool: 'update_task', args: { status: 'in-progress' } }];
+    const requested = params.explicitFinalStatus;
+    if (!requested) {
+        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
+        calls.push({ tool: 'update_task', args: { status: 'review' } });
+        return calls;
+    }
+    if ((requested === 'done' || requested === 'cancelled') && !params.explicitUserInstructionForDoneOrCancelled) {
+        throw new Error('Blocked unsafe status transition');
+    }
+    if (requested === 'task' || requested === 'on-hold') {
+        calls.push({ tool: 'add_comment', args: { kind: 'status-justification' } });
+    }
+    else {
+        calls.push({ tool: 'add_comment', args: { kind: 'summary' } });
+    }
+    calls.push({ tool: 'update_task', args: { status: requested } });
+    return calls;
+}
+function simulateOptionalArtifactSave(workflowName, approveSave) {
+    const workflow = loadWorkflow(workflowName);
+    const artifact = Object.values(workflow.artifacts || {})[0];
+    const calls = [{ tool: 'render_in_screen' }];
+    if (!artifact || artifact.required || artifact.savePolicy !== 'ask-before-save') {
+        return calls;
+    }
+    calls.push({ tool: 'prompt_save_artifact', args: { path: artifact.path } });
+    if (approveSave) {
+        calls.push({ tool: 'write_file', args: { path: artifact.path } });
+        calls.push({ tool: 'attach_context_file', args: { path: artifact.path } });
+    }
+    return calls;
+}
+describe('Workflow simulation', () => {
+    it('/do routes by approach to execute when approach is implement', () => {
+        const result = simulateDoDispatch({ command: '/do', approach: 'implement', knownTaskId: true });
+        expect(result.routedTo).toBe('execute');
+        expect(result.calls[0].tool).toBe('get_task');
+    });
+    it('/do defaults to execute when approach is missing', () => {
+        const result = simulateDoDispatch({ command: '/do', knownTaskId: true });
+        expect(result.routedTo).toBe('execute');
+    });
+    it('explicit slash command wins over approach routing', () => {
+        const result = simulateDoDispatch({ command: '/review', approach: 'implement', knownTaskId: true });
+        expect(result.routedTo).toBe('review');
+    });
+    it('unknown task id uses list before get', () => {
+        const result = simulateDoDispatch({ command: '/do', approach: 'plan', knownTaskId: false });
+        expect(result.calls.map((c) => c.tool)).toEqual(['list_tasks', 'get_task']);
+    });
+    it('execute flow defaults to in-progress then review', () => {
+        const calls = simulateExecuteFlow({});
+        expect(calls.map((c) => c.tool)).toEqual(['update_task', 'add_comment', 'update_task']);
+        expect(calls[0].args?.status).toBe('in-progress');
+        expect(calls[2].args?.status).toBe('review');
+    });
+    it('execute flow requires justification for task/on-hold final status', () => {
+        const calls = simulateExecuteFlow({ explicitFinalStatus: 'on-hold' });
+        expect(calls[1].args?.kind).toBe('status-justification');
+        expect(calls[2].args?.status).toBe('on-hold');
+    });
+    it('execute flow blocks done/cancelled without explicit user instruction', () => {
+        expect(() => simulateExecuteFlow({ explicitFinalStatus: 'done' })).toThrow('Blocked unsafe status transition');
+    });
+    it('optional artifact flow prompts first and only attaches on approval', () => {
+        const noSave = simulateOptionalArtifactSave('evaluate', false);
+        expect(noSave.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact']);
+        const saved = simulateOptionalArtifactSave('evaluate', true);
+        expect(saved.map((c) => c.tool)).toEqual(['render_in_screen', 'prompt_save_artifact', 'write_file', 'attach_context_file']);
+    });
+});

package/dist/__tests__/workflowV2Policy.test.d.ts

@@ -0,0 +1 @@
+export {};