@xulthekl/team-flow 0.22.4

package/tests/lib/raw-mode-smoke.test.mjs

@@ -0,0 +1,42 @@
+// Raw-package smoke: canonical skills must work without host plugin-root variables
+// or a globally installed `tf` binary.
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const ROOT = process.cwd();
+
+function run(command, args, options) {
+  const result = spawnSync(command, args, { encoding: 'utf8', ...options });
+  assert.equal(result.status, 0, `${command} ${args.join(' ')}\n${result.stderr}`);
+  return result.stdout;
+}
+
+describe('raw-package runtime smoke', () => {
+  it('runs a packed canonical runtime with no plugin-root variables or global tf', () => {
+    const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
+    assert.equal(pkg.scripts['test:raw-mode'], 'node --test tests/lib/raw-mode-smoke.test.mjs');
+
+    const tempRoot = mkdtempSync(join(tmpdir(), 'tf-raw-mode-'));
+    try {
+      const packJson = run('npm', ['pack', '--json', '--pack-destination', tempRoot], { cwd: ROOT });
+      const [{ filename }] = JSON.parse(packJson);
+      const env = { ...process.env };
+      delete env.CLAUDE_PLUGIN_ROOT;
+      delete env.PLUGIN_ROOT;
+      delete env.CODEX_HOME;
+
+      const output = run('npx', [
+        '--yes', '--package', join(tempRoot, filename), 'tf',
+        'runtime', 'asset', 'read', 'docs/state-machine.md',
+      ], { cwd: tempRoot, env });
+
+      assert.match(output, /State Machine/);
+    } finally {
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+});

package/tests/lib/sdd-overlay.test.mjs

@@ -0,0 +1,118 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  saveCheckpoint, listCheckpoints, createHandoff, listHandoffs, finishHandoff, resolveHandoff,
+} from '../../scripts/lib/sdd-overlay.mjs';
+
+let changeDir;
+
+const validHandoffInput = {
+  type: 'research',
+  title: 'Research findings',
+  question: 'Which approach should the implementation use?',
+  context: 'Compare the available implementation approaches.',
+  source: 'Local repository inspection',
+};
+
+beforeEach(() => {
+  changeDir = mkdtempSync(join(tmpdir(), 'sdd-overlay-'));
+  writeFileSync(join(changeDir, 'tasks.md'), '# Tasks\n\n- [ ] 1.1 Original task text\n');
+  writeFileSync(join(changeDir, 'proposal.md'), '# Proposal\n\nA valid proposal.\n');
+  writeFileSync(join(changeDir, 'design.md'), '# Design\n\nA valid design.\n');
+  writeFileSync(join(changeDir, '.team-flow.yaml'), 'state: executing\nworkflow: auto\n');
+});
+
+afterEach(() => {
+  rmSync(changeDir, { recursive: true, force: true });
+});
+
+describe('checkpoint storage', () => {
+  it('persists commit boundaries and recovery fields across list and show reads', () => {
+    saveCheckpoint(changeDir, {
+      taskId: '1.1',
+      next: 'Run the focused test',
+      completed: 'Added parser tests',
+      evidence: 'tests/lib/sdd-overlay.test.mjs',
+      review: 'review.md',
+      risk: 'None',
+      commitStart: 'aaaaaaa',
+      commitEnd: 'bbbbbbb',
+    });
+
+    const checkpoint = listCheckpoints(changeDir)[0];
+    assert.equal(checkpoint.task_id, '1.1');
+    assert.equal(checkpoint.next, 'Run the focused test');
+    assert.equal(checkpoint.completed, 'Added parser tests');
+    assert.equal(checkpoint.evidence, 'tests/lib/sdd-overlay.test.mjs');
+    assert.equal(checkpoint.review, 'review.md');
+    assert.equal(checkpoint.risk, 'None');
+    assert.equal(checkpoint.commit_start, 'aaaaaaa');
+    assert.equal(checkpoint.commit_end, 'bbbbbbb');
+  });
+
+  it('marks a checkpoint stale when its numbered task line changes', () => {
+    saveCheckpoint(changeDir, { taskId: '1.1', next: 'Run the focused test' });
+    writeFileSync(join(changeDir, 'tasks.md'), '# Tasks\n\n- [ ] 1.1 Changed task text\n');
+
+    assert.equal(listCheckpoints(changeDir)[0].stale, true);
+  });
+
+  it('marks a checkpoint stale when its task is removed', () => {
+    saveCheckpoint(changeDir, { taskId: '1.1', next: 'Run the focused test' });
+    writeFileSync(join(changeDir, 'tasks.md'), '# Tasks\n');
+
+    assert.equal(listCheckpoints(changeDir)[0].stale, true);
+  });
+});
+
+describe('handoff storage', () => {
+  it('creates HANDOFF.md and HANDOFF_RESULT.md and validates the latter on finish', () => {
+    const handoff = createHandoff(changeDir, validHandoffInput);
+    const handoffPath = join(handoff.directory, 'HANDOFF.md');
+    const resultPath = join(handoff.directory, 'HANDOFF_RESULT.md');
+
+    assert.equal(existsSync(handoffPath), true);
+    assert.equal(existsSync(resultPath), true);
+    writeFileSync(resultPath, validResult());
+    assert.equal(finishHandoff(changeDir, handoff.id).status, 'result-ready');
+  });
+
+  it('keeps a handoff active when finish validation fails', () => {
+    const handoff = createHandoff(changeDir, validHandoffInput);
+
+    assert.throws(() => finishHandoff(changeDir, handoff.id), /Conclusion/);
+    assert.equal(listHandoffs(changeDir)[0].status, 'active');
+  });
+
+  it('requires explicit drift acknowledgement before resolving', () => {
+    const handoff = createReadyHandoff();
+    writeFileSync(join(changeDir, 'design.md'), '# Changed design\n');
+
+    assert.throws(
+      () => resolveHandoff(changeDir, handoff.id, 'accept', false),
+      /acknowledge-source-drift/,
+    );
+    assert.equal(resolveHandoff(changeDir, handoff.id, 'accept', true).status, 'resolved');
+  });
+});
+
+function createReadyHandoff() {
+  const handoff = createHandoff(changeDir, validHandoffInput);
+  const resultPath = join(changeDir, '.superpowers', 'sdd', 'handoffs', handoff.id, 'HANDOFF_RESULT.md');
+  writeFileSync(resultPath, validResult());
+  return finishHandoff(changeDir, handoff.id);
+}
+
+function validResult() {
+  return [
+    '## Conclusion\nThe research is complete.',
+    '## Evidence\nRepository evidence was reviewed.',
+    '## Produced Artifacts\nThe handoff record was produced.',
+    '## Risks\nNo additional risks were found.',
+    '## Suggested Changes\nProceed with the selected approach.',
+    '',
+  ].join('\n');
+}

package/tests/lib/spec-paths.test.mjs

@@ -0,0 +1,80 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+let mod;
+let tempDir;
+
+describe('spec-paths', () => {
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-spec-paths-'));
+    mod = await import(join(process.cwd(), 'scripts/lib/spec-paths.mjs'));
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('finds canonical specs in sorted order', () => {
+    const dir = mkdtempSync(join(tempDir, 'canonical-'));
+    mkdirSync(join(dir, 'specs', 'z-auth'), { recursive: true });
+    mkdirSync(join(dir, 'specs', 'a-ui'), { recursive: true });
+    writeFileSync(join(dir, 'specs', 'z-auth', 'spec.md'), 'z');
+    writeFileSync(join(dir, 'specs', 'a-ui', 'spec.md'), 'a');
+
+    const files = mod.findCanonicalSpecFiles(dir).map(f => f.replace(dir + '/', ''));
+    assert.deepEqual(files, ['specs/a-ui/spec.md', 'specs/z-auth/spec.md']);
+  });
+
+  it('ignores nested spec.md files when finding canonical specs', () => {
+    const dir = mkdtempSync(join(tempDir, 'nested-'));
+    mkdirSync(join(dir, 'specs', 'ui-theme', 'nested'), { recursive: true });
+    writeFileSync(join(dir, 'specs', 'ui-theme', 'nested', 'spec.md'), 'nested');
+
+    assert.deepEqual(mod.findCanonicalSpecFiles(dir), []);
+
+    const result = mod.validateSpecPathLayout(dir, { requireSpecs: true });
+    assert.equal(result.pass, false);
+    assert.deepEqual(result.specFiles, []);
+    assert.ok(result.failures.some(f => f.includes('No canonical spec files found')));
+  });
+
+  it('reports flat capability specs with expected canonical path', () => {
+    const dir = mkdtempSync(join(tempDir, 'flat-'));
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+    writeFileSync(join(dir, 'specs', 'ui-theme.md'), 'flat');
+
+    const invalid = mod.findInvalidSpecFiles(dir);
+    assert.deepEqual(invalid.map(i => i.path), ['specs/ui-theme.md']);
+    assert.deepEqual(invalid.map(i => i.expected), ['specs/ui-theme/spec.md']);
+  });
+
+  it('reports root specs/spec.md as invalid', () => {
+    const dir = mkdtempSync(join(tempDir, 'root-spec-'));
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+    writeFileSync(join(dir, 'specs', 'spec.md'), 'root');
+
+    const invalid = mod.findInvalidSpecFiles(dir);
+    assert.deepEqual(invalid, [{ path: 'specs/spec.md', expected: 'specs/<capability>/spec.md' }]);
+  });
+
+  it('does not reject README.md inside specs', () => {
+    const dir = mkdtempSync(join(tempDir, 'readme-'));
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+    writeFileSync(join(dir, 'specs', 'README.md'), 'notes');
+
+    assert.deepEqual(mod.findInvalidSpecFiles(dir), []);
+  });
+
+  it('fails layout validation when canonical specs are required but missing', () => {
+    const dir = mkdtempSync(join(tempDir, 'missing-'));
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+
+    const result = mod.validateSpecPathLayout(dir, { requireSpecs: true });
+    assert.equal(result.pass, false);
+    assert.deepEqual(result.specFiles, []);
+    assert.ok(result.failures.some(f => f.includes('No canonical spec files found')));
+  });
+});

package/tests/lib/state-loader.test.mjs

@@ -0,0 +1,251 @@
+// tests/lib/state-loader.test.mjs
+// Tests for scripts/lib/state-loader.mjs
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+let tempDir;
+
+describe('state-loader: readState()', () => {
+  let stateLoader;
+
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-test-'));
+    const modulePath = join(process.cwd(), 'scripts/lib/state-loader.mjs');
+    stateLoader = await import(modulePath);
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns defaults when no state file exists', () => {
+    const state = stateLoader.readState(tempDir);
+    assert.equal(state.state, 'exploring');
+    assert.equal(state.workflow, 'auto');
+    assert.equal(state.batches_completed, 0);
+    assert.equal(state.execution_mode, null);
+    assert.equal(state.execution_plan_hash, null);
+    assert.equal(state.execution_plan_revision, null);
+  });
+
+  it('infers change_name from directory when no state file', () => {
+    const changeDir = join(tempDir, 'my-feature');
+    const state = stateLoader.readState(changeDir);
+    assert.equal(state.change_name, 'my-feature');
+  });
+
+  it('parses existing state file correctly', () => {
+    const stateYaml = [
+      'state: executing',
+      'workflow: full',
+      'artifacts_hash: sha256:abc123',
+      'batches_completed: 3',
+      'test_result: pass',
+      'change_name: export-csv',
+      'dp_0_confirmed: true',
+      'dp_1_result: confirmed: add csv export',
+    ].join('\n');
+
+    writeFileSync(join(tempDir, '.team-flow.yaml'), stateYaml);
+
+    const state = stateLoader.readState(tempDir);
+
+    assert.equal(state.state, 'executing');
+    assert.equal(state.workflow, 'full');
+    assert.equal(state.artifacts_hash, 'sha256:abc123');
+    assert.equal(state.batches_completed, 3);
+    assert.equal(state.test_result, 'pass');
+    assert.equal(state.change_name, 'export-csv');
+    assert.equal(state.dp_0_confirmed, 'true');
+    assert.equal(state.dp_1_result, 'confirmed: add csv export');
+  });
+
+  it('handles null values in YAML', () => {
+    const stateYaml = [
+      'state: exploring',
+      'artifacts_hash: null',
+      'contract_hash: null',
+      'dp_0_timestamp: null',
+    ].join('\n');
+
+    writeFileSync(join(tempDir, '.team-flow.yaml'), stateYaml);
+
+    const state = stateLoader.readState(tempDir);
+
+    assert.equal(state.artifacts_hash, null);
+    assert.equal(state.contract_hash, null);
+    assert.equal(state.dp_0_timestamp, null);
+  });
+
+  it('ignores comments and empty lines in YAML', () => {
+    const stateYaml = [
+      '# This is a comment',
+      '',
+      'state: specifying',
+      '  ',
+      '# Another comment',
+      'workflow: tweak',
+    ].join('\n');
+
+    writeFileSync(join(tempDir, '.team-flow.yaml'), stateYaml);
+
+    const state = stateLoader.readState(tempDir);
+
+    assert.equal(state.state, 'specifying');
+    assert.equal(state.workflow, 'tweak');
+  });
+
+  it('merges partial state file with defaults', () => {
+    const stateYaml = 'state: approved-for-build\nworkflow: hotfix';
+
+    writeFileSync(join(tempDir, '.team-flow.yaml'), stateYaml);
+
+    const state = stateLoader.readState(tempDir);
+    assert.equal(state.state, 'approved-for-build');
+    assert.equal(state.workflow, 'hotfix');
+    // Unspecified fields should use defaults
+    assert.equal(state.batches_completed, 0);
+    assert.equal(state.test_result, null);
+  });
+});
+
+describe('state-loader: writeState()', () => {
+  let stateLoader;
+
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-write-'));
+    const modulePath = join(process.cwd(), 'scripts/lib/state-loader.mjs');
+    stateLoader = await import(modulePath);
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('writes state file with correct structure', () => {
+    const state = {
+      state: 'executing',
+      workflow: 'full',
+      artifacts_hash: 'sha256:def456',
+      contract_hash: null,
+      batches_completed: 2,
+      test_result: null,
+      change_name: 'test-change',
+      dp_0_confirmed: 'true',
+    };
+
+    stateLoader.writeState(tempDir, state);
+
+    const filePath = join(tempDir, '.team-flow.yaml');
+    assert.ok(existsSync(filePath));
+
+    const content = readFileSync(filePath, 'utf-8');
+    assert.ok(content.includes('state: executing'));
+    assert.ok(content.includes('workflow: full'));
+    assert.ok(content.includes('artifacts_hash: sha256:def456'));
+    assert.ok(content.includes('contract_hash: null'));
+    assert.ok(content.includes('batches_completed: 2'));
+    assert.ok(content.includes('execution_plan_hash: null'));
+    assert.ok(content.includes('execution_plan_revision: null'));
+    assert.ok(content.includes('change_name: test-change'));
+    assert.ok(content.includes('dp_0_confirmed: true'));
+  });
+
+  it('writes all DP fields (0-7)', () => {
+    const state = {
+      state: 'closing',
+      dp_0_decisions: 'scope: csv export only, tech: nestjs',
+      dp_0_result: 'confirmed: scope ok',
+      dp_0_confirmed: 'true',
+      dp_0_timestamp: '2026-07-01T08:00:00Z',
+      dp_1_result: 'confirmed: csv export',
+      dp_2_result: 'approved: artifacts ok',
+      dp_3_result: 'contract signed',
+      dp_4_result: 'execution started',
+      dp_5_result: null,
+      dp_6_result: null,
+      dp_7_result: null,
+    };
+
+    stateLoader.writeState(tempDir, state);
+
+    const content = readFileSync(join(tempDir, '.team-flow.yaml'), 'utf-8');
+    assert.ok(content.includes('dp_0_decisions: scope: csv export only, tech: nestjs'));
+    assert.ok(content.includes('dp_0_result: confirmed: scope ok'));
+    assert.ok(content.includes('dp_0_confirmed: true'));
+    assert.ok(content.includes('dp_1_result: confirmed: csv export'));
+    assert.ok(content.includes('dp_5_result: null'));
+  });
+
+  it('round-trips dp_0_result when updated through state loader', () => {
+    stateLoader.writeState(tempDir, {
+      state: 'exploring',
+      dp_0_decisions: 'scope confirmed',
+      dp_0_confirmed: 'true',
+    });
+
+    stateLoader.updateField(tempDir, 'dp_0_result', 'confirmed: manual');
+
+    const content = readFileSync(join(tempDir, '.team-flow.yaml'), 'utf-8');
+    const state = stateLoader.readState(tempDir);
+
+    assert.ok(content.includes('dp_0_result: confirmed: manual'));
+    assert.equal(state.dp_0_result, 'confirmed: manual');
+  });
+
+  it('round-trips state through write then read', () => {
+    const original = {
+      state: 'bridging',
+      workflow: 'hotfix',
+      artifacts_hash: 'sha256:xyz789',
+      batches_completed: 0,
+      dp_1_result: 'confirmed: refactor auth',
+      dp_1_timestamp: '2026-07-01T10:00:00Z',
+    };
+
+    stateLoader.writeState(tempDir, original);
+    const read = stateLoader.readState(tempDir);
+
+    assert.equal(read.state, original.state);
+    assert.equal(read.workflow, original.workflow);
+    assert.equal(read.artifacts_hash, original.artifacts_hash);
+    assert.equal(read.batches_completed, original.batches_completed);
+    assert.equal(read.dp_1_result, original.dp_1_result);
+    assert.equal(read.dp_1_timestamp, original.dp_1_timestamp);
+  });
+});
+
+describe('state-loader: updateField()', () => {
+  let stateLoader;
+
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-state-update-'));
+    const modulePath = join(process.cwd(), 'scripts/lib/state-loader.mjs');
+    stateLoader = await import(modulePath);
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('updates a single field without affecting others', () => {
+    // Initialize with some state
+    stateLoader.writeState(tempDir, {
+      state: 'exploring',
+      workflow: 'full',
+      batches_completed: 0,
+    });
+
+    stateLoader.updateField(tempDir, 'state', 'specifying');
+    stateLoader.updateField(tempDir, 'batches_completed', 3);
+
+    const state = stateLoader.readState(tempDir);
+    assert.equal(state.state, 'specifying');
+    assert.equal(state.batches_completed, 3);
+    // workflow should still be 'full'
+    assert.equal(state.workflow, 'full');
+  });
+});

package/tests/lib/token-baseline.test.mjs

@@ -0,0 +1,72 @@
+// tests/lib/token-baseline.test.mjs
+// Tests for scripts/token-baseline.mjs — measurement and comparison
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { execSync } from 'node:child_process';
+import { writeFileSync, unlinkSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const BASELINE_PATH = join(process.cwd(), 'scripts/token-baseline.mjs');
+const TMP = tmpdir();
+
+describe('token-baseline: measurement', () => {
+  it('outputs valid JSON with components and totals', () => {
+    const out = execSync(`node "${BASELINE_PATH}" --files hooks/session-start`, { encoding: 'utf-8' });
+    const data = JSON.parse(out);
+    assert.ok(Array.isArray(data.components), 'components should be an array');
+    assert.ok(data.components.length > 0, 'should have at least one component');
+    const c = data.components[0];
+    assert.ok(typeof c.lines === 'number' && c.lines > 0, 'lines should be positive');
+    assert.ok(typeof c.chars === 'number' && c.chars > 0, 'chars should be positive');
+    assert.ok(typeof c.estimatedTokens === 'number' && c.estimatedTokens > 0, 'estimatedTokens should be positive');
+    assert.ok(typeof data.totals === 'object', 'totals should be an object');
+    assert.ok(data.totals.estimatedTokens > 0, 'total estimatedTokens should be positive');
+  });
+
+  it('--files filter limits output', () => {
+    const out = execSync(`node "${BASELINE_PATH}" --files hooks/session-start`, { encoding: 'utf-8' });
+    const data = JSON.parse(out);
+    assert.equal(data.components.length, 1, 'should only have one component');
+    assert.ok(data.components[0].path.includes('hooks/session-start'), 'should be the filtered file');
+  });
+
+  it('--output writes to file', () => {
+    const outPath = join(TMP, 'token-baseline-test.json');
+    execSync(`node "${BASELINE_PATH}" --files hooks/session-start --output "${outPath}"`, { encoding: 'utf-8' });
+    const data = JSON.parse(readFileSync(outPath, 'utf-8'));
+    assert.ok(data.totals.estimatedTokens > 0, 'file should contain valid data');
+    unlinkSync(outPath);
+  });
+});
+
+describe('token-baseline: comparison', () => {
+  it('--compare produces change deltas', () => {
+    const baselinePath = join(TMP, 'baseline-cmp-test.json');
+    // Create a baseline with slightly different values
+    const baseline = {
+      timestamp: '2026-01-01T00:00:00Z',
+      components: [
+        { path: 'hooks/session-start', label: 'hooks/session-start', lines: 30, chars: 2000, estimatedTokens: 500 },
+      ],
+      totals: { lines: 30, chars: 2000, estimatedTokens: 500 },
+    };
+    writeFileSync(baselinePath, JSON.stringify(baseline));
+
+    const out = execSync(`node "${BASELINE_PATH}" --files hooks/session-start --compare "${baselinePath}"`, { encoding: 'utf-8' });
+    const data = JSON.parse(out);
+    assert.ok(Array.isArray(data.changes), 'should have changes array');
+    assert.ok(data.changes.length > 0, 'should have at least one change');
+    assert.ok(typeof data.summary.totalDelta === 'number', 'should have totalDelta');
+    assert.ok(typeof data.summary.totalPct === 'string', 'should have totalPct');
+
+    unlinkSync(baselinePath);
+  });
+
+  it('missing file in baseline reports error', () => {
+    const out = execSync(`node "${BASELINE_PATH}" --files hooks/session-start --compare /nonexistent/baseline.json 2>&1 || true`, { encoding: 'utf-8' });
+    // Should fail gracefully — error message from file not found
+    assert.ok(out.length > 0, 'should produce output even on error');
+  });
+});

package/tests/lib/token-rules.test.mjs

@@ -0,0 +1,94 @@
+// tests/lib/token-rules.test.mjs
+// Tests for scripts/lint/rules/token-rules.mjs — lint rule functions
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { checkMaxLines, checkMaxChars, checkMaxEmphasisMarkers, checkMaxCodeBlockLength } from '../../scripts/lint/rules/token-rules.mjs';
+
+const CTX = { skillDirs: ['test-skill'], skillsDir: '/fake/skills' };
+
+describe('token-rules: checkMaxLines', () => {
+  it('passes when under limit', async () => {
+    const issues = await checkMaxLines('test', 'line1\nline2\nline3', CTX, 10);
+    assert.equal(issues.length, 0);
+  });
+
+  it('fails when over limit', async () => {
+    const content = Array(251).fill('line').join('\n');
+    const issues = await checkMaxLines('test', content, CTX, 250);
+    assert.equal(issues.length, 1);
+    assert.equal(issues[0].severity, 'error');
+    assert.ok(issues[0].message.includes('251'));
+  });
+});
+
+describe('token-rules: checkMaxChars', () => {
+  it('passes when under limit', async () => {
+    const issues = await checkMaxChars('test', 'short', CTX, 100);
+    assert.equal(issues.length, 0);
+  });
+
+  it('warns when over limit', async () => {
+    const content = 'x'.repeat(10001);
+    const issues = await checkMaxChars('test', content, CTX, 10000);
+    assert.equal(issues.length, 1);
+    assert.equal(issues[0].severity, 'warning');
+  });
+});
+
+describe('token-rules: checkMaxEmphasisMarkers', () => {
+  it('passes for content without banned markers', async () => {
+    const issues = await checkMaxEmphasisMarkers('test', 'normal text with **some** emphasis', CTX, 30);
+    assert.equal(issues.length, 0);
+  });
+
+  it('detects EXTREMELY_IMPORTANT', async () => {
+    const issues = await checkMaxEmphasisMarkers('test', 'This is EXTREMELY_IMPORTANT content', CTX, 30);
+    const eiIssue = issues.find(i => i.message.includes('EXTREMELY_IMPORTANT'));
+    assert.ok(eiIssue, 'should flag EXTREMELY_IMPORTANT');
+    assert.equal(eiIssue.severity, 'error');
+  });
+
+  it('detects CRITICAL', async () => {
+    const issues = await checkMaxEmphasisMarkers('test', 'CRITICAL: do not skip', CTX, 30);
+    const crIssue = issues.find(i => i.message.includes('CRITICAL'));
+    assert.ok(crIssue, 'should flag CRITICAL');
+    assert.equal(crIssue.severity, 'error');
+  });
+
+  it('warns on too many IMPORTANT occurrences', async () => {
+    const content = 'IMPORTANT\n'.repeat(5) + 'text';
+    const issues = await checkMaxEmphasisMarkers('test', content, CTX, 30);
+    const impIssue = issues.find(i => i.message.includes('IMPORTANT'));
+    assert.ok(impIssue, 'should flag excessive IMPORTANT');
+  });
+
+  it('warns on too many emphasis markers', async () => {
+    const content = '**a** **b** '.repeat(31);
+    const issues = await checkMaxEmphasisMarkers('test', content, CTX, 30);
+    const empIssue = issues.find(i => i.message.includes('emphasis markers'));
+    assert.ok(empIssue, 'should flag excessive emphasis');
+    assert.equal(empIssue.severity, 'warning');
+  });
+});
+
+describe('token-rules: checkMaxCodeBlockLength', () => {
+  it('passes for short code blocks', async () => {
+    const issues = await checkMaxCodeBlockLength('test', '```\nline1\nline2\n```', CTX, 5);
+    assert.equal(issues.length, 0);
+  });
+
+  it('warns for long code blocks', async () => {
+    const lines = Array(17).fill('code').join('\n');
+    const content = '```\n' + lines + '\n```';
+    const issues = await checkMaxCodeBlockLength('test', content, CTX, 15);
+    assert.equal(issues.length, 1);
+    assert.equal(issues[0].severity, 'warning');
+    assert.ok(issues[0].message.includes('19'), `expected message to include '19', got: ${issues[0].message}`);
+  });
+
+  it('handles content with no code blocks', async () => {
+    const issues = await checkMaxCodeBlockLength('test', 'just text, no code', CTX, 15);
+    assert.equal(issues.length, 0);
+  });
+});