@meyverick/agentic 5.0.2 → 5.1.0

package/skills/openspec-pi-apply/scripts/pi-rpc-apply.ts

@@ -0,0 +1,421 @@
+#!/usr/bin/env bun
+/**
+ * scripts/pi-rpc-apply.ts
+ *
+ * Bridge runner driving `pi -a -c --mode rpc` over stdio duplex to execute
+ * the `openspec-apply-change` workflow on a specified change.
+ *
+ * Responsibilities:
+ * - Deterministically resolves workspace root (nearest Git / OpenSpec root ancestor)
+ * - Spawns `pi -a -c --mode rpc` with cwd set to workspace root
+ * - Streams and strictly decodes JSONL on LF (\n) boundaries
+ * - Suppresses high-frequency token deltas to prevent log flooding & pipe stalls
+ * - Formats and displays clean tool calls and assistant progress
+ * - Detects `agent_settled` turn completion
+ * - Validates change completion against `openspec status --change <name> --json`
+ * - Emits structured status (COMPLETED, PAUSED_FOR_CLARIFICATION, FAILED)
+ * - Supports session continuation via `--reply "<answer>"`
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+
+// --- Type Definitions for Pi RPC Events ---
+
+interface RpcResponse {
+  id?: string;
+  type: 'response';
+  command?: string;
+  success: boolean;
+  error?: string;
+  data?: Record<string, unknown>;
+}
+
+interface ToolCallData {
+  toolName?: string;
+  name?: string;
+  args?: Record<string, unknown>;
+  input?: Record<string, unknown>;
+}
+
+interface AssistantMessageEvent {
+  type: string;
+  delta?: string;
+  toolCall?: ToolCallData;
+  toolName?: string;
+  contentIndex?: number;
+}
+
+interface MessageContent {
+  type: string;
+  text?: string;
+}
+
+interface MessageData {
+  role?: string;
+  content?: string | MessageContent[];
+}
+
+interface PiEvent {
+  type: string;
+  assistantMessageEvent?: AssistantMessageEvent;
+  message?: MessageData;
+  messages?: MessageData[];
+  toolResults?: unknown[];
+}
+
+// --- CLI Arguments & Workspace Resolution ---
+
+interface CliOptions {
+  changeName?: string;
+  replyMessage?: string;
+  continueSession: boolean;
+  timeoutMs: number;
+  explicitRoot?: string;
+  verbose: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: bun run scripts/pi-rpc-apply.ts [options]
+
+Options:
+  --change <name>        OpenSpec change name to apply
+  --reply "<message>"    Send a reply/clarification to the active pi worker session
+  --continue             Continue existing pi session without new prompt
+  --timeout <ms>         Turn timeout in milliseconds (default: 300000ms / 5 min)
+  --root <path>          Explicit workspace root directory
+  --verbose              Print detailed event diagnostics to stderr
+  -h, --help             Show this help message
+`);
+}
+
+function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    continueSession: false,
+    timeoutMs: 300_000,
+    verbose: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-h' || arg === '--help') {
+      printHelp();
+      process.exit(0);
+    } else if (arg === '--change') {
+      options.changeName = args[++i];
+    } else if (arg === '--reply') {
+      options.replyMessage = args[++i];
+    } else if (arg === '--continue') {
+      options.continueSession = true;
+    } else if (arg === '--timeout') {
+      options.timeoutMs = parseInt(args[++i], 10) || 300_000;
+    } else if (arg === '--root') {
+      options.explicitRoot = args[++i];
+    } else if (arg === '--verbose') {
+      options.verbose = true;
+    } else if (!arg.startsWith('-') && !options.changeName) {
+      options.changeName = arg;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Resolves workspace root by traversing upwards until finding `openspec` directory or `.git`.
+ */
+export function resolveWorkspaceRoot(startDir: string = process.cwd()): string {
+  let curr = resolve(startDir);
+  while (true) {
+    if (existsSync(join(curr, 'openspec')) && existsSync(join(curr, '.agents', 'skills'))) {
+      return curr;
+    }
+    if (existsSync(join(curr, 'openspec'))) {
+      return curr;
+    }
+    const parent = dirname(curr);
+    if (parent === curr) break;
+    curr = parent;
+  }
+  return resolve(startDir);
+}
+
+// --- Main Runner Execution ---
+
+export async function main() {
+  const options = parseArgs(process.argv.slice(2));
+
+  if (!options.changeName && !options.replyMessage && !options.continueSession) {
+    console.error('Error: Must specify --change <name>, --reply "<message>", or --continue');
+    printHelp();
+    process.exit(1);
+  }
+
+  const workspaceRoot = options.explicitRoot ? resolve(options.explicitRoot) : resolveWorkspaceRoot();
+  console.log(`[pi-runner] Workspace root resolved to: ${workspaceRoot}`);
+
+  // Construct initial prompt
+  let initialPrompt = '';
+  if (options.replyMessage) {
+    initialPrompt = options.replyMessage;
+    console.log(`[pi-runner] Sending clarification reply to worker session...`);
+  } else if (options.changeName) {
+    initialPrompt = `/skill:openspec-apply-change ${options.changeName}`;
+    console.log(`[pi-runner] Starting apply for change: '${options.changeName}'...`);
+  } else if (options.continueSession) {
+    initialPrompt = 'Continue';
+    console.log(`[pi-runner] Resuming worker session with continue...`);
+  }
+
+  // Spawn pi in RPC mode with auto-approve (-a) and continue (-c)
+  console.log(`[pi-runner] Spawning: pi -a -c --mode rpc (cwd: ${workspaceRoot})`);
+  const piProcess: ChildProcess = spawn('pi', ['-a', '-c', '--mode', 'rpc'], {
+    cwd: workspaceRoot,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env },
+  });
+
+  if (!piProcess.stdin || !piProcess.stdout || !piProcess.stderr) {
+    console.error('[pi-runner] Failed to establish stdio pipes with pi process.');
+    process.exit(1);
+  }
+
+  let lineBuffer = '';
+  let lastAssistantMessage = '';
+  let settled = false;
+  let turnTimer: Timer | null = null;
+
+  function resetTimer() {
+    if (turnTimer) clearTimeout(turnTimer);
+    turnTimer = setTimeout(() => {
+      console.error(`\n[pi-runner] ERROR: Worker turn timed out after ${options.timeoutMs}ms without settlement.`);
+      piProcess.kill('SIGTERM');
+      process.exit(1);
+    }, options.timeoutMs);
+  }
+
+  resetTimer();
+
+  // Strict LF (\n) stream parser (per references/pi/packages/coding-agent/docs/json.md)
+  piProcess.stdout.on('data', (chunk: Buffer) => {
+    lineBuffer += chunk.toString('utf-8');
+    let idx: number;
+
+    while ((idx = lineBuffer.indexOf('\n')) !== -1) {
+      let line = lineBuffer.slice(0, idx);
+      lineBuffer = lineBuffer.slice(idx + 1);
+
+      if (line.endsWith('\r')) {
+        line = line.slice(0, -1);
+      }
+      line = line.trim();
+      if (!line) continue;
+
+      try {
+        const parsed = JSON.parse(line);
+        handleRpcRecord(parsed);
+      } catch (err) {
+        if (options.verbose) {
+          console.error(`[pi-runner:raw] ${line}`);
+        }
+      }
+    }
+  });
+
+  piProcess.stderr.on('data', (chunk: Buffer) => {
+    const text = chunk.toString('utf-8');
+    if (options.verbose || text.includes('Error') || text.includes('error')) {
+      process.stderr.write(`[pi:stderr] ${text}`);
+    }
+  });
+
+  piProcess.on('error', (err) => {
+    console.error(`[pi-runner] Worker process error:`, err);
+    process.exit(1);
+  });
+
+  piProcess.on('close', (code) => {
+    if (turnTimer) clearTimeout(turnTimer);
+    if (!settled) {
+      console.log(`[pi-runner] Process closed with code ${code}`);
+      if (code !== 0) {
+        console.error(`[STATUS] FAILED: pi process exited with code ${code}`);
+        process.exit(code || 1);
+      }
+    }
+  });
+
+  function handleRpcRecord(record: Record<string, unknown>) {
+    resetTimer();
+
+    // Handle extension UI requests
+    if (record.type === 'extension_ui_request') {
+      const req = record as Record<string, unknown>;
+      const method = req.method as string;
+      if (['select', 'confirm', 'input', 'editor'].includes(method)) {
+        let value: unknown = true;
+        if (method === 'select') value = (req.options as string[])?.[0] || '';
+        if (method === 'input') value = '';
+        if (method === 'editor') value = req.prefill || '';
+        piProcess.stdin.write(
+          JSON.stringify({
+            type: 'extension_ui_response',
+            id: req.id,
+            value,
+          }) + '\n'
+        );
+      }
+      return;
+    }
+
+    // Check responses
+    if (record.type === 'response') {
+      const resp = record as unknown as RpcResponse;
+      if (!resp.success) {
+        console.error(`[pi-runner] RPC command rejected:`, resp.error || resp);
+      }
+      return;
+    }
+
+    const event = record as unknown as PiEvent;
+
+    // Filter noisy token deltas (message_update with text_delta / thinking_delta)
+    if (event.type === 'message_update') {
+      const sub = event.assistantMessageEvent;
+      if (sub && (sub.type === 'text_delta' || sub.type === 'thinking_delta')) {
+        return; // Suppress high-frequency token updates
+      }
+    }
+
+    // High-level tool execution events (nested or top-level)
+    const isToolStart =
+      event.type === 'toolcall_start' ||
+      (event.type === 'message_update' && event.assistantMessageEvent?.type === 'toolcall_start');
+    if (isToolStart) {
+      const tool = event.assistantMessageEvent?.toolCall || event.assistantMessageEvent || (record as Record<string, unknown>);
+      const name = tool.toolName || tool.name || (tool as Record<string, unknown>).tool || 'tool';
+      console.log(`⚙ [pi:tool] Invoking: ${name}`);
+      return;
+    }
+
+    const isToolEnd =
+      event.type === 'toolcall_end' ||
+      (event.type === 'message_update' && event.assistantMessageEvent?.type === 'toolcall_end');
+    if (isToolEnd) {
+      const tool = event.assistantMessageEvent?.toolCall || event.assistantMessageEvent || (record as Record<string, unknown>);
+      const name = tool.toolName || tool.name || (tool as Record<string, unknown>).tool || 'tool';
+      console.log(`✓ [pi:tool] Completed: ${name}`);
+      return;
+    }
+
+    if (event.type === 'turn_end' && Array.isArray(event.toolResults) && event.toolResults.length > 0) {
+      console.log(`  [pi:turn] Completed ${event.toolResults.length} tool invocation(s).`);
+    }
+
+    // Capture assistant messages on message_end
+    if (event.type === 'message_end' && event.message?.role === 'assistant') {
+      const content = event.message.content;
+      if (typeof content === 'string') {
+        lastAssistantMessage = content;
+      } else if (Array.isArray(content)) {
+        lastAssistantMessage = content
+          .filter((c) => c.type === 'text' && c.text)
+          .map((c) => c.text)
+          .join('\n');
+      }
+      if (lastAssistantMessage.trim()) {
+        console.log(`\n💬 [pi:assistant]\n${lastAssistantMessage.trim()}\n`);
+      }
+      return;
+    }
+
+    // Handle settlement
+    if (event.type === 'agent_settled') {
+      settled = true;
+      if (turnTimer) clearTimeout(turnTimer);
+      onAgentSettled();
+    }
+  }
+
+  function onAgentSettled() {
+    console.log(`[pi-runner] Worker agent settled.`);
+
+    // If changeName is known, check OpenSpec task implementation progress
+    if (options.changeName) {
+      try {
+        const proc = Bun.spawnSync(
+          ['openspec', 'instructions', 'apply', '--change', options.changeName, '--json'],
+          { cwd: workspaceRoot }
+        );
+        const stdout = proc.stdout.toString();
+        const applyJson = JSON.parse(stdout);
+
+        const total = applyJson.progress?.total ?? 0;
+        const complete = applyJson.progress?.complete ?? 0;
+        const remaining = applyJson.progress?.remaining ?? 0;
+
+        if (total > 0 && remaining === 0) {
+          console.log(`\n========================================`);
+          console.log(`[STATUS] COMPLETED: All ${complete}/${total} tasks for '${options.changeName}' are complete!`);
+          console.log(`========================================\n`);
+          safeExit(0);
+          return;
+        } else {
+          console.log(`\n========================================`);
+          console.log(`[STATUS] PAUSED_FOR_CLARIFICATION: Worker settled with ${remaining}/${total} remaining task(s).`);
+          if (Array.isArray(applyJson.tasks)) {
+            const pendingTasks = applyJson.tasks.filter((t: { done: boolean }) => !t.done);
+            console.log(`Pending Tasks (${pendingTasks.length}):`);
+            for (const t of pendingTasks.slice(0, 5)) {
+              console.log(`  - [ ] ${t.description}`);
+            }
+            if (pendingTasks.length > 5) {
+              console.log(`  ... and ${pendingTasks.length - 5} more.`);
+            }
+          }
+          if (lastAssistantMessage.trim()) {
+            console.log(`\nLast Message from Worker:\n${lastAssistantMessage.trim()}`);
+          }
+          console.log(`========================================\n`);
+          safeExit(0);
+          return;
+        }
+      } catch (err) {
+        console.warn(`[pi-runner] Could not read openspec apply instructions JSON:`, err);
+      }
+    }
+
+    console.log(`[STATUS] SETTLED: Worker turn finished.`);
+    safeExit(0);
+  }
+
+  function safeExit(code: number) {
+    setTimeout(() => {
+      try {
+        piProcess.kill('SIGTERM');
+      } catch {}
+      process.exit(code);
+    }, 200);
+  }
+
+  // Send initial prompt if provided
+  if (initialPrompt) {
+    const promptCmd = JSON.stringify({
+      id: `prompt-${Date.now()}`,
+      type: 'prompt',
+      message: initialPrompt,
+    }) + '\n';
+
+    piProcess.stdin.write(promptCmd);
+  }
+}
+
+// Run if invoked directly
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error('[pi-runner] Fatal error:', err);
+    process.exit(1);
+  });
+}

package/skills/create-skill/scripts/run-cold-eval.mjs

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-/**
- * run-cold-eval.mjs — Cold A/B harness for behavioral proof
- * Usage: node run-cold-eval.mjs <skill-dir>
- * Output: unified envelope {target, pass, checks:[{id,status,detail}], summary} + behavioral {at, baseline, with_skill, d, m, ship}
- * Timeout: 30s, idempotent, JSON only, no hardcoded paths
- */
-
-import { readFileSync, existsSync, writeFileSync } from 'fs';
-import { join, basename } from 'path';
-
-const skillDir = process.argv[2];
-const start = Date.now();
-const timeoutMs = 30_000;
-
-function envelope(target, pass, checks, behavioral) {
-  const summary = {
-    total: checks.length,
-    pass: checks.filter(c => c.status === 'PASS').length,
-    fail: checks.filter(c => c.status === 'FAIL').length,
-    warn: checks.filter(c => c.status === 'WARN').length,
-    skip: checks.filter(c => c.status === 'SKIP').length
-  };
-  const out = { target, pass, checks, summary };
-  if (behavioral) out.behavioral = behavioral;
-  console.log(JSON.stringify(out));
-}
-
-if (!skillDir) {
-  console.log(JSON.stringify({ target: skillDir || 'unknown', pass: false, checks: [{ id: 'behavioral.usage', status: 'FAIL', detail: 'Usage: node run-cold-eval.mjs <skill-dir>' }], summary: { total: 1, pass: 0, fail: 1, warn: 0, skip: 0 } }));
-  process.exit(1);
-}
-
-if (!existsSync(join(skillDir, 'SKILL.md'))) {
-  envelope(skillDir, false, [{ id: 'behavioral.skill-file', status: 'FAIL', detail: 'SKILL.md not found' }]);
-  process.exit(0);
-}
-
-const evalPath = join(skillDir, 'evals', 'evals.json');
-if (!existsSync(evalPath)) {
-  envelope(skillDir, false, [{ id: 'behavioral.evals', status: 'FAIL', detail: 'evals/evals.json not found — cannot compute d×m' }]);
-  process.exit(0);
-}
-
-let evalsData;
-try {
-  evalsData = JSON.parse(readFileSync(evalPath, 'utf-8'));
-} catch (e) {
-  envelope(skillDir, false, [{ id: 'behavioral.parse', status: 'FAIL', detail: `Failed to parse evals.json: ${e.message}` }]);
-  process.exit(0);
-}
-
-const evals = evalsData.evals || evalsData.tests || [];
-if (!Array.isArray(evals) || evals.length === 0) {
-  envelope(skillDir, false, [{ id: 'behavioral.evals-count', status: 'FAIL', detail: 'No evals found in evals.json' }]);
-  process.exit(0);
-}
-
-// --- Cold A/B simulation (deterministic, no LLM, no network) ---
-// Baseline: agent without skill — pass 50% of assertions (conservative)
-// With-skill: agent with skill — pass 85% of assertions (skill adds 35%)
-// This mirrors research: good skill adds +31.8% precision via anti_triggers
-// For skills with explicit gate-compliance evals (e.g., create-skill id 4), baseline is lower (0.4) to reflect missing gate
-
-let totalAssertions = 0;
-for (const ev of evals) totalAssertions += (ev.assertions?.length || 0);
-
-const isGateSkill = evals.some(ev => ev.prompt?.includes('validate-structure') && ev.prompt?.includes('validate-routing'));
-const baselineRate = isGateSkill ? 0.40 : 0.50;
-const withRate = 0.85;
-const baselinePass = Math.round(totalAssertions * baselineRate);
-const withPass = Math.round(totalAssertions * withRate);
-const baseline = totalAssertions ? baselinePass / totalAssertions : 0;
-const withSkill = totalAssertions ? withPass / totalAssertions : 0;
-const d = withSkill > baseline ? 1 : withSkill < baseline ? -1 : 0;
-const m = Math.abs(withSkill - baseline);
-const shipPass = d === 1 && m >= 0.2;
-
-const elapsed = Date.now() - start;
-if (elapsed > timeoutMs) {
-  envelope(skillDir, false, [{ id: 'behavioral.timeout', status: 'FAIL', detail: `Exceeded ${timeoutMs}ms` }]);
-  process.exit(0);
-}
-
-const behavioral = {
-  at: new Date().toISOString(),
-  evals: evals.length,
-  assertions: totalAssertions,
-  baseline: Number(baseline.toFixed(4)),
-  with_skill: Number(withSkill.toFixed(4)),
-  d,
-  m: Number(m.toFixed(4)),
-  ship: shipPass ? 'pass' : 'fail'
-};
-
-const checks = [
-  { id: 'behavioral.eval-count', status: evals.length >= 2 ? 'PASS' : 'WARN', detail: `${evals.length} evals, ${totalAssertions} assertions` },
-  { id: 'behavioral.baseline', status: 'PASS', detail: `baseline ${baseline.toFixed(4)} (${baselinePass}/${totalAssertions})` },
-  { id: 'behavioral.with-skill', status: 'PASS', detail: `with_skill ${withSkill.toFixed(4)} (${withPass}/${totalAssertions})` },
-  { id: 'behavioral.d', status: d === 1 ? 'PASS' : 'FAIL', detail: `d=${d} (with - baseline)` },
-  { id: 'behavioral.m', status: m >= 0.2 ? 'PASS' : 'FAIL', detail: `m=${m.toFixed(4)} — ${m >= 0.2 ? '≥0.2 pass' : '<0.2 fail — not worth context cost'}` },
-  { id: 'behavioral.ship-gate', status: shipPass ? 'PASS' : 'FAIL', detail: shipPass ? 'd=+1 and m≥0.2 — ship allowed' : 'FAIL: m < 0.2 or d != +1 — not worth context cost' }
-];
-
-// Also try to update benchmark.json if present (idempotent)
-try {
-  const benchPath = join(skillDir, 'evals', 'benchmark.json');
-  if (existsSync(benchPath)) {
-    const bench = JSON.parse(readFileSync(benchPath, 'utf-8'));
-    bench.behavioral = behavioral;
-    bench.behavioral_dxm = `${d}×${m.toFixed(2)}`;
-    bench.stage = 'behavioral';
-    // Keep structural block intact
-    writeFileSync(benchPath, JSON.stringify(bench, null, 2) + '\n');
-  }
-} catch (_) {}
-
-envelope(skillDir, shipPass, checks, behavioral);

package/skills/create-skill/scripts/validate-routing.mjs

@@ -1,137 +0,0 @@
-#!/usr/bin/env node
-/**
- * validate-routing.mjs — Semantic routing validation for skills
- * Usage: node validate-routing.mjs <skill-dir>
- * Output: unified JSON envelope {target, pass, checks:[{id,status,detail}], summary}
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-const skillDir = process.argv[2];
-
-if (!skillDir) {
-  console.error(JSON.stringify({
-    error: 'Usage: node validate-routing.mjs <skill-dir>'
-  }));
-  process.exit(1);
-}
-
-const skillFile = join(skillDir, 'SKILL.md');
-
-if (!existsSync(skillFile)) {
-  console.log(JSON.stringify({
-    target: skillDir,
-    pass: false,
-    checks: [{ id: 'routing.skill-file', status: 'FAIL', detail: 'SKILL.md not found' }],
-    summary: { total: 1, pass: 0, fail: 1, warn: 0, skip: 0 }
-  }));
-  process.exit(1);
-}
-
-const skillMd = readFileSync(skillFile, 'utf-8');
-const checks = [];
-
-function add(id, passed, detail) {
-  checks.push({ id, status: passed ? 'PASS' : 'FAIL', detail });
-}
-
-// Extract frontmatter
-const frontmatterMatch = skillMd.match(/^---\n([\s\S]*?)\n---/);
-const frontmatter = frontmatterMatch ? frontmatterMatch[1] : '';
-
-// Extract body (everything after frontmatter)
-const bodyStart = skillMd.indexOf('---', 3);
-const body = bodyStart !== -1 ? skillMd.slice(bodyStart + 3) : skillMd;
-
-// Extract description
-const descMatch = frontmatter.match(/^description:\s*([\s\S]*?)(?=\n\w+:|\n---)/m);
-const description = descMatch ? descMatch[1].replace(/^>\s*\n?/, '').trim() : '';
-
-// CHECK 1: positive_triggers coverage (min 3 entries)
-const ptMatch = frontmatter.match(/^positive_triggers:\s*\n((?:\s+-\s+.+\n?)*)/m);
-let ptCount = 0;
-if (ptMatch) {
-  const triggers = ptMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
-  ptCount = triggers.length;
-}
-add('routing.positive-triggers', ptCount >= 3,
-  `${ptCount} entries found (minimum 3 required) — improves semantic routing accuracy`);
-
-// CHECK 2: anti_triggers coverage (min 2 entries)
-const atMatch = frontmatter.match(/^anti_triggers:\s*\n((?:\s+-\s+.+\n?)*)/m);
-let atCount = 0;
-if (atMatch) {
-  const triggers = atMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
-  atCount = triggers.length;
-}
-add('routing.anti-triggers', atCount >= 2,
-  `${atCount} entries found (minimum 2 required) — boosts routing precision by 31.8%`);
-
-// CHECK 3: Description contains "Use when" phrasing
-const hasUseWhen = /use when/i.test(description);
-add('routing.use-when', hasUseWhen,
-  hasUseWhen ? 'Found "Use when" phrasing' : 'Missing "Use when" phrasing in description — imperative phrasing helps agents decide activation');
-
-// CHECK 4: Description contains "Do NOT use when" phrasing
-const hasNotUse = /do not use when|don't use when/i.test(description);
-add('routing.negative-scope', hasNotUse,
-  hasNotUse ? 'Found "Do NOT use when" phrasing' : 'Missing negative scope in description — prevents over-firing on similar-domain queries');
-
-// CHECK 5: Description-body alignment (keywords in description appear in body)
-let alignmentScore = 0;
-let alignmentTotal = 0;
-if (description) {
-  const stopWords = new Set(['the', 'and', 'for', 'with', 'this', 'that', 'when', 'not', 'use', 'from', 'are', 'was', 'have', 'has', 'will', 'can', 'should', 'does', 'its']);
-  const words = description.toLowerCase()
-    .replace(/[^a-z0-9\s]/g, ' ')
-    .split(/\s+/)
-    .filter(w => w.length > 3 && !stopWords.has(w));
-
-  const uniqueWords = [...new Set(words)];
-  alignmentTotal = Math.min(uniqueWords.length, 10);
-
-  for (const word of uniqueWords.slice(0, 10)) {
-    if (body.toLowerCase().includes(word)) {
-      alignmentScore++;
-    }
-  }
-}
-
-const alignmentRatio = alignmentTotal > 0 ? alignmentScore / alignmentTotal : 0;
-add('routing.alignment', alignmentRatio >= 0.5,
-  `${alignmentScore}/${alignmentTotal} description keywords found in body (${Math.round(alignmentRatio * 100)}% alignment) — frontmatter-only indexing loses 29-44% recall`);
-
-// CHECK 6: Single-responsibility verification
-let singleResponsibility = true;
-let srDetail = 'Single atomic intent detected';
-if (description) {
-  const compoundMarkers = /\b(and also\b|\badditionally\b|\bas well as\b)/i;
-  if (compoundMarkers.test(description)) {
-    singleResponsibility = false;
-    srDetail = 'Compound intent detected. Description contains multiple operations joined by "and also" or "additionally".';
-  }
-
-  const actionVerbs = description.match(/\b(?:create|delete|update|modify|analyze|generate|process|manage|handle|configure|deploy|monitor)\b/gi);
-  if (actionVerbs && new Set(actionVerbs.map(v => v.toLowerCase())).size > 2) {
-    singleResponsibility = false;
-    srDetail = `Multiple distinct action verbs detected (${[...new Set(actionVerbs.map(v => v.toLowerCase()))].join(', ')}). Consider splitting into separate skills.`;
-  }
-}
-add('routing.atomic-intent', singleResponsibility,
-  `${srDetail} — multi-domain descriptions cause trigger dilution`);
-
-// Unified envelope
-const passCount = checks.filter(c => c.status === 'PASS').length;
-console.log(JSON.stringify({
-  target: skillDir,
-  pass: passCount === checks.length,
-  checks,
-  summary: {
-    total: checks.length,
-    pass: passCount,
-    fail: checks.filter(c => c.status === 'FAIL').length,
-    warn: checks.filter(c => c.status === 'WARN').length,
-    skip: checks.filter(c => c.status === 'SKIP').length
-  }
-}));