workspace-maxxing 0.1.0

package/tests/validation-enhanced.test.ts

@@ -0,0 +1,303 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('enhanced validation sub-skill', () => {
+  const skillPath = path.join(
+    __dirname,
+    '..',
+    'templates',
+    '.workspace-templates',
+    'skills',
+    'validation',
+    'SKILL.md',
+  );
+
+  type FrontmatterValue = string | string[];
+  type ParsedFrontmatter = {
+    boundaryLength: number;
+    fields: Record<string, FrontmatterValue>;
+  };
+
+  const allowedNextSkills = ['fixer', 'orchestrator', 'none'] as const;
+
+  const escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+  const stripOuterQuotes = (value: string): string => value.trim().replace(/^['"]|['"]$/g, '').trim();
+
+  const parseInlineYamlArray = (value: string): string[] =>
+    value
+      .replace(/^\[/, '')
+      .replace(/\]$/, '')
+      .split(',')
+      .map((item) => stripOuterQuotes(item))
+      .filter((item) => item.length > 0);
+
+  const parseFrontmatter = (content: string): ParsedFrontmatter | null => {
+    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+
+    if (!frontmatterMatch) {
+      return null;
+    }
+
+    const fields: Record<string, FrontmatterValue> = {};
+    const lines = frontmatterMatch[1].split(/\r?\n/);
+    let lineIndex = 0;
+
+    while (lineIndex < lines.length) {
+      const line = lines[lineIndex];
+      const keyValueMatch = line.match(/^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/);
+
+      if (!keyValueMatch) {
+        lineIndex += 1;
+        continue;
+      }
+
+      const [, key, rawValue] = keyValueMatch;
+
+      if (key !== 'triggers') {
+        fields[key] = stripOuterQuotes(rawValue);
+        lineIndex += 1;
+        continue;
+      }
+
+      const inlineTriggers = rawValue.trim();
+
+      if (inlineTriggers.length > 0) {
+        fields[key] = /^\[.*\]$/.test(inlineTriggers)
+          ? parseInlineYamlArray(inlineTriggers)
+          : [stripOuterQuotes(inlineTriggers)];
+        lineIndex += 1;
+        continue;
+      }
+
+      const triggerItems: string[] = [];
+      lineIndex += 1;
+
+      while (lineIndex < lines.length) {
+        const candidateLine = lines[lineIndex];
+
+        if (!candidateLine.trim()) {
+          lineIndex += 1;
+          continue;
+        }
+
+        if (/^[A-Za-z][A-Za-z0-9_-]*:\s*/.test(candidateLine)) {
+          break;
+        }
+
+        const listItemMatch = candidateLine.match(/^\s*-\s+(.+?)\s*$/);
+
+        if (listItemMatch) {
+          triggerItems.push(stripOuterQuotes(listItemMatch[1]));
+        }
+
+        lineIndex += 1;
+      }
+
+      fields[key] = triggerItems;
+    }
+
+    return {
+      boundaryLength: frontmatterMatch[0].length,
+      fields,
+    };
+  };
+
+  const getSectionBody = (content: string, heading: string): string | null => {
+    const headingPattern = escapeRegExp(heading);
+    const sectionMatch = content.match(
+      new RegExp(`##\\s+${headingPattern}\\s*\\r?\\n([\\s\\S]*?)(?=\\r?\\n##\\s+|$)`, 'i'),
+    );
+
+    return sectionMatch ? sectionMatch[1] : null;
+  };
+
+  let content = '';
+  let parsedFrontmatter: ParsedFrontmatter | null = null;
+
+  beforeAll(() => {
+    if (fs.existsSync(skillPath)) {
+      content = fs.readFileSync(skillPath, 'utf-8');
+      parsedFrontmatter = parseFrontmatter(content);
+    }
+  });
+
+  it('exists', () => {
+    expect(fs.existsSync(skillPath)).toBe(true);
+  });
+
+  it('has YAML frontmatter at the top with required keys and triggers', () => {
+    expect(parsedFrontmatter).not.toBeNull();
+
+    if (!parsedFrontmatter) {
+      return;
+    }
+
+    expect(parsedFrontmatter.fields.name).toBe('validation');
+
+    const descriptionValue = parsedFrontmatter.fields.description;
+    expect(typeof descriptionValue).toBe('string');
+    expect(String(descriptionValue).trim()).not.toBe('');
+
+    const triggersValue = parsedFrontmatter.fields.triggers;
+    expect(Array.isArray(triggersValue)).toBe(true);
+
+    if (Array.isArray(triggersValue)) {
+      expect(triggersValue.length).toBeGreaterThan(0);
+      for (const trigger of triggersValue) {
+        expect(trigger.trim()).not.toBe('');
+      }
+    }
+
+    const firstHeadingIndex = content.search(/\r?\n##\s+/);
+    expect(firstHeadingIndex).toBeGreaterThan(parsedFrontmatter.boundaryLength - 1);
+
+    const betweenFrontmatterAndFirstHeading = content
+      .slice(parsedFrontmatter.boundaryLength, firstHeadingIndex)
+      .trim();
+    expect(betweenFrontmatterAndFirstHeading).toBe('');
+  });
+
+  it('has required enhanced sections', () => {
+    expect(content).toContain('## Overview');
+    expect(content).toContain('## When to Use');
+    expect(content).toContain('## When Not to Use');
+    expect(content).toContain('## The Iron Law');
+    expect(content).toContain('## The Process');
+    expect(content).toContain('## Batch-Level Validation');
+    expect(content).toContain('## Anti-Rationalization Table');
+    expect(content).toContain('## Sub-Skill Dispatch');
+    expect(content).toContain('## Report Format');
+  });
+
+  it('has the Task 7 validation Iron Law constraints', () => {
+    const ironLawSection = getSectionBody(content, 'The Iron Law');
+
+    expect(ironLawSection).not.toBeNull();
+
+    if (!ironLawSection) {
+      return;
+    }
+
+    expect(ironLawSection).toMatch(/NO\s+SCORE\s+INFLATION/i);
+    expect(ironLawSection).toMatch(/NO\s+SKIPPING\s+FAILURES/i);
+    expect(ironLawSection).toMatch(/NO\s+VALIDATING\s+WITHOUT\s+BENCHMARK/i);
+    expect(ironLawSection).toMatch(/NO\s+PASSING\s+WITHOUT\s+EVIDENCE/i);
+  });
+
+  it('has anti-rationalization guidance tied to scoring and validation discipline', () => {
+    const antiRationalizationSection = getSectionBody(content, 'Anti-Rationalization Table');
+
+    expect(antiRationalizationSection).not.toBeNull();
+
+    if (!antiRationalizationSection) {
+      return;
+    }
+
+    expect(antiRationalizationSection).toContain('| Thought | Reality |');
+    expect(antiRationalizationSection).toMatch(/round\s+up|score\s+inflation/i);
+    expect(antiRationalizationSection).toMatch(/one\s+failure\s+does\s+not\s+matter|every\s+failure\s+matters/i);
+    expect(antiRationalizationSection).toMatch(/re-?validate\s+after\s+every\s+change|re-?validate/i);
+  });
+
+  it('captures batch-level validation semantics and benchmark references', () => {
+    const processSection = getSectionBody(content, 'The Process');
+    const batchSection = getSectionBody(content, 'Batch-Level Validation');
+    const dispatchSection = getSectionBody(content, 'Sub-Skill Dispatch');
+
+    expect(processSection).not.toBeNull();
+    expect(batchSection).not.toBeNull();
+    expect(dispatchSection).not.toBeNull();
+
+    if (!processSection || !batchSection || !dispatchSection) {
+      return;
+    }
+
+    expect(processSection).toMatch(/validate\.ts/i);
+    expect(processSection).toMatch(/benchmark\.ts/i);
+    expect(processSection).toMatch(/batch-?report\.json/i);
+    expect(processSection).toMatch(/nextSkill[\s\S]*fixer[\s\S]*orchestrator[\s\S]*none/i);
+
+    expect(batchSection).toMatch(/\.agents\/iteration\/batch-<N>\//i);
+    expect(batchSection).toMatch(/report\.json/i);
+    expect(batchSection).toMatch(/per-?test-?case\s+pass\/?fail/i);
+    expect(batchSection).toMatch(/overall\s+batch\s+score/i);
+    expect(batchSection).toMatch(/score\s*<\s*threshold[\s\S]{0,80}fixer/i);
+
+    for (const nextSkill of allowedNextSkills) {
+      expect(dispatchSection).toMatch(new RegExp(`\\b${escapeRegExp(nextSkill)}\\b`, 'i'));
+    }
+  });
+
+  it('has a parseable report format JSON block with benchmark-linked fields', () => {
+    const reportJsonBlockMatch = content.match(/## Report Format[\s\S]*?```json\r?\n([\s\S]*?)\r?\n```/i);
+
+    expect(reportJsonBlockMatch).not.toBeNull();
+
+    if (!reportJsonBlockMatch) {
+      return;
+    }
+
+    const reportSample = JSON.parse(reportJsonBlockMatch[1]);
+
+    expect(reportSample).toEqual(
+      expect.objectContaining({
+        skill: 'validation',
+        status: expect.any(String),
+        timestamp: expect.any(String),
+        batchId: expect.any(Number),
+        findings: expect.any(Array),
+        fixSuggestions: expect.any(Array),
+        recommendations: expect.any(Array),
+        metrics: expect.any(Object),
+        nextSkill: expect.any(String),
+      }),
+    );
+
+    expect(reportSample.metrics).toEqual(
+      expect.objectContaining({
+        score: expect.any(Number),
+        benchmarkScore: expect.any(Number),
+        itemsChecked: expect.any(Number),
+        itemsPassed: expect.any(Number),
+        testCasesPassed: expect.any(Number),
+        testCasesFailed: expect.any(Number),
+      }),
+    );
+
+    const normalizedNextSkill = String(reportSample.nextSkill).trim().toLowerCase();
+    expect(
+      allowedNextSkills.includes(normalizedNextSkill as (typeof allowedNextSkills)[number]),
+    ).toBe(true);
+  });
+
+  it('keeps process report shape aligned with the report format fields', () => {
+    const processSection = getSectionBody(content, 'The Process');
+
+    expect(processSection).not.toBeNull();
+
+    if (!processSection) {
+      return;
+    }
+
+    expect(processSection).toMatch(/Write\s+batch-?report\.json/i);
+
+    const requiredFields = [
+      'skill',
+      'status',
+      'timestamp',
+      'batchId',
+      'findings',
+      'fixSuggestions',
+      'recommendations',
+      'metrics',
+      'nextSkill',
+    ];
+
+    for (const field of requiredFields) {
+      expect(processSection).toMatch(new RegExp(`\\b${escapeRegExp(field)}\\b`, 'i'));
+    }
+
+    expect(processSection).toMatch(/nextSkill[\s\S]*fixer[\s\S]*orchestrator[\s\S]*none/i);
+  });
+});

package/tests/worker-skill.test.ts

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('worker sub-skill', () => {
+  const skillPath = path.join(__dirname, '..', 'templates', '.workspace-templates', 'skills', 'worker', 'SKILL.md');
+
+  it('exists', () => {
+    expect(fs.existsSync(skillPath)).toBe(true);
+  });
+
+  it('has YAML frontmatter at the top with required keys', () => {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+
+    expect(frontmatterMatch).not.toBeNull();
+
+    if (!frontmatterMatch) {
+      return;
+    }
+
+    const frontmatter = frontmatterMatch[1];
+
+    expect(frontmatter).toMatch(/^name:\s*worker\s*$/m);
+    expect(frontmatter).toMatch(/^description:\s*".+"\s*$/m);
+    expect(frontmatter).toMatch(/^triggers:\s*\[[^\]]+\]\s*$/m);
+
+    const firstHeadingIndex = content.indexOf('\n## ');
+    expect(firstHeadingIndex).toBeGreaterThan(frontmatterMatch[0].length - 1);
+
+    const betweenFrontmatterAndFirstHeading = content
+      .slice(frontmatterMatch[0].length, firstHeadingIndex)
+      .trim();
+    expect(betweenFrontmatterAndFirstHeading).toBe('');
+  });
+
+  it('has Iron Law section', () => {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    expect(content.toLowerCase()).toContain('the iron law');
+  });
+
+  it('has Anti-Rationalization Table', () => {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    expect(content).toContain('| Thought | Reality |');
+  });
+
+  it('has Report Format section with required worker report fields', () => {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+    expect(content.toLowerCase()).toContain('report format');
+
+    const reportJsonBlockMatch = content.match(/## Report Format[\s\S]*?```json\r?\n([\s\S]*?)\r?\n```/i);
+    expect(reportJsonBlockMatch).not.toBeNull();
+
+    if (!reportJsonBlockMatch) {
+      return;
+    }
+
+    const reportSample = JSON.parse(reportJsonBlockMatch[1]);
+
+    expect(reportSample).toEqual(
+      expect.objectContaining({
+        skill: 'worker',
+        status: expect.any(String),
+        timestamp: expect.any(String),
+        testCaseId: expect.any(String),
+        batchId: expect.any(Number),
+        findings: expect.any(Array),
+        recommendations: expect.any(Array),
+        metrics: expect.any(Object),
+        nextSkill: 'validation',
+      }),
+    );
+
+    expect(reportSample.metrics).toEqual(
+      expect.objectContaining({
+        executionTimeMs: expect.any(Number),
+        outputLength: expect.any(Number),
+      }),
+    );
+  });
+
+  it('keeps Process report shape aligned with Report Format fields', () => {
+    const content = fs.readFileSync(skillPath, 'utf-8');
+
+    expect(content).toContain('Write report.json');
+    expect(content).toContain('{skill, status, timestamp, testCaseId, batchId, findings, recommendations, metrics, nextSkill}');
+    expect(content).not.toContain('{testCaseId, status, output, findings}');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/workspace/00-meta/CONTEXT.md

@@ -0,0 +1,3 @@
+# 00-meta Context
+
+Metadata and tool inventory for the NoAgent Test workspace.

package/workspace/00-meta/execution-log.md

@@ -0,0 +1,17 @@
+# Execution Log
+
+## Stage Checklist
+
+- [ ] 01-input
+
+## Rules
+
+1. Mark a stage complete only after its completion criteria are satisfied.
+2. Stages must be checked in ascending numerical order.
+3. Every checked stage must have corresponding evidence notes.
+
+## Evidence Notes
+
+### 01-input
+- Artifacts:
+- Handoff Summary:

package/workspace/00-meta/tools.md

@@ -0,0 +1,11 @@
+## Tool Inventory
+
+## Installed Tools
+
+| Tool | Version | Manager | Installed |
+|------|---------|---------|-----------|
+| — | — | — | — |
+
+## Pending Tools
+
+List tools that are proposed but not yet approved.

package/workspace/01-input/CONTEXT.md

@@ -0,0 +1,27 @@
+# 01-input — Context
+
+## Purpose
+This folder executes the 01-input stage of the NoAgent Test workflow.
+
+## Inputs
+- Required data artifacts for 01-input
+- Upstream context from previous stage when applicable
+
+## Outputs
+- Stage-specific deliverables for downstream consumption
+- Updated markdown artifacts needed by the next stage
+
+## Dependencies
+- None (entry stage)
+
+## Required Evidence
+- Update `00-meta/execution-log.md` to mark 01-input complete before handoff.
+- Link or reference the markdown artifacts produced in this stage.
+
+## Completion Criteria
+- Required outputs are produced and non-empty
+- Outputs conform to stage purpose and markdown-first workflow format
+- Handoff notes are updated for downstream stage
+
+## Handoff
+- This is the terminal stage. Package and deliver final output.

package/workspace/CONTEXT.md

@@ -0,0 +1,35 @@
+# NoAgent Test — Context Router
+
+## How to Use This File
+Use this file to route each task to the smallest required context scope.
+
+## Task Routing
+This routing table maps task intent to the correct stage context.
+
+| When you need to... | Load | Why |
+|---------------------|------|-----|
+| Understand workspace constraints | `SYSTEM.md` | Global rules and stage boundaries |
+| Work in 01-input tasks | `01-input/CONTEXT.md` | Stage contract and required outputs |
+| Check available tools | `00-meta/tools.md` | Tool inventory and approval status |
+
+## Loading Order
+1. `SYSTEM.md` (always)
+2. This root `CONTEXT.md`
+3. One relevant stage `CONTEXT.md`
+4. Only the task files needed for that stage
+
+## Scope Guardrails
+- Route domain requests into workflow design steps and markdown deliverables.
+- Do not scaffold backend, frontend, or runtime product source files from this router.
+- Keep outputs file-structured and markdown-first across numbered workflow folders.
+
+## Sequential Routing Contract
+- Route only to the earliest incomplete stage in `00-meta/execution-log.md`.
+- Refuse jumps to later stages when earlier stages are not marked complete.
+- Append handoff notes for each completed stage before routing onward.
+
+## Stage Handoff Routing
+- `01-input` -> deliver final output and close loop
+
+## Escalation
+Escalate when required sections are missing, dependencies are contradictory, or no valid stage route can satisfy the task.

package/workspace/README.md

@@ -0,0 +1,14 @@
+# NoAgent Test Workspace
+
+## Structure
+
+- `01-input/`
+- `00-meta/`
+
+## Usage
+
+1. Follow the workflow stages in order
+2. Load CONTEXT.md files selectively — only what you need
+3. Update 00-meta/execution-log.md after each completed stage
+4. Keep outputs in stage folders as markdown workflow artifacts
+5. Run validate.ts to check ICM compliance

package/workspace/SYSTEM.md

@@ -0,0 +1,36 @@
+# NoAgent Test — System Prompt
+
+## Role
+You are an AI assistant operating inside the NoAgent Test workspace. Follow stage boundaries and route tasks through stage-specific CONTEXT files.
+
+## Folder Map
+
+| Stage | Folder | Purpose |
+|------:|--------|---------|
+| 1 | `01-input/` | Input collection and validation |
+| meta | `00-meta/` | Workspace configuration, tool inventory, and session notes |
+
+## Workflow Rules
+1. Read `SYSTEM.md` first, then root `CONTEXT.md`.
+2. Load only one stage `CONTEXT.md` at a time unless handoff explicitly requires another stage.
+3. Keep information canonical; do not duplicate facts across files.
+4. Maintain one-way stage dependencies from earlier stage numbers to later stage numbers.
+
+## Scope Guardrails
+- Build and maintain workflow documentation, not product implementation code.
+- Keep stage outputs as markdown artifacts (plans, checklists, prompts, routing notes).
+- If asked to build the product itself, capture that request as workflow requirements and stay in ICM workspace scope.
+
+## Sequential Execution Protocol
+1. Complete stages strictly in ascending numeric order.
+2. Record stage completion in `00-meta/execution-log.md` before moving to the next stage.
+3. Do not produce final deliverables until all prior stage checkboxes are complete.
+
+## Stage Boundaries
+- Each numbered folder is an execution stage.
+- A stage may consume upstream outputs but must not redefine upstream facts.
+- Cross-stage jumps require explicit routing through root `CONTEXT.md`.
+
+## Tooling Policy
+- Check `00-meta/tools.md` before proposing tool installation.
+- Document approved tooling changes in `00-meta/tools.md`.