harness-everything 0.2.2 → 0.4.0

package/ci/disclosure-check.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * Progressive-disclosure checks for the skill catalog.
+ *
+ * The top-level SKILL.md is the routed contract. Workflow docs explain the
+ * behavior in plain language, and references/guides hold detail that is
+ * loaded only when needed. Keeping these checks separate makes the policy
+ * usable from consistency-check.js and from focused mechanism tests.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_ROOT = path.resolve(__dirname, '..');
+const DEFAULT_MIN_MERMAID = 1;
+
+function discoverSkills(root) {
+  return fs.readdirSync(root, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && !entry.name.startsWith('.') && fs.existsSync(path.join(root, entry.name, 'SKILL.md')))
+    .map(entry => entry.name)
+    .sort();
+}
+
+function discoverWorkflowDocs(root) {
+  const dir = path.join(root, 'docs', 'workflows');
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir, { withFileTypes: true })
+    .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+    .map(entry => entry.name.slice(0, -3))
+    .sort();
+}
+
+function bodyWithoutFrontmatter(raw) {
+  return raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
+}
+
+function mermaidBlocks(text) {
+  const blocks = [];
+  const re = /```mermaid\s*\r?\n([\s\S]*?)\r?\n```/gi;
+  let match;
+  while ((match = re.exec(text)) !== null) blocks.push(match[1].trim());
+  return blocks;
+}
+
+function isMeaningfulMermaid(block) {
+  if (!block) return false;
+  const lines = block.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+  if (lines.length < 2) return false;
+  const edgeTokens = ['-.->', '-..->', '==>', '-->', '->>', '---', '-.-', '~~~', '-..-'];
+  for (const line of lines.slice(1)) {
+    let nesting = 0;
+    let quote = false;
+    for (let i = 0; i < line.length; i++) {
+      const char = line[i];
+      if (char === '"' && line[i - 1] !== '\\') {
+        quote = !quote;
+        continue;
+      }
+      if (quote) continue;
+      if ('([{'.includes(char)) {
+        nesting++;
+        continue;
+      }
+      if (')]}'.includes(char)) {
+        nesting = Math.max(0, nesting - 1);
+        continue;
+      }
+      if (nesting !== 0) continue;
+      if (edgeTokens.some(token => line.startsWith(token, i))) return true;
+    }
+  }
+  return false;
+}
+
+function deepDivePointers(body) {
+  const pointers = [];
+  const re = /^Deep dive:\s*(.+)$/gim;
+  let match;
+  while ((match = re.exec(body)) !== null) {
+    const line = match[1]
+      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$2')
+      .replace(/`/g, '');
+    pointers.push(...line.split(/\s+\+\s+/).map(value => value.trim()).filter(Boolean));
+  }
+  return pointers;
+}
+
+function cleanPointer(pointer) {
+  return pointer.replace(/[),.;:]+$/, '').trim();
+}
+
+function isInside(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === '' || (relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+
+function globRegExp(segment) {
+  const escaped = segment.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`);
+}
+
+function globMatches(root, base, segments) {
+  if (!isInside(root, base)) return false;
+  if (!segments.length) return fs.existsSync(base);
+  if (!fs.existsSync(base) || !fs.statSync(base).isDirectory()) return false;
+
+  const [segment, ...rest] = segments;
+  if (!segment) return globMatches(root, base, rest);
+  if (!segment.includes('*') && !segment.includes('?')) {
+    const next = path.resolve(base, segment);
+    return isInside(root, next) && globMatches(root, next, rest);
+  }
+
+  const pattern = globRegExp(segment);
+  return fs.readdirSync(base).some(entry => pattern.test(entry) && globMatches(root, path.join(base, entry), rest));
+}
+
+function pointerTarget(root, skill, pointer, skillDirs) {
+  const clean = cleanPointer(pointer);
+  const match = clean.match(/^<([^>/]+)>\/(.*)$/);
+  if (match && match[1] === 'skills-repo-root') return path.resolve(root, match[2]);
+  if (match && match[1] === 'this-skill-dir') return path.resolve(root, skill, match[2]);
+  const first = clean.split('/')[0];
+  if (skillDirs.includes(first)) return path.resolve(root, clean);
+  return path.resolve(root, skill, clean);
+}
+
+function pointerResolves(root, skill, pointer, skillDirs) {
+  const clean = cleanPointer(pointer);
+  const wildcard = clean.search(/[?*]/);
+  if (wildcard === -1) {
+    const target = pointerTarget(root, skill, clean, skillDirs);
+    return isInside(root, target) && fs.existsSync(target);
+  }
+
+  const slash = clean.lastIndexOf('/', wildcard);
+  const basePointer = slash === -1 ? '.' : clean.slice(0, slash + 1);
+  const pattern = clean.slice(slash + 1);
+  const base = pointerTarget(root, skill, basePointer, skillDirs);
+  return globMatches(root, base, pattern.split('/'));
+}
+
+function checkDisclosure(root = DEFAULT_ROOT, options = {}) {
+  const minMermaid = options.minMermaid === undefined ? DEFAULT_MIN_MERMAID : options.minMermaid;
+  const skills = discoverSkills(root);
+  const workflows = discoverWorkflowDocs(root);
+  const failures = [];
+  const add = (check, detail) => failures.push({ check, detail });
+
+  const skillSet = new Set(skills);
+  for (const skill of skills) {
+    const skillPath = path.join(root, skill, 'SKILL.md');
+    const raw = fs.readFileSync(skillPath, 'utf8');
+    const body = bodyWithoutFrontmatter(raw);
+    const refsDir = path.join(root, skill, 'references');
+    if (!fs.existsSync(refsDir) || !fs.statSync(refsDir).isDirectory()) {
+      add(`${skill}: references directory`, 'missing references/ for lazy-loaded detail');
+    }
+
+    const pointers = deepDivePointers(body);
+    if (pointers.length === 0) {
+      add(`${skill}: Deep dive pointer`, 'SKILL.md must name one lazy-loaded entry point');
+    } else {
+      for (const pointer of pointers) {
+        if (!pointerResolves(root, skill, pointer, skills)) {
+          add(`${skill}: Deep dive pointer resolves`, `${pointer} does not resolve from ${skill}/SKILL.md`);
+        }
+      }
+    }
+
+    if (/```mermaid\b/i.test(body)) {
+      add(`${skill}: no Mermaid in SKILL.md`, 'put diagram source in docs/workflows/<skill>.md');
+    }
+  }
+
+  for (const skill of skills) {
+    const workflowPath = path.join(root, 'docs', 'workflows', `${skill}.md`);
+    if (!fs.existsSync(workflowPath)) {
+      add(`${skill}: workflow document`, `missing docs/workflows/${skill}.md`);
+      continue;
+    }
+    const workflow = fs.readFileSync(workflowPath, 'utf8');
+    const blocks = mermaidBlocks(workflow);
+    if (blocks.length < minMermaid) {
+      add(`${skill}: Mermaid coverage`, `${blocks.length} fence(s); requires at least ${minMermaid}`);
+    }
+    if (blocks.some(block => !isMeaningfulMermaid(block))) {
+      add(`${skill}: meaningful Mermaid coverage`, 'each Mermaid fence needs nodes and at least one transition');
+    }
+  }
+
+  for (const workflow of workflows) {
+    if (!skillSet.has(workflow)) {
+      add(`${workflow}: workflow pairing`, `orphan docs/workflows/${workflow}.md`);
+    }
+  }
+
+  return { failures, skills, workflows, minMermaid };
+}
+
+function main() {
+  const rootArg = process.argv.indexOf('--root');
+  const root = rootArg === -1 ? DEFAULT_ROOT : path.resolve(process.argv[rootArg + 1]);
+  const result = checkDisclosure(root);
+  for (const failure of result.failures) console.error(`FAIL ${failure.check}: ${failure.detail}`);
+  console.log(`Checked disclosure for ${result.skills.length} skill(s) and ${result.workflows.length} workflow doc(s).`);
+  if (result.failures.length) {
+    console.error(`DISCLOSURE CHECK FAILED: ${result.failures.length} problem(s).`);
+    process.exit(1);
+  }
+  console.log('ALL DISCLOSURE CHECKS PASSED.');
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  bodyWithoutFrontmatter,
+  checkDisclosure,
+  deepDivePointers,
+  discoverSkills,
+  discoverWorkflowDocs,
+  isMeaningfulMermaid,
+  mermaidBlocks,
+  pointerResolves,
+};

package/ci/doc-capability-consistency.test.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+let failures = 0;
+
+function fail(message) {
+  console.error(`❌ ${message}`);
+  failures++;
+}
+
+function pass(message) {
+  console.log(`✅ ${message}`);
+}
+
+function read(rel) {
+  const p = path.join(ROOT, rel);
+  if (!fs.existsSync(p)) {
+    fail(`missing documentation surface: ${rel}`);
+    return '';
+  }
+  return fs.readFileSync(p, 'utf8');
+}
+
+function requireText(rel, patterns) {
+  const text = read(rel);
+  for (const { name, re } of patterns) {
+    if (!re.test(text)) fail(`${rel}: missing ${name}`);
+    else pass(`${rel}: ${name}`);
+  }
+}
+
+const CURRENT_SURFACES = [
+  'README.md',
+  'AGENTS.md',
+  'BENCHMARK_SOP.md',
+  'VERIFICATION.md',
+  'docs/architecture.md',
+  'docs/mechanism-first-skill-mesh.md',
+  'docs/philosophy.md',
+  'docs/platform-capabilities.md',
+  'docs/reflection.md',
+  'docs/routing.md',
+  'docs/troubleshooting.md',
+  'docs/openai-plugin.md',
+  'submission/openai/README.md',
+  'opencode-plugin/README.md',
+];
+
+const STALE_PATTERNS = [
+  /OpenAI\/Codex plugin hook packaging is tracked separately in \[#72\]/i,
+  /Plugin adapter tracked in #72/i,
+  /plugin target pending/i,
+  /Codex[^\n]{0,120}adapter[^\n]{0,80}pending/i,
+  /Only Claude Code gets the hard-boundary hooks/i,
+  /Only possible on Claude Code \(the only platform with a hook\/exit-code execution system\)/i,
+  /On platforms with no hook system at all \(Cursor, Copilot, Codex/i,
+  /hooks[^\n]{0,100}Hard enforcement, Claude Code only/i,
+  /Codex[^\n]{0,180}\.codex\/skills\//i,
+];
+
+for (const rel of CURRENT_SURFACES) {
+  const text = read(rel);
+  for (const re of STALE_PATTERNS) {
+    if (re.test(text)) fail(`${rel}: contains stale capability claim ${re}`);
+  }
+}
+
+requireText('docs/platform-capabilities.md', [
+  { name: 'local Codex plugin boundary', re: /Codex \/ local OpenAI plugin/i },
+  { name: 'public Skills-only boundary', re: /Public OpenAI Skills-only plugin/i },
+  { name: 'OpenCode live-unverified boundary', re: /live plugin loading remains unverified/i },
+  { name: 'general Codex installer boundary', re: /general `--codex` installer|Legacy\/general installer target/i },
+  { name: 'Codex project skill target', re: /Codex[^\n]*`\.agents\/skills\/`/i },
+  { name: 'Continue global skill target', re: /Continue\.dev[^\n]*`~\/\.continue\/skills\/`/i },
+  { name: 'Hermes global skill target', re: /Hermes Agent[^\n]*`~\/\.hermes\/skills\/`/i },
+  { name: 'Hermes trust boundary', re: /Hermes[^\n]{0,160}trust/i },
+  { name: 'installer ownership boundary', re: /Install\/uninstall ownership boundary/i },
+  { name: 'three-OS round-trip boundary', re: /Linux, Windows, and macOS/i },
+]);
+
+requireText('docs/platform-compatibility.json', [
+  { name: 'machine-readable matrix format', re: /harness-platform-compatibility-v1/ },
+  { name: 'ten-dimension coverage', re: /standaloneSkills[\s\S]*liveHostVerification/ },
+  { name: 'official OpenAI source', re: /https:\/\/developers\.openai\.com\/plugins\/deploy\/submission/ },
+  { name: 'Continue unknown discovery boundary', re: /"id": "continue"[\s\S]{0,3000}"status": "Unknown"/ },
+]);
+
+requireText('README.md', [
+  { name: 'local Codex plugin surface', re: /Codex \/ local OpenAI plugin|local OpenAI plugin/i },
+  { name: 'public Skills-only distinction', re: /Public OpenAI[^\n]*Skills-only|public OpenAI \*\*Skills-only\*\*/i },
+  { name: 'OpenCode live-unverified qualifier', re: /OpenCode[^\n]*(?:live plugin loading|live loading) remains unverified/i },
+  { name: 'canonical matrix link', re: /docs\/platform-capabilities\.md/ },
+  { name: 'Codex repo Agent Skills path', re: /Codex[^\n]*`?\.agents\/skills\/?`?/i },
+  { name: 'Continue native global skills path', re: /`~\/\.continue\/skills\/`/i },
+  { name: 'Hermes native global skills path', re: /`~\/\.hermes\/skills\/`/i },
+  { name: 'installer round-trip evidence', re: /install[^\n]{0,40}(?:→|->)[^\n]{0,40}verify[^\n]{0,40}(?:→|->)[^\n]{0,40}uninstall/i },
+]);
+
+requireText('AGENTS.md', [
+  { name: 'canonical platform matrix rule', re: /docs\/platform-capabilities\.md/ },
+  { name: 'Codex local plugin distribution', re: /plugins\/harness-everything/ },
+  { name: 'public Skills-only boundary', re: /public artifact does not include local `\.codex-plugin` lifecycle hooks/i },
+]);
+
+requireText('BENCHMARK_SOP.md', [
+  { name: 'behavior vs mechanism separation', re: /behavior[^\n]{0,120}mechanism|mechanism\/live-host evidence/i },
+  { name: 'Codex multi-surface distinction', re: /Codex \/ local OpenAI plugin|general Codex installer path/i },
+  { name: 'OpenCode live-unverified qualifier', re: /OpenCode[^\n]*(?:live plugin loading|live loading) remains unverified/i },
+]);
+
+requireText('docs/architecture.md', [
+  { name: 'Codex local plugin host adapter', re: /Codex[^\n]*local OpenAI plugin/i },
+  { name: 'OpenCode live loading remains unverified', re: /live (plugin )?loading remains unverified/i },
+]);
+
+requireText('VERIFICATION.md', [
+  { name: 'mechanism/behavior distinction', re: /Mechanism evidence[\s\S]{0,700}Behavior evidence/i },
+  { name: 'Codex local plugin verification surface', re: /Codex \/ local OpenAI plugin/i },
+  { name: 'public Skills-only verification boundary', re: /Public OpenAI Skills-only/i },
+  { name: 'live-host evidence layer', re: /Live-host evidence/i },
+  { name: 'Codex repo Agent Skills path', re: /Codex[^\n]*`\.agents\/skills\/`/i },
+  { name: 'Continue native global skills path', re: /`~\/\.continue\/skills\/`/i },
+  { name: 'Hermes native global skills path', re: /`~\/\.hermes\/skills\/`/i },
+]);
+
+requireText('docs/philosophy.md', [
+  { name: 'platform-specific mechanism boundary', re: /platform-specific|installation surface/i },
+  { name: 'canonical capability link', re: /platform-capabilities\.md/ },
+  { name: 'automatic mechanism qualifier', re: /On surfaces that package|On integration surfaces that expose/i },
+]);
+
+requireText('docs/reflection.md', [
+  { name: 'runtime state vs durable learning distinction', re: /Runtime session state[\s\S]{0,500}Durable workspace learning/i },
+  { name: 'Codex local plugin WAL boundary', re: /Codex \/ local OpenAI plugin/i },
+  { name: 'public Skills-only hook exclusion', re: /public OpenAI \*\*Skills-only\*\* artifact has no local `\.codex-plugin` lifecycle hooks/i },
+]);
+
+requireText('docs/routing.md', [
+  { name: 'host-specific enforcement boundary', re: /Enforcement strength/i },
+  { name: 'no cross-host parity inference', re: /do not infer cross-host parity/i },
+]);
+
+requireText('docs/troubleshooting.md', [
+  { name: 'Codex advisory installer troubleshooting', re: /Codex advisory installer/i },
+  { name: 'Codex local plugin troubleshooting', re: /Codex \/ local OpenAI plugin not appearing/i },
+  { name: 'public Skills-only troubleshooting boundary', re: /Public OpenAI Skills-only plugin behaves differently/i },
+]);
+
+requireText('docs/openai-plugin.md', [
+  { name: 'public submission excludes local hooks', re: /does \*\*not\*\* include the local `\.codex-plugin` lifecycle hooks/i },
+]);
+
+requireText('submission/openai/README.md', [
+  { name: 'submission excludes local hooks', re: /does not contain the local `\.codex-plugin` lifecycle hooks/i },
+]);
+
+requireText('opencode-plugin/README.md', [
+  { name: 'live OpenCode evidence limitation', re: /Live opencode plugin loading remains unverified/i },
+]);
+
+requireText('docs/audit.md', [
+  { name: 'historical snapshot boundary', re: /Historical snapshot boundary/i },
+  { name: 'current platform matrix link', re: /platform-capabilities\.md/ },
+]);
+
+requireText('CHANGELOG.md', [
+  { name: 'OpenAI/Codex plugin packaging release note', re: /OpenAI\/Codex plugin packaging/i },
+  { name: 'platform capability documentation drift gate release note', re: /platform capability documentation consistency|documentation capability drift/i },
+]);
+
+if (failures) {
+  console.error(`\nDocumentation capability consistency: FAILED (${failures} issue${failures === 1 ? '' : 's'})`);
+  process.exit(1);
+}
+
+console.log('\nDocumentation capability consistency: PASSED');

package/ci/fable-mode-test.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+const selector = path.join(root, 'fable-mode', 'scripts', 'model-selector.js');
+const router = path.join(root, 'harness-everything', 'scripts', 'tier-router.js');
+const auditDir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-fable-mode-'));
+const auditFile = path.join(auditDir, 'audit.jsonl');
+
+function runNode(file, args) {
+  return spawnSync(process.execPath, [file, ...args], {
+    cwd: root,
+    encoding: 'utf8'
+  });
+}
+
+function selectorArgs(overrides = {}) {
+  const input = {
+    requested: 'opus',
+    available: 'opus,sonnet,haiku',
+    'available-agents': 'fable-orchestrator,fable-worker-sonnet,fable-worker-haiku',
+    fallback: 'stop',
+    'host-model': 'opus',
+    'audit-file': auditFile,
+    'stage-brief': 'Choose the architecture',
+    'pass-condition': 'ADR exists and names the decision',
+    'verification-command': 'npm test',
+    'verifier-result': 'pending',
+    ...overrides
+  };
+  return Object.entries(input).flatMap(([key, value]) => [`--${key}`, value]);
+}
+
+function readRecord(result) {
+  assert.ok(result.stdout.trim(), `selector produced no JSON: ${result.stderr}`);
+  return JSON.parse(result.stdout);
+}
+
+console.log('=== Fable model mode contract tests ===');
+
+const selected = runNode(selector, selectorArgs());
+assert.strictEqual(selected.status, 0, selected.stderr);
+const selectedRecord = readRecord(selected);
+assert.strictEqual(selectedRecord.status, 'selected');
+assert.strictEqual(selectedRecord.requestedModel, 'opus');
+assert.strictEqual(selectedRecord.effectiveModel, 'opus');
+assert.strictEqual(selectedRecord.fallbackReason, 'none');
+assert.strictEqual(selectedRecord.agent, 'fable-orchestrator');
+
+const sonnect = runNode(selector, selectorArgs({ requested: 'sonnect', available: 'haiku,sonnet' }));
+assert.strictEqual(sonnect.status, 0, sonnect.stderr);
+const sonnectRecord = readRecord(sonnect);
+assert.strictEqual(sonnectRecord.requestedModel, 'sonnet');
+assert.strictEqual(sonnectRecord.requestedInput, 'sonnect');
+
+const inline = runNode(selector, selectorArgs({
+  requested: 'opus',
+  available: 'sonnet',
+  fallback: 'inline',
+  'host-model': 'sonnet'
+}));
+assert.strictEqual(inline.status, 0, inline.stderr);
+const inlineRecord = readRecord(inline);
+assert.strictEqual(inlineRecord.status, 'fallback');
+assert.strictEqual(inlineRecord.effectiveModel, 'sonnet');
+assert.match(inlineRecord.fallbackReason, /opus is not in availableModels/);
+assert.strictEqual(inlineRecord.escalationRequired, false);
+
+const blocked = runNode(selector, selectorArgs({ requested: 'opus', available: 'sonnet' }));
+assert.strictEqual(blocked.status, 2);
+const blockedRecord = readRecord(blocked);
+assert.strictEqual(blockedRecord.status, 'blocked');
+assert.strictEqual(blockedRecord.effectiveModel, null);
+assert.strictEqual(blockedRecord.escalationRequired, true);
+assert.match(blockedRecord.fallbackReason, /inline fallback was not authorized/);
+
+const missingAgent = runNode(selector, selectorArgs({
+  requested: 'sonnet',
+  available: 'sonnet',
+  'available-agents': 'fable-worker-haiku',
+  fallback: 'inline',
+  'host-model': 'opus'
+}));
+assert.strictEqual(missingAgent.status, 0, missingAgent.stderr);
+const missingAgentRecord = readRecord(missingAgent);
+assert.strictEqual(missingAgentRecord.status, 'fallback');
+assert.strictEqual(missingAgentRecord.effectiveModel, 'opus');
+assert.match(missingAgentRecord.fallbackReason, /fable-worker-sonnet is not in availableAgents/);
+
+const missingField = runNode(selector, selectorArgs({ 'pass-condition': '' }));
+assert.strictEqual(missingField.status, 2);
+assert.match(missingField.stderr, /passCondition is required/);
+
+const explicitRoute = runNode(router, ['fable on sonnect for architecture synthesis']);
+assert.strictEqual(explicitRoute.status, 0);
+assert.match(explicitRoute.stdout, /REQUESTED FABLE MODEL MODE: sonnet/);
+assert.match(explicitRoute.stdout, /fable-mode\/fable-sonnet\/SKILL\.md/);
+
+const ordinaryTier2 = runNode(router, ['Fix this checkout bug and add a regression test.']);
+assert.strictEqual(ordinaryTier2.status, 0);
+assert.match(ordinaryTier2.stdout, /RECOMMENDED TIER: Tier 2/);
+assert.doesNotMatch(ordinaryTier2.stdout, /REQUESTED FABLE MODEL MODE/);
+assert.doesNotMatch(ordinaryTier2.stdout, /fable-opus\/SKILL\.md/);
+
+const auditLines = fs.readFileSync(auditFile, 'utf8').trim().split(/\r?\n/).filter(Boolean);
+assert.strictEqual(auditLines.length, 5);
+for (const line of auditLines) {
+  const record = JSON.parse(line);
+  for (const field of ['requestedModel', 'effectiveModel', 'fallbackReason', 'stageBrief', 'passCondition', 'verificationCommand', 'verifierResult']) {
+    assert.ok(Object.prototype.hasOwnProperty.call(record, field), `audit missing ${field}`);
+  }
+}
+fs.rmSync(auditDir, { recursive: true, force: true });
+
+console.log('PASS: selected, sonnect alias, inline fallback, blocked escalation, audit fields, and routing separation');

package/ci/fixtures/agency-agents/divisions.json

@@ -0,0 +1,6 @@
+{
+  "divisions": {
+    "engineering": { "label": "Engineering", "icon": "Code", "color": "#3B82F6" },
+    "testing": { "label": "Testing", "icon": "FlaskConical", "color": "#F59E0B" }
+  }
+}

package/ci/fixtures/agency-agents/engineering/code-reviewer.md

@@ -0,0 +1,11 @@
+---
+name: Code Reviewer
+description: Reviews code for correctness, security, and maintainability.
+color: purple
+emoji: eye
+vibe: Evidence before approval.
+---
+
+# Code Reviewer
+
+Review only the files named in the dispatch brief and return a structured handoff.

package/ci/fixtures/agency-agents/testing/reality-checker.md

@@ -0,0 +1,11 @@
+---
+name: Reality Checker
+description: Checks release readiness against observable evidence.
+color: red
+emoji: check
+vibe: Needs proof before sign-off.
+---
+
+# Reality Checker
+
+Reject unverifiable claims and report the evidence needed for a bounded handoff.

package/ci/fixtures/bad-frontmatter-colon/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: bad-frontmatter-colon
+description: This description has an unquoted colon: which breaks YAML parsers
+license: Apache-2.0
+metadata:
+  author: Test
+  version: 0.0.1
+---
+
+# Bad Frontmatter Colon
+
+## USE FOR:
+- Testing
+
+## DO NOT USE FOR:
+- Production

package/ci/fixtures/duplicate-description/skill-a/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: duplicate-a
+description: Identical description used for collision testing purposes only
+license: Apache-2.0
+metadata:
+  author: Test
+  version: 0.0.1
+---
+
+# Duplicate A
+
+## USE FOR:
+- Testing
+
+## DO NOT USE FOR:
+- Production

package/ci/fixtures/duplicate-description/skill-b/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: duplicate-b
+description: Identical description used for collision testing purposes only
+license: Apache-2.0
+metadata:
+  author: Test
+  version: 0.0.1
+---
+
+# Duplicate B
+
+## USE FOR:
+- Testing
+
+## DO NOT USE FOR:
+- Production

package/ci/fixtures/phase4/parallel-disjoint.stages.json

@@ -0,0 +1,32 @@
+{
+  "stages": [
+    {
+      "stageId": "security-doc",
+      "goal": "Write the security review artifact",
+      "agent": "fable-worker-sonnet",
+      "task": "Produce the security review only in its declared output scope.",
+      "inputs": ["src/auth"],
+      "expectedOutputs": ["docs/security/review.md"],
+      "outputPath": "docs/security/review.md",
+      "dependsOn": [],
+      "writeSet": ["docs/security"],
+      "checkCommand": null,
+      "passCondition": "security review artifact exists",
+      "failureReturn": "failure summary + evidence + missing prerequisite"
+    },
+    {
+      "stageId": "architecture-doc",
+      "goal": "Write the architecture review artifact",
+      "agent": "fable-worker-sonnet",
+      "task": "Produce the architecture review only in its declared output scope.",
+      "inputs": ["src"],
+      "expectedOutputs": ["docs/architecture/review.md"],
+      "outputPath": "docs/architecture/review.md",
+      "dependsOn": [],
+      "writeSet": ["docs/architecture"],
+      "checkCommand": null,
+      "passCondition": "architecture review artifact exists",
+      "failureReturn": "failure summary + evidence + missing prerequisite"
+    }
+  ]
+}

package/ci/fixtures/phase4/parallel-read-only.stages.json

@@ -0,0 +1,32 @@
+{
+  "stages": [
+    {
+      "stageId": "security-audit",
+      "goal": "Audit authentication security without editing files",
+      "agent": "fable-worker-sonnet",
+      "task": "Inspect the authentication surface and return evidence-backed findings.",
+      "inputs": ["src/auth"],
+      "expectedOutputs": ["security findings"],
+      "outputPath": null,
+      "dependsOn": [],
+      "writeSet": [],
+      "checkCommand": null,
+      "passCondition": "evidence-backed findings returned",
+      "failureReturn": "failure summary + evidence + missing prerequisite"
+    },
+    {
+      "stageId": "architecture-audit",
+      "goal": "Audit architecture boundaries without editing files",
+      "agent": "fable-worker-sonnet",
+      "task": "Inspect architecture boundaries and return evidence-backed findings.",
+      "inputs": ["src"],
+      "expectedOutputs": ["architecture findings"],
+      "outputPath": null,
+      "dependsOn": [],
+      "writeSet": [],
+      "checkCommand": null,
+      "passCondition": "evidence-backed findings returned",
+      "failureReturn": "failure summary + evidence + missing prerequisite"
+    }
+  ]
+}