workspace-maxxing 0.1.0

package/tests/scaffold.test.ts

@@ -0,0 +1,238 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { scaffoldWorkspace, ScaffoldOptions } from '../src/scripts/scaffold';
+
+describe('scaffold', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffold-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('scaffoldWorkspace', () => {
+    it('creates output directory', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      expect(fs.existsSync(outputDir)).toBe(true);
+    });
+
+    it('creates SYSTEM.md with folder map', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      const systemMd = fs.readFileSync(path.join(outputDir, 'SYSTEM.md'), 'utf-8');
+      expect(systemMd).toContain('## Folder Map');
+      expect(systemMd).toContain('01-research');
+      expect(systemMd).toContain('02-analysis');
+      expect(systemMd).toContain('03-report');
+    });
+
+    it('creates CONTEXT.md at root level', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      const contextMd = fs.readFileSync(path.join(outputDir, 'CONTEXT.md'), 'utf-8');
+      expect(contextMd).toContain('## Task Routing');
+      expect(contextMd).toContain('01-research');
+      expect(contextMd).toContain('02-analysis');
+      expect(contextMd).toContain('03-report');
+    });
+
+    it('creates robust SYSTEM.md sections for workflow-following prompts', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      scaffoldWorkspace({
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      });
+
+      const systemMd = fs.readFileSync(path.join(outputDir, 'SYSTEM.md'), 'utf-8');
+      expect(systemMd).toContain('## Role');
+      expect(systemMd).toContain('## Folder Map');
+      expect(systemMd).toContain('## Workflow Rules');
+      expect(systemMd).toContain('## Scope Guardrails');
+      expect(systemMd).toContain('## Sequential Execution Protocol');
+      expect(systemMd).toContain('## Stage Boundaries');
+      expect(systemMd).toContain('## Tooling Policy');
+      expect(systemMd.toLowerCase()).toContain('markdown');
+    });
+
+    it('creates robust root CONTEXT.md routing and loading order', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      scaffoldWorkspace({
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      });
+
+      const contextMd = fs.readFileSync(path.join(outputDir, 'CONTEXT.md'), 'utf-8');
+      expect(contextMd).toContain('## How to Use This File');
+      expect(contextMd).toContain('## Task Routing');
+      expect(contextMd).toContain('## Loading Order');
+      expect(contextMd).toContain('## Scope Guardrails');
+      expect(contextMd).toContain('## Sequential Routing Contract');
+      expect(contextMd).toContain('## Stage Handoff Routing');
+      expect(contextMd).toContain('## Escalation');
+
+      expect(contextMd).toContain('01-research/CONTEXT.md');
+      expect(contextMd).toContain('02-analysis/CONTEXT.md');
+      expect(contextMd).toContain('03-report/CONTEXT.md');
+      expect(contextMd).toContain('SYSTEM.md');
+      expect(contextMd.toLowerCase()).toContain('markdown');
+    });
+
+    it('creates numbered stage folders with CONTEXT.md', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research', '02-analysis', '03-report'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      for (const stage of options.stages) {
+        const stageDir = path.join(outputDir, stage);
+        expect(fs.existsSync(stageDir)).toBe(true);
+        const contextMd = fs.readFileSync(path.join(stageDir, 'CONTEXT.md'), 'utf-8');
+        expect(contextMd.trim().length).toBeGreaterThan(0);
+        expect(contextMd).toContain(stage);
+      }
+    });
+
+    it('creates stage CONTEXT.md files with completion and handoff contracts', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const stages = ['01-research', '02-analysis', '03-report'];
+
+      scaffoldWorkspace({
+        name: 'research',
+        stages,
+        output: outputDir,
+      });
+
+      for (let i = 0; i < stages.length; i++) {
+        const stage = stages[i];
+        const nextStage = stages[i + 1];
+        const stageContext = fs.readFileSync(path.join(outputDir, stage, 'CONTEXT.md'), 'utf-8');
+
+        expect(stageContext).toContain('## Purpose');
+        expect(stageContext).toContain('## Inputs');
+        expect(stageContext).toContain('## Outputs');
+        expect(stageContext).toContain('## Dependencies');
+        expect(stageContext).toContain('## Required Evidence');
+        expect(stageContext).toContain('## Completion Criteria');
+        expect(stageContext).toContain('## Handoff');
+        expect(stageContext.toLowerCase()).toContain('markdown');
+        expect(stageContext).toContain('00-meta/execution-log.md');
+
+        if (nextStage) {
+          expect(stageContext).toContain(nextStage);
+        } else {
+          expect(stageContext.toLowerCase()).toContain('final output');
+        }
+      }
+    });
+
+    it('creates 00-meta folder with tools.md', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      const toolsMd = path.join(outputDir, '00-meta', 'tools.md');
+      expect(fs.existsSync(toolsMd)).toBe(true);
+      const content = fs.readFileSync(toolsMd, 'utf-8');
+      expect(content).toContain('## Tool Inventory');
+
+      const executionLogPath = path.join(outputDir, '00-meta', 'execution-log.md');
+      expect(fs.existsSync(executionLogPath)).toBe(true);
+      const executionLog = fs.readFileSync(executionLogPath, 'utf-8');
+      expect(executionLog).toContain('## Stage Checklist');
+      expect(executionLog).toContain('- [ ] 01-research');
+    });
+
+    it('creates README.md', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research'],
+        output: outputDir,
+      };
+
+      scaffoldWorkspace(options);
+
+      const readme = fs.readFileSync(path.join(outputDir, 'README.md'), 'utf-8');
+      expect(readme.trim().length).toBeGreaterThan(0);
+    });
+
+    it('throws if output directory already exists', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      fs.mkdirSync(outputDir, { recursive: true });
+
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research'],
+        output: outputDir,
+      };
+
+      expect(() => scaffoldWorkspace(options)).toThrow('already exists');
+    });
+
+    it('overwrites if force is true', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      fs.mkdirSync(outputDir, { recursive: true });
+      fs.writeFileSync(path.join(outputDir, 'existing.txt'), 'data');
+
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: ['01-research'],
+        output: outputDir,
+        force: true,
+      };
+
+      scaffoldWorkspace(options);
+
+      const systemMd = path.join(outputDir, 'SYSTEM.md');
+      expect(fs.existsSync(systemMd)).toBe(true);
+    });
+
+    it('throws if stages list is empty', () => {
+      const outputDir = path.join(tempDir, 'workspace');
+      const options: ScaffoldOptions = {
+        name: 'research',
+        stages: [],
+        output: outputDir,
+      };
+
+      expect(() => scaffoldWorkspace(options)).toThrow('stages');
+    });
+  });
+});

package/tests/templates-enhanced.test.ts

@@ -0,0 +1,208 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const templatesDir = path.join(__dirname, '..', 'templates', '.workspace-templates');
+const skillsDir = path.join(templatesDir, 'skills');
+
+describe('Shared References', () => {
+  describe('references/ directory', () => {
+    it('contains anti-patterns.md', () => {
+      const filePath = path.join(templatesDir, 'references', 'anti-patterns.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('Rationalization');
+      expect(content).toContain('Thought');
+      expect(content).toContain('Reality');
+    });
+
+    it('contains reporting-format.md', () => {
+      const filePath = path.join(templatesDir, 'references', 'reporting-format.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('skill');
+      expect(content).toContain('status');
+      expect(content).toContain('findings');
+      expect(content).toContain('recommendations');
+      expect(content).toContain('nextSkill');
+    });
+
+    it('contains iron-laws.md', () => {
+      const filePath = path.join(templatesDir, 'references', 'iron-laws.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('NO BUILD WITHOUT PLAN');
+      expect(content).toContain('NO PLAN WITHOUT RESEARCH');
+      expect(content).toContain('NO IMPROVEMENT WITHOUT VALIDATION');
+      expect(content).toContain('NO COMPLETION CLAIM WITHOUT VERIFICATION');
+    });
+  });
+});
+
+describe('Sub-Skills', () => {
+  describe('validation', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'validation', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+
+    it('references validate.ts script', () => {
+      const filePath = path.join(skillsDir, 'validation', 'SKILL.md');
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('validate.ts');
+    });
+  });
+
+  describe('research', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'research', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('architecture', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'architecture', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('prompt-engineering', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'prompt-engineering', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('testing', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'testing', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('iteration', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'iteration', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('tooling', () => {
+    it('has SKILL.md with required sections', () => {
+      const filePath = path.join(skillsDir, 'tooling', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## When to Use');
+      expect(content).toContain('## The Process');
+      expect(content).toContain('## Red Flags');
+      expect(content).toContain('## Report Format');
+      expect(content).toContain('## Integration');
+    });
+  });
+
+  describe('worker', () => {
+    it('documents strict external runner contract and payload schema', () => {
+      const filePath = path.join(skillsDir, 'worker', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('External Runner Contract');
+      expect(content).toContain('--subagent-runner');
+      expect(content).toContain('{skill}');
+      expect(content).toContain('{workspace}');
+      expect(content).toContain('{batchId}');
+      expect(content).toContain('{testCaseId}');
+      expect(content).toContain('report.json');
+    });
+  });
+
+  describe('fixer', () => {
+    it('documents strict external runner contract and payload schema', () => {
+      const filePath = path.join(skillsDir, 'fixer', 'SKILL.md');
+      expect(fs.existsSync(filePath)).toBe(true);
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      expect(content).toContain('External Runner Contract');
+      expect(content).toContain('--subagent-runner');
+      expect(content).toContain('{skill}');
+      expect(content).toContain('{workspace}');
+      expect(content).toContain('{batchId}');
+      expect(content).toContain('{testCaseId}');
+      expect(content).toContain('report.json');
+    });
+  });
+});
+
+describe('Dispatch Script', () => {
+  it('exists in templates scripts directory', () => {
+    const filePath = path.join(templatesDir, 'scripts', 'dispatch.ts');
+    expect(fs.existsSync(filePath)).toBe(true);
+    const content = fs.readFileSync(filePath, 'utf-8');
+    expect(content).toContain('dispatchSkill');
+    expect(content).toContain('DispatchReport');
+  });
+});

package/tests/templates.test.ts

@@ -0,0 +1,219 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const templatesDir = path.join(__dirname, '..', 'templates');
+
+describe('Template files', () => {
+  const requiredFiles = [
+    'SKILL.md',
+    '.workspace-templates/SYSTEM.md',
+    '.workspace-templates/CONTEXT.md',
+    '.workspace-templates/workspace/00-meta/CONTEXT.md',
+    '.workspace-templates/workspace/00-meta/execution-log.md',
+    '.workspace-templates/workspace/01-input/CONTEXT.md',
+    '.workspace-templates/workspace/02-process/CONTEXT.md',
+    '.workspace-templates/workspace/03-output/CONTEXT.md',
+    '.workspace-templates/workspace/README.md',
+  ];
+
+  describe.each(requiredFiles)('%s', (filePath) => {
+    it('exists', () => {
+      const fullPath = path.join(templatesDir, filePath);
+      expect(fs.existsSync(fullPath)).toBe(true);
+    });
+
+    it('is not empty', () => {
+      const fullPath = path.join(templatesDir, filePath);
+      if (!fs.existsSync(fullPath)) {
+        fail(`File does not exist: ${fullPath}`);
+        return;
+      }
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      expect(content.trim().length).toBeGreaterThan(0);
+    });
+  });
+
+  it('SKILL.md contains required sections', () => {
+    const skillPath = path.join(templatesDir, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) {
+      fail('SKILL.md does not exist');
+      return;
+    }
+    const content = fs.readFileSync(skillPath, 'utf-8');
+
+    expect(content).toContain('# Workspace-Maxxing');
+    expect(content).toContain('## Overview');
+    expect(content).toContain('## When to Use');
+    expect(content).toContain('## The Iron Law');
+    expect(content).toContain('## Hybrid Flow');
+    expect(content).toContain('## Sub-Skill Dispatch');
+    expect(content).toContain('## Available Scripts');
+    expect(content).toContain('## Anti-Rationalization Table');
+    expect(content).toContain('## Scope Guardrails');
+    expect(content).toContain('## Integration');
+    expect(content).toContain('## ICM Rules');
+    expect(content).toContain('## Output Format');
+    expect(content).toContain('## Sub-Agent Runner Contract');
+  });
+
+  it('README.md documents strict external runner contract for worker/fixer', () => {
+    const readmePath = path.join(__dirname, '..', 'README.md');
+    expect(fs.existsSync(readmePath)).toBe(true);
+
+    const content = fs.readFileSync(readmePath, 'utf-8');
+    expect(content).toContain('--subagent-runner');
+    expect(content).toContain('{skill}');
+    expect(content.toLowerCase()).toContain('worker/fixer');
+    expect(content.toLowerCase()).toContain('external runner');
+  });
+
+  it('SYSTEM.md contains Layer 0 content', () => {
+    const systemPath = path.join(templatesDir, '.workspace-templates', 'SYSTEM.md');
+    if (!fs.existsSync(systemPath)) {
+      fail('SYSTEM.md does not exist');
+      return;
+    }
+    const content = fs.readFileSync(systemPath, 'utf-8');
+
+    expect(content.toLowerCase()).toContain('folder map');
+    expect(content).toContain('workspace');
+  });
+
+  it('CONTEXT.md contains routing table structure', () => {
+    const contextPath = path.join(templatesDir, '.workspace-templates', 'CONTEXT.md');
+    if (!fs.existsSync(contextPath)) {
+      fail('CONTEXT.md does not exist');
+      return;
+    }
+    const content = fs.readFileSync(contextPath, 'utf-8');
+
+    expect(content).toContain('routing');
+    expect(content).toContain('workspace');
+  });
+
+  it('SYSTEM.md includes robust workflow sections', () => {
+    const systemPath = path.join(templatesDir, '.workspace-templates', 'SYSTEM.md');
+    if (!fs.existsSync(systemPath)) {
+      fail('SYSTEM.md does not exist');
+      return;
+    }
+
+    const content = fs.readFileSync(systemPath, 'utf-8');
+
+    expect(content).toContain('## Role');
+    expect(content).toContain('## Folder Map');
+    expect(content).toContain('## Workflow Rules');
+    expect(content).toContain('## Scope Guardrails');
+    expect(content).toContain('## Sequential Execution Protocol');
+    expect(content).toContain('## Stage Boundaries');
+    expect(content).toContain('## Tooling Policy');
+    expect(content.toLowerCase()).toContain('markdown');
+  });
+
+  it('root CONTEXT.md includes routing, loading order, and handoff routing', () => {
+    const contextPath = path.join(templatesDir, '.workspace-templates', 'CONTEXT.md');
+    if (!fs.existsSync(contextPath)) {
+      fail('CONTEXT.md does not exist');
+      return;
+    }
+
+    const content = fs.readFileSync(contextPath, 'utf-8');
+
+    expect(content).toContain('## How to Use This File');
+    expect(content).toContain('## Task Routing');
+    expect(content).toContain('## Loading Order');
+    expect(content).toContain('## Scope Guardrails');
+    expect(content).toContain('## Sequential Routing Contract');
+    expect(content).toContain('## Stage Handoff Routing');
+    expect(content).toContain('## Escalation');
+    expect(content.toLowerCase()).toContain('markdown');
+  });
+
+  it('stage context templates include completion and handoff sections', () => {
+    const stageFiles = [
+      '.workspace-templates/workspace/01-input/CONTEXT.md',
+      '.workspace-templates/workspace/02-process/CONTEXT.md',
+      '.workspace-templates/workspace/03-output/CONTEXT.md',
+    ];
+
+    for (const file of stageFiles) {
+      const fullPath = path.join(templatesDir, file);
+      if (!fs.existsSync(fullPath)) {
+        fail(`File does not exist: ${fullPath}`);
+        return;
+      }
+
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      expect(content).toContain('## Purpose');
+      expect(content).toContain('## Inputs');
+      expect(content).toContain('## Outputs');
+      expect(content).toContain('## Dependencies');
+      expect(content).toContain('## Required Evidence');
+      expect(content).toContain('## Completion Criteria');
+      expect(content).toContain('## Handoff');
+      expect(content.toLowerCase()).toContain('markdown');
+    }
+  });
+
+  it('execution-log template provides sequential stage checklist format', () => {
+    const logPath = path.join(templatesDir, '.workspace-templates', 'workspace', '00-meta', 'execution-log.md');
+    if (!fs.existsSync(logPath)) {
+      fail('execution-log.md does not exist');
+      return;
+    }
+
+    const content = fs.readFileSync(logPath, 'utf-8');
+    expect(content).toContain('## Stage Checklist');
+    expect(content).toContain('- [ ] 01-input');
+    expect(content).toContain('- [ ] 02-process');
+    expect(content).toContain('- [ ] 03-output');
+  });
+
+  it('template scaffold script generates robust routing and scope sections', () => {
+    const scriptPath = path.join(templatesDir, '.workspace-templates', 'scripts', 'scaffold.ts');
+    if (!fs.existsSync(scriptPath)) {
+      fail('Template scaffold script does not exist');
+      return;
+    }
+
+    const content = fs.readFileSync(scriptPath, 'utf-8');
+    expect(content).toContain('## Workflow Rules');
+    expect(content).toContain('## Scope Guardrails');
+    expect(content).toContain('## Stage Boundaries');
+    expect(content).toContain('## Task Routing');
+    expect(content).toContain('## Loading Order');
+  });
+
+  it('template validate script enforces structural and semantic routing checks', () => {
+    const scriptPath = path.join(templatesDir, '.workspace-templates', 'scripts', 'validate.ts');
+    if (!fs.existsSync(scriptPath)) {
+      fail('Template validate script does not exist');
+      return;
+    }
+
+    const content = fs.readFileSync(scriptPath, 'utf-8');
+    expect(content).toContain('REQUIRED_SYSTEM_HEADINGS');
+    expect(content).toContain('REQUIRED_ROOT_CONTEXT_HEADINGS');
+    expect(content).toContain('Root routing references all numbered stages');
+    expect(content).toContain('dependencies do not point to later stages');
+  });
+
+  it('SKILL.md has YAML frontmatter with name and description', () => {
+    const skillPath = path.join(templatesDir, 'SKILL.md');
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    expect(content).toMatch(/^---\nname:/m);
+    expect(content).toMatch(/description:/);
+  });
+
+  it('SKILL.md references all 7 sub-skills', () => {
+    const skillPath = path.join(templatesDir, 'SKILL.md');
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    expect(content).toContain('validation');
+    expect(content).toContain('research');
+    expect(content).toContain('prompt-engineering');
+    expect(content).toContain('testing');
+    expect(content).toContain('iteration');
+    expect(content).toContain('architecture');
+    expect(content).toContain('tooling');
+  });
+});