ai-developer-skill-os 10.1.0 → 10.2.0

package/tooling/build-registry.js

@@ -1,208 +1,226 @@
-/**
- * build-registry.js
- * V8.2 Governed Capability Metadata & Eval Platform
- * Generates registry/index.yaml (lightweight lookup) and registry/graph.json (O(1) graph & cycle check)
- * 
- * Usage: node tooling/build-registry.js
- */
-
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import yaml from 'js-yaml';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const SKILLS_DIR = path.join(__dirname, '../.agents/skills');
-const REGISTRY_DIR = path.join(__dirname, '../.agents/registry');
-const INDEX_YAML = path.join(REGISTRY_DIR, 'index.yaml');
-const GRAPH_JSON = path.join(REGISTRY_DIR, 'graph.json');
-
-function parseYamlFile(filePath) {
-  try {
-    let content = fs.readFileSync(filePath, 'utf8');
-    if (content.charCodeAt(0) === 0xFEFF) content = content.slice(1);
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (match) {
-      return yaml.load(match[1]);
-    }
-    return yaml.load(content);
-  } catch (e) {
-    console.error(`[WARN] Failed to parse YAML from ${filePath}: ${e.message}`);
-    return null;
-  }
-}
-
-function buildRegistry() {
-  console.log('🔄 Building V8.2 Governed Capability Registry & O(1) Runtime Graph...');
-
-  if (!fs.existsSync(SKILLS_DIR)) {
-    console.error('❌ Skills directory not found:', SKILLS_DIR);
-    process.exit(1);
-  }
-
-  fs.mkdirSync(REGISTRY_DIR, { recursive: true });
-
-  const dirs = fs.readdirSync(SKILLS_DIR).filter(d => 
-    !d.startsWith('_') && fs.statSync(path.join(SKILLS_DIR, d)).isDirectory()
-  );
-
-  const capabilities = {};
-  const adjacency = {};
-  const reverseAdjacency = {};
-
-  for (const dir of dirs) {
-    const capYamlPath = path.join(SKILLS_DIR, dir, 'capability.yaml');
-    const skillMdPath = path.join(SKILLS_DIR, dir, 'SKILL.md');
-    
-    let meta = null;
-    let fromCapabilityYaml = false;
-
-    let skillMdMeta = null;
-    if (fs.existsSync(skillMdPath)) {
-      skillMdMeta = parseYamlFile(skillMdPath);
-    }
-
-    if (fs.existsSync(capYamlPath)) {
-      meta = parseYamlFile(capYamlPath);
-      fromCapabilityYaml = true;
-    } else if (skillMdMeta) {
-      meta = skillMdMeta;
-    }
-
-    if (!meta) continue;
-
-    const id = meta.id || meta.name || dir;
-    const version = meta.version || skillMdMeta?.version || '8.2.0';
-    const status = meta.status || skillMdMeta?.status || 'stable';
-    const description = meta.description || skillMdMeta?.description || '';
-    
-    // Normalize tags
-    let tags = meta.tags || meta.keywords || [];
-    if (!Array.isArray(tags) || tags.length === 0) {
-      // Derive simple tags from dir words
-      tags = dir.replace(/^qk-/, '').split('-');
-    }
-
-    // Normalize dependencies
-    let dependencies = meta.dependencies || [];
-    if (!fromCapabilityYaml) {
-      // Derive from V8.1 skill frontmatter decision_boundary / workflow
-      const deps = new Set();
-      if (meta.workflow && typeof meta.workflow === 'string') deps.add(meta.workflow);
-      if (meta.decision_boundary?.delegates_to) {
-        meta.decision_boundary.delegates_to.forEach(d => deps.add(d));
-      }
-      dependencies = Array.from(deps);
-    }
-
-    capabilities[id] = {
-      path: `.agents/skills/${dir}`,
-      version,
-      status,
-      tags,
-      dependencies
-    };
-
-    adjacency[id] = dependencies;
-    if (!reverseAdjacency[id]) reverseAdjacency[id] = [];
-  }
-
-  // Populate reverse adjacency for orphan detection
-  for (const [id, deps] of Object.entries(adjacency)) {
-    for (const dep of deps) {
-      if (!reverseAdjacency[dep]) reverseAdjacency[dep] = [];
-      reverseAdjacency[dep].push(id);
-    }
-  }
-
-  // Detect cycles using DFS
-  let hasCycles = false;
-  const visited = {};
-  const recursionStack = {};
-
-  function detectCycle(node) {
-    visited[node] = true;
-    recursionStack[node] = true;
-
-    const deps = adjacency[node] || [];
-    for (const dep of deps) {
-      if (!visited[dep]) {
-        if (detectCycle(dep)) return true;
-      } else if (recursionStack[dep]) {
-        return true;
-      }
-    }
-
-    recursionStack[node] = false;
-    return false;
-  }
-
-  for (const node of Object.keys(adjacency)) {
-    if (!visited[node]) {
-      if (detectCycle(node)) {
-        hasCycles = true;
-        break;
-      }
-    }
-  }
-
-  // Build Graph JSON (O(1) Runtime lookups)
-  const graphNodes = {};
-  for (const [id, data] of Object.entries(capabilities)) {
-    const dependents = reverseAdjacency[id] || [];
-    const isOrphan = data.dependencies.length === 0 && dependents.length === 0 && id !== 'qk-orchestrator' && id !== 'qk-help';
-
-    graphNodes[id] = {
-      path: data.path,
-      version: data.version,
-      tags: data.tags,
-      dependencies: data.dependencies,
-      dependents,
-      is_orphan: isOrphan
-    };
-  }
-
-  const allIds = Object.keys(capabilities);
-  const activeSkills = allIds.filter(id => capabilities[id].status === 'stable' || capabilities[id].status === 'experimental');
-  const archivedSkills = allIds.filter(id => capabilities[id].status === 'archived');
-  const relocatedSkills = allIds.filter(id => capabilities[id].status === 'relocated');
-
-  const graphJsonData = {
-    schema_version: 1,
-    manifest_version: '8.2',
-    generated_at: new Date().toISOString(),
-    nodes: graphNodes,
-    adjacency,
-    stats: {
-      total_scanned: allIds.length,
-      active: activeSkills.length,
-      archived: archivedSkills.length,
-      relocated: relocatedSkills.length,
-      has_cycles: hasCycles
-    }
-  };
-
-  // Build Registry Index YAML (Lightweight lookup)
-  const indexYamlContent = `# AUTO-GENERATED BY registry-builder (tooling/build-registry.js)\n# DO NOT EDIT MANUALLY. THIS IS A GENERATED RUNTIME ARTIFACT.\n` +
-    yaml.dump({
-      schema_version: 1,
-      manifest_version: '8.2',
-      generated_at: new Date().toISOString(),
-      stats: {
-        total_scanned: allIds.length,
-        active: activeSkills.length,
-        archived: archivedSkills.length,
-        relocated: relocatedSkills.length
-      },
-      capabilities
-    }, { indent: 2 });
-
-  fs.writeFileSync(INDEX_YAML, indexYamlContent, 'utf8');
-  fs.writeFileSync(GRAPH_JSON, JSON.stringify(graphJsonData, null, 2), 'utf8');
-
-  console.log(`✅ Generated lightweight registry index at .agents/registry/index.yaml (${allIds.length} scanned: ${activeSkills.length} active, ${archivedSkills.length} archived, ${relocatedSkills.length} relocated)`);
-  console.log(`✅ Generated O(1) adjacency graph at .agents/registry/graph.json (active: ${activeSkills.length}, has_cycles: ${hasCycles})`);
-}
-
-buildRegistry();
+/**
+ * build-registry.js
+ * V10.2 Governed Capability Metadata & Eval Platform
+ * Generates registry/index.yaml (lightweight lookup) and registry/graph.json (O(1) graph & cycle check)
+ * 
+ * Usage: node tooling/build-registry.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const SKILLS_DIR = path.join(__dirname, '../.agents/skills');
+const REGISTRY_DIR = path.join(__dirname, '../.agents/registry');
+const INDEX_YAML = path.join(REGISTRY_DIR, 'index.yaml');
+const GRAPH_JSON = path.join(REGISTRY_DIR, 'graph.json');
+
+function parseYamlFile(filePath) {
+  try {
+    let content = fs.readFileSync(filePath, 'utf8');
+    if (content.charCodeAt(0) === 0xFEFF) content = content.slice(1);
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (match) {
+      return yaml.load(match[1]);
+    }
+    return yaml.load(content);
+  } catch (e) {
+    console.error(`[WARN] Failed to parse YAML from ${filePath}: ${e.message}`);
+    return null;
+  }
+}
+
+function buildRegistry() {
+  console.log('🔄 Building V10.2 Governed Capability Registry & O(1) Runtime Graph...');
+
+  if (!fs.existsSync(SKILLS_DIR)) {
+    console.error('❌ Skills directory not found:', SKILLS_DIR);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+
+  const dirs = fs.readdirSync(SKILLS_DIR).filter(d => 
+    !d.startsWith('_') && fs.statSync(path.join(SKILLS_DIR, d)).isDirectory()
+  );
+
+  const capabilities = {};
+  const adjacency = {};
+  const reverseAdjacency = {};
+
+  for (const dir of dirs) {
+    const capYamlPath = path.join(SKILLS_DIR, dir, 'capability.yaml');
+    const skillMdPath = path.join(SKILLS_DIR, dir, 'SKILL.md');
+    
+    let meta = null;
+    let fromCapabilityYaml = false;
+
+    let skillMdMeta = null;
+    if (fs.existsSync(skillMdPath)) {
+      skillMdMeta = parseYamlFile(skillMdPath);
+    }
+
+    if (fs.existsSync(capYamlPath)) {
+      meta = parseYamlFile(capYamlPath);
+      fromCapabilityYaml = true;
+    } else if (skillMdMeta) {
+      meta = skillMdMeta;
+    }
+
+    if (!meta) continue;
+
+    const id = meta.id || meta.name || dir;
+    const version = meta.version || skillMdMeta?.version || '8.2.0';
+    const status = meta.status || skillMdMeta?.status || 'stable';
+    const description = meta.description || skillMdMeta?.description || '';
+    
+    // Normalize tags
+    let tags = meta.tags || meta.keywords || [];
+    if (!Array.isArray(tags) || tags.length === 0) {
+      // Derive simple tags from dir words
+      tags = dir.replace(/^qk-/, '').split('-');
+    }
+
+    // Normalize dependencies - only use explicit skill-to-skill dependencies
+    let dependencies = meta.dependencies || [];
+    if (!fromCapabilityYaml) {
+      // Only use explicit dependencies, not workflow names
+      // workflow field identifies the primary workflow, not a dependency
+      const extraDeps = meta.decision_boundary?.delegates_to || [];
+      if (extraDeps.length > 0) {
+        const depSet = new Set([...dependencies, ...extraDeps]);
+        dependencies = Array.from(depSet);
+      }
+    }
+
+    capabilities[id] = {
+      path: `.agents/skills/${dir}`,
+      version,
+      status,
+      platforms: meta.platforms || ["antigravity", "claude", "opencode"],
+      tags,
+      dependencies
+    };
+
+    adjacency[id] = dependencies;
+    if (!reverseAdjacency[id]) reverseAdjacency[id] = [];
+  }
+
+  // ── Hardcoded Cross-Skill Edges (V10.2) ─────
+  // Directed acyclic graph: qk-orchestrator is the root hub
+  // It routes to all other skills. No other skill routes back to it.
+  const crossEdges = {
+    'qk-orchestrator': ['qk-prompt-compiler', 'qk-product-spec', 'qk-feature-delivery', 'qk-bug-resolution', 'qk-code-cleaner', 'qk-code-review', 'qk-ui-engineer', 'qk-backend-data', 'qk-devops-release', 'qk-api-data-discovery']
+  };
+
+  for (const [skillId, deps] of Object.entries(crossEdges)) {
+    if (adjacency[skillId]) {
+      adjacency[skillId] = [...new Set([...adjacency[skillId], ...deps])];
+    } else {
+      adjacency[skillId] = deps;
+    }
+  }
+
+  // Populate reverse adjacency for orphan detection
+  for (const [id, deps] of Object.entries(adjacency)) {
+    for (const dep of deps) {
+      if (!reverseAdjacency[dep]) reverseAdjacency[dep] = [];
+      reverseAdjacency[dep].push(id);
+    }
+  }
+
+  // Detect cycles using DFS
+  let hasCycles = false;
+  const visited = {};
+  const recursionStack = {};
+
+  function detectCycle(node) {
+    visited[node] = true;
+    recursionStack[node] = true;
+
+    const deps = adjacency[node] || [];
+    for (const dep of deps) {
+      if (!visited[dep]) {
+        if (detectCycle(dep)) return true;
+      } else if (recursionStack[dep]) {
+        return true;
+      }
+    }
+
+    recursionStack[node] = false;
+    return false;
+  }
+
+  for (const node of Object.keys(adjacency)) {
+    if (!visited[node]) {
+      if (detectCycle(node)) {
+        hasCycles = true;
+        break;
+      }
+    }
+  }
+
+  // Build Graph JSON (O(1) Runtime lookups)
+  const graphNodes = {};
+  for (const [id, data] of Object.entries(capabilities)) {
+    const dependents = reverseAdjacency[id] || [];
+    const isOrphan = data.dependencies.length === 0 && dependents.length === 0 && id !== 'qk-orchestrator' && id !== 'qk-help';
+
+    graphNodes[id] = {
+      path: data.path,
+      version: data.version,
+      platforms: data.platforms || ["antigravity", "claude", "opencode"],
+      tags: data.tags,
+      dependencies: data.dependencies,
+      dependents,
+      is_orphan: isOrphan
+    };
+  }
+
+  const allIds = Object.keys(capabilities);
+  const activeSkills = allIds.filter(id => capabilities[id].status === 'stable' || capabilities[id].status === 'experimental');
+  const archivedSkills = allIds.filter(id => capabilities[id].status === 'archived');
+  const relocatedSkills = allIds.filter(id => capabilities[id].status === 'relocated');
+
+  const graphJsonData = {
+    schema_version: 1,
+    manifest_version: '10.2',
+    generated_at: new Date().toISOString(),
+    nodes: graphNodes,
+    edges: Object.entries(adjacency).flatMap(([from, toList]) => toList.map(to => ({ from, to, relation: 'depends_on' }))),
+    adjacency,
+    stats: {
+      total_scanned: allIds.length,
+      active: activeSkills.length,
+      archived: archivedSkills.length,
+      relocated: relocatedSkills.length,
+      has_cycles: hasCycles
+    }
+  };
+
+  // Build Registry Index YAML (Lightweight lookup)
+  const indexYamlContent = `# AUTO-GENERATED BY registry-builder (tooling/build-registry.js)\n# DO NOT EDIT MANUALLY. THIS IS A GENERATED RUNTIME ARTIFACT.\n` +
+    yaml.dump({
+      schema_version: 1,
+      manifest_version: '10.2',
+      generated_at: new Date().toISOString(),
+      stats: {
+        total_scanned: allIds.length,
+        active: activeSkills.length,
+        archived: archivedSkills.length,
+        relocated: relocatedSkills.length
+      },
+      capabilities
+    }, { indent: 2 });
+
+  fs.writeFileSync(INDEX_YAML, indexYamlContent, 'utf8');
+  fs.writeFileSync(GRAPH_JSON, JSON.stringify(graphJsonData, null, 2), 'utf8');
+
+  console.log(`✅ Generated lightweight registry index at .agents/registry/index.yaml (${allIds.length} scanned: ${activeSkills.length} active, ${archivedSkills.length} archived, ${relocatedSkills.length} relocated)`);
+  console.log(`✅ Generated O(1) adjacency graph at .agents/registry/graph.json (active: ${activeSkills.length}, has_cycles: ${hasCycles})`);
+}
+
+buildRegistry();

package/tooling/run-aar.js

@@ -1,143 +1,72 @@
 import fs from 'fs';
 import path from 'path';
-import YAML from 'js-yaml';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.resolve(__dirname, '..');
-const skillsDir = path.join(rootDir, '.agents/skills');
-const graphPath = path.join(rootDir, '.agents/registry/capability-graph.yml');
-const workflowsDir = path.join(rootDir, '.agents/workflows');
+const graphPath = path.join(rootDir, '.agents/registry/graph.json');
 const reportsDir = path.join(rootDir, '.agents/reports');
 
-if (!fs.existsSync(reportsDir)) {
-  fs.mkdirSync(reportsDir, { recursive: true });
-}
-
-function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) return null;
-  try {
-    return YAML.load(match[1]);
-  } catch (e) {
-    return null;
+/**
+ * Run After Action Review (AAR).
+ * Reads graph.json and generates health report.
+ */
+export async function runAar() {
+  if (!fs.existsSync(graphPath)) {
+    console.error('❌ graph.json not found. Run: node tooling/build-registry.js');
+    return;
   }
-}
-
-// 1. Skill Audit
-function runSkillAudit() {
-  const dirs = fs.readdirSync(skillsDir).filter(name => !name.startsWith('_') && fs.statSync(path.join(skillsDir, name)).isDirectory());
-  
-  let report = `# Skill Audit Report\n\n`;
-  let valid = 0;
-
-  dirs.forEach(skill => {
-    const skillPath = path.join(skillsDir, skill, 'SKILL.md');
-    if (!fs.existsSync(skillPath)) return;
-    
-    const content = fs.readFileSync(skillPath, 'utf8');
-    const data = parseFrontmatter(content);
-    if (!data) return;
-
-    // Check boundary
-    const bounds = data.decision_boundary || {};
-    const hasOwns = bounds.owns && bounds.owns.length > 0;
-    const hasNotOwn = bounds.does_not_own && bounds.does_not_own.length > 0;
-    const hasConflicts = bounds.conflicts_with !== undefined; // can be empty array
-    const hasDelegates = bounds.delegates_to !== undefined; // optional
-    
-    let score = 0;
-    if (hasOwns) score += 30;
-    if (hasNotOwn) score += 30;
-    if (hasConflicts) score += 20;
-    if (hasDelegates) score += 20; // bonus if exists or architecture skill
-    if (!hasDelegates && !skill.includes('architecture') && !skill.includes('orchestrator')) {
-        score += 20; // It's fine if implementation skill doesn't delegate
-    }
-
-    report += `## ${skill}\n`;
-    report += `- \`owns\`: ${hasOwns ? '✅' : '❌'}\n`;
-    report += `- \`does_not_own\`: ${hasNotOwn ? '✅' : '❌'}\n`;
-    report += `- \`conflicts_with\`: ${hasConflicts ? '✅' : '❌'}\n`;
-    report += `- \`delegates_to\`: ${hasDelegates ? '✅' : (skill.includes('architecture') ? '❌ (Architecture should delegate)' : '➖ (Optional)')}\n`;
-    report += `**Boundary Health Score: ${score}/100**\n\n`;
-    
-    if (score >= 80) valid++;
-  });
-
-  report += `\n**Total Scanned:** ${dirs.length}\n`;
-  report += `**Total Passed (>=80):** ${valid}\n`;
-
-  fs.writeFileSync(path.join(reportsDir, 'skill-audit.md'), report);
-  console.log('✅ Skill audit complete.');
-}
 
-// 2. Graph Audit
-function runGraphAudit() {
-  if (!fs.existsSync(graphPath)) return;
-  const graph = YAML.load(fs.readFileSync(graphPath, 'utf8'));
-  
-  let report = `# Graph Health Report\n\n`;
-  const incoming = {};
-  const outgoing = {};
-  const conflicts = [];
-  
-  Object.keys(graph.nodes).forEach(n => {
-    incoming[n] = 0;
-    outgoing[n] = 0;
-  });
-
-  graph.edges.forEach(e => {
-    if (outgoing[e.from] !== undefined) outgoing[e.from]++;
-    if (incoming[e.to] !== undefined) incoming[e.to]++;
-    
-    if (e.relation === 'conflicts_with') {
-      conflicts.push(`- **${e.from}** conflicts **${e.to}**\n  - Reason: Semantic overlap\n  - Severity: High\n  - Resolution: Context loader intervention required`);
-    }
-  });
+  if (!fs.existsSync(reportsDir)) {
+    fs.mkdirSync(reportsDir, { recursive: true });
+  }
 
-  report += `## Hub Risk Analysis\n`;
-  const MAX_OUT = 12;
-  const MAX_IN = 15;
-  const ALLOWED_HUBS = ['qk-orchestrator', 'qk-context-loader'];
+  const graph = JSON.parse(fs.readFileSync(graphPath, 'utf8'));
+  const nodes = Object.keys(graph.nodes || {});
+  const edges = graph.edges || [];
+  const adjacency = graph.adjacency || {};
+
+  let report = '# After Action Review (AAR)\n\n';
+  report += `**Generated:** ${new Date().toISOString()}\n\n`;
+
+  // Node health
+  report += '## Node Health\n\n';
+  report += '| Node | Version | Platforms | Dependencies |\n';
+  report += '|------|---------|-----------|-------------|\n';
+  for (const [id, node] of Object.entries(graph.nodes || {})) {
+    const deps = (node.dependencies || []).join(', ') || '—';
+    report += `| ${id} | ${node.version || '—'} | ${(node.platforms || []).join(', ') || '—'} | ${deps} |\n`;
+  }
 
-  Object.keys(outgoing).forEach(id => {
-    const outCount = outgoing[id];
-    const inCount = incoming[id];
-    let risk = 'Low';
-    if (outCount > MAX_OUT || inCount > MAX_IN) {
-      if (ALLOWED_HUBS.includes(id)) {
-        risk = 'Allowed Exception';
-      } else {
-        risk = 'High Risk Hub';
-      }
-    }
-    if (risk !== 'Low') {
-      report += `- **${id}**: Incoming(${inCount}), Outgoing(${outCount}) -> [${risk}]\n`;
+  // Edge summary
+  report += '\n## Edge Summary\n\n';
+  report += `- Total edges: ${edges.length}\n`;
+  report += `- Total nodes: ${nodes.length}\n`;
+  report += `- Orphans: ${graph.orphan_count || 0}\n`;
+  report += `- Has cycles: ${graph.has_cycles || false}\n`;
+
+  // Platform coverage
+  report += '\n## Platform Coverage\n\n';
+  const platformCounts = { antigravity: 0, claude: 0, opencode: 0 };
+  for (const node of Object.values(graph.nodes || {})) {
+    for (const p of node.platforms || []) {
+      if (platformCounts[p] !== undefined) platformCounts[p]++;
     }
-  });
-
-  report += `\n## Conflict Matrix\n`;
-  conflicts.forEach(c => {
-    report += `${c}\n\n`;
-  });
+  }
+  for (const [platform, count] of Object.entries(platformCounts)) {
+    report += `- ${platform}: ${count}/${nodes.length} skills\n`;
+  }
 
-  fs.writeFileSync(path.join(reportsDir, 'graph-health.md'), report);
-  console.log('✅ Graph audit complete.');
-}
+  // Version compliance
+  report += '\n## Version Compliance\n\n';
+  let compliant = 0;
+  for (const [id, node] of Object.entries(graph.nodes || {})) {
+    if (node.version === '10.2.0') compliant++;
+  }
+  report += `- Version 10.2.0: ${compliant}/${nodes.length}\n`;
 
-// 3. Workflow Audit
-function runWorkflowAudit() {
-  const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith('.md') || f.endsWith('.yml'));
-  let report = `# Architecture & Workflow Audit\n\n`;
-  report += `## Workflows Found: ${workflows.length}\n`;
-  workflows.forEach(w => {
-    report += `- ${w}\n`;
-  });
-  fs.writeFileSync(path.join(reportsDir, 'architecture-audit.md'), report);
-  console.log('✅ Workflow audit complete.');
+  fs.writeFileSync(path.join(reportsDir, 'aar-report.md'), report);
+  console.log('✅ AAR report generated.');
 }
 
-runSkillAudit();
-runGraphAudit();
-runWorkflowAudit();
+export default { runAar };

package/tooling/sync-versions.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 
-const targetVersion = "9.1.0";
+const targetVersion = "10.2.0";
 const rootDir = process.cwd();
 const skillsDir = path.join(rootDir, '.agents', 'skills');
 
@@ -253,7 +253,7 @@ skills.forEach(skill => {
   if (fs.existsSync(skillMdPath)) {
     let content = fs.readFileSync(skillMdPath, 'utf8');
     let newContent = content.replace(/^version:\s*["']?[\d.]+["']?/m, `version: ${targetVersion}`);
-    newContent = newContent.replace(/^# ── V[\d]+: Classification/m, `# ── V9: Classification`);
+    newContent = newContent.replace(/^# ── V[\d]+: Classification/m, `# ── V10: Classification`);
     
     // Inject or update Memory Workflow (except qk-project-memory which manages memory itself)
     if (skill !== 'qk-project-memory' && skill !== 'qk-help') {