bmad-module-skill-forge 0.9.0 → 0.10.1-alpha.0

package/tools/cli/lib/ui.js

@@ -17,6 +17,7 @@ const fs = require('fs-extra');
 const yaml = require('js-yaml');
 const { readManifest } = require('./manifest');
 const { compareVersions } = require('./version-check');
+const { getAvailablePlatforms, getDetectionMarkers } = require('./ide-skills');
 
 const SKF_FOLDER = '_bmad/skf';
 
@@ -42,30 +43,44 @@ class UI {
       logoLines = ['  S K F'];
     }
 
-    const w = 54;
+    const w = 72;
     const frame = brand.dark;
     const top = frame('  ╔' + '═'.repeat(w) + '╗');
     const mid = frame('  ╟' + '─'.repeat(w) + '╢');
     const bottom = frame('  ╚' + '═'.repeat(w) + '╝');
+    const rule = frame('  ' + '━'.repeat(w));
     const row = (content) => {
       // eslint-disable-next-line no-control-regex -- stripping ANSI escape codes for visual width calculation
       const stripped = content.replaceAll(/\u001B\[\d+(?:;\d+)*m/g, '');
       const pad = Math.max(0, w - stripped.length - 2);
       return frame('  ║ ') + content + ' '.repeat(pad) + frame(' ║');
     };
+    const empty = row('');
+    const indent = '  ';
 
     console.log();
     console.log(top);
+    console.log(empty);
     for (const line of logoLines) {
-      console.log(row(brand.amber.bold(line.replace(/\s+$/, ''))));
+      console.log(row(indent + brand.amber.bold(line.replace(/\s+$/, ''))));
     }
+    console.log(empty);
     console.log(mid);
-    console.log(row(chalk.white.bold('Skill Forge') + chalk.dim(` v${version}`)));
-    console.log(row(chalk.dim('Agent Skill Compiler') + ' '.repeat(15) + brand.spark('⚒')));
-    console.log(mid);
-    console.log(row(chalk.dim('Code · Docs · Discourse → Verified agent skills')));
+    console.log(row(indent + chalk.white.bold('Skill Forge') + '  ' + brand.spark('⚒') + '  ' + chalk.dim('Agent Skill Compiler')));
+    console.log(row(indent + chalk.dim('Turn code and docs into instructions AI agents can actually follow.')));
+    console.log(row(indent + chalk.dim(`v${version}  ·  MIT License  ·  Open Source`)));
     console.log(bottom);
     console.log();
+    console.log(rule);
+    console.log();
+    const resource = (label, url) => '  ' + chalk.dim(label.padEnd(10)) + brand.amber(url);
+    console.log(resource('Docs', 'https://armelhbobdad.github.io/bmad-module-skill-forge'));
+    console.log(resource('GitHub', 'https://github.com/armelhbobdad/bmad-module-skill-forge'));
+    console.log(resource('Discord', 'https://discord.gg/gk8jAdXWmj'));
+    console.log(resource('Support', 'https://buymeacoffee.com/armelhbobdad'));
+    console.log();
+    console.log(rule);
+    console.log();
 
     intro(brand.amber('Skill Forge Installer'));
   }
@@ -133,7 +148,7 @@ class UI {
       }
       action = choice;
     } else {
-      log.info(`Agents and workflows will be installed in ${chalk.white(skfFolder + '/')}`);
+      log.info(`Skills will be installed in ${chalk.white(skfFolder + '/')}`);
     }
 
     if (action === 'update') {
@@ -153,16 +168,12 @@ class UI {
       log.info('Previous configuration detected — defaults pre-populated.');
     }
 
-    const ideOptions = [
-      { label: 'Claude Code', value: 'claude-code' },
-      { label: 'Cline', value: 'cline' },
-      { label: 'Codex', value: 'codex' },
-      { label: 'Cursor', value: 'cursor' },
-      { label: 'GitHub Copilot', value: 'github-copilot' },
-      { label: 'Roo Code', value: 'roo' },
-      { label: 'Windsurf', value: 'windsurf' },
-      { label: 'Other', value: 'other' },
-    ];
+    // Build IDE options from platform-codes.yaml
+    const platforms = getAvailablePlatforms();
+    const ideOptions = platforms.map((p) => ({
+      label: p.preferred ? `${p.label} (Recommended)` : p.label,
+      value: p.value,
+    }));
 
     // Pre-check IDEs: saved config takes priority, then auto-detect from directories
     const savedIdes = savedConfig?.ides || [];
@@ -249,16 +260,7 @@ class UI {
   }
 
   async detectIdes(projectDir) {
-    const markers = {
-      'claude-code': ['.claude'],
-      cursor: ['.cursor'],
-      cline: ['.clinerules'],
-      codex: ['.codex'],
-      'github-copilot': ['.github/copilot-instructions.md', '.github/prompts'],
-      roo: ['.roo', '.roomodes'],
-      windsurf: ['.windsurf'],
-    };
-
+    const markers = getDetectionMarkers();
     const detected = [];
     for (const [ide, paths] of Object.entries(markers)) {
       for (const p of paths) {
@@ -285,31 +287,58 @@ class UI {
   }
 
   displaySuccess(skfFolder, ides = [], action = 'fresh') {
-    const ideNames = {
-      'claude-code': 'Claude Code',
-      cline: 'Cline',
-      codex: 'Codex',
-      cursor: 'Cursor',
-      'github-copilot': 'GitHub Copilot',
-      roo: 'Roo Code',
-      windsurf: 'Windsurf',
-      other: 'your IDE',
-    };
+    // Build per-platform lookup tables from platform-codes.yaml
+    const ideNames = {};
+    const idePrefixes = {};
+    for (const p of getAvailablePlatforms()) {
+      ideNames[p.value] = p.label;
+      idePrefixes[p.value] = p.skillInvocationPrefix; // null = auto-invoke only
+    }
+
+    const selectedIdes = Array.isArray(ides) && ides.length > 0 ? ides : [];
 
     let ideDisplay;
-    if (!ides || ides.length === 0) {
+    if (selectedIdes.length === 0) {
       ideDisplay = 'your IDE';
-    } else if (ides.length === 1) {
-      ideDisplay = ideNames[ides[0]] || 'your IDE';
+    } else if (selectedIdes.length === 1) {
+      ideDisplay = ideNames[selectedIdes[0]] || 'your IDE';
+    } else {
+      ideDisplay = selectedIdes.map((ide) => ideNames[ide] || ide).join(' or ');
+    }
+
+    // Build per-IDE invocation hints. Skills with a prefix get a literal
+    // command; auto-invoke IDEs get a chat-based instruction.
+    const invocations = selectedIdes.map((ide) => {
+      const name = ideNames[ide] || ide;
+      const prefix = idePrefixes[ide];
+      if (prefix) {
+        return { ide: name, command: `${prefix}skf-forger`, auto: false };
+      }
+      return { ide: name, command: null, auto: true };
+    });
+
+    // Compose the activate line shown in steps and outro.
+    let activateLine;
+    if (invocations.length === 0) {
+      // Update flow with no IDE list — show both common forms
+      activateLine = `${brand.gold('/skf-forger')} ${chalk.dim('(Claude Code)')}  ${chalk.dim('·')}  ${brand.gold('$skf-forger')} ${chalk.dim('(Codex)')}`;
+    } else if (invocations.length === 1) {
+      const inv = invocations[0];
+      activateLine = inv.auto ? chalk.dim(`${inv.ide} auto-loads skf-forger`) : brand.gold(inv.command);
     } else {
-      ideDisplay = ides.map((ide) => ideNames[ide] || ide).join(' or ');
+      // Mixed: show one segment per IDE
+      activateLine = invocations
+        .map((inv) =>
+          inv.auto
+            ? `${chalk.dim('auto')} ${chalk.dim('(' + inv.ide + ')')}`
+            : `${brand.gold(inv.command)} ${chalk.dim('(' + inv.ide + ')')}`,
+        )
+        .join('  ');
     }
 
     let noteTitle;
     let noteBody;
 
-    const activateCmd = brand.gold('/bmad-agent-skf-forger');
-
     if (action === 'update') {
       noteTitle = brand.amber.bold('Update complete!');
       noteBody = [
@@ -318,15 +347,15 @@ class UI {
         'Your config.yaml and sidecar state are preserved.',
         '',
         `${chalk.white.bold('Next Steps')}`,
-        `1. Reload the agent in ${ideDisplay}:  ${activateCmd}`,
-        '2. Run @Ferris SF to re-detect tools if needed',
+        `1. Reload the agent in ${ideDisplay}:  ${activateLine}`,
+        `2. Then ask Ferris to ${chalk.white('"setup the forge"')} to re-detect tools`,
       ].join('\n');
     } else {
       noteTitle = brand.amber.bold('Installation complete!');
       noteBody = [
         `${chalk.white.bold('Get Started')}`,
         `1. Open this folder in ${ideDisplay}`,
-        `2. Activate Ferris:  ${activateCmd}`,
+        `2. Activate Ferris:  ${activateLine}`,
         '3. Ferris (your Skill Architect) will guide you through',
         '   setting up and forging your first agent skill',
       ].join('\n');
@@ -335,7 +364,7 @@ class UI {
     note(noteBody, noteTitle);
 
     outro(
-      `${brand.spark('⚒')}  Agent: ${chalk.white('Ferris')} ${chalk.dim('(Skill Architect & Integrity Guardian)')}\n${brand.dark('⚡')} Docs: ${brand.amber('https://armelhbobdad.github.io/bmad-module-skill-forge')}`,
+      `${brand.spark('⚒')}  Agent: ${chalk.white('Ferris')} ${chalk.dim('(Skill Architect & Integrity Guardian)')}\n${brand.dark('⚡')} Docs: ${brand.amber('https://armelhbobdad.github.io/bmad-module-skill-forge')}\n${brand.gold('▶')}  Call the forger:  ${activateLine}`,
     );
   }
 }

package/tools/validate-docs-drift.js

@@ -0,0 +1,193 @@
+/**
+ * Documentation Drift Validator
+ *
+ * Verifies that SKF docs agree with the canonical oh-my-skills output on
+ * every version number, commit SHA, and library reference the docs cite.
+ *
+ * What it checks:
+ * - Every skill listed in `docs/_data/pinned.yaml` actually exists at the
+ *   claimed version and commit in $OMS/skills/<name>/<version>/<name>/metadata.json
+ * - The metadata.json `version` field matches the anchor `version`
+ * - The metadata.json `source_commit` field matches the anchor `source_commit`
+ * - Every `.md` file under `docs/` is grepped for `<library> v?<x.y.z>` strings;
+ *   any that don't match the currently-pinned version for that library are flagged
+ * - Known illustrative libraries (hono, drizzle-orm, ...) are whitelisted and
+ *   allowed to carry any version number
+ *
+ * Usage:
+ *   node tools/validate-docs-drift.js             # validate, exit 1 on drift
+ *   OMS=/path/to/oh-my-skills node tools/validate-docs-drift.js
+ *
+ * Exit codes:
+ *   0 — no drift detected
+ *   1 — drift found; fix the docs or update docs/_data/pinned.yaml
+ *   2 — infrastructure failure (anchors file missing, oh-my-skills path
+ *       unreachable, yaml parse error)
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('js-yaml');
+
+const SKF_ROOT = path.resolve(__dirname, '..');
+const DOCS_DIR = path.join(SKF_ROOT, 'docs');
+const ANCHORS_PATH = path.join(DOCS_DIR, '_data', 'pinned.yaml');
+
+function loadAnchors() {
+  if (!fs.existsSync(ANCHORS_PATH)) {
+    console.error(`error: anchors file not found at ${ANCHORS_PATH}`);
+    process.exit(2);
+  }
+  try {
+    return yaml.load(fs.readFileSync(ANCHORS_PATH, 'utf8'));
+  } catch (error) {
+    console.error(`error: could not parse ${ANCHORS_PATH}: ${error.message}`);
+    process.exit(2);
+  }
+}
+
+function resolveOmsPath(anchors) {
+  if (process.env.OMS) {
+    return path.resolve(process.env.OMS);
+  }
+  return path.resolve(SKF_ROOT, anchors.oh_my_skills_path);
+}
+
+// Accept either a full SHA match or a short-SHA prefix match, per
+// src/skf-update-skill/steps-c/step-03-re-extract.md:36 — the pinned commit
+// is often stored as an 8-char short hash. Both anchors and metadata are
+// lowercased before comparison; blank / null values never match.
+function commitsMatch(anchorCommit, metadataCommit) {
+  if (!anchorCommit || !metadataCommit) return false;
+  const a = String(anchorCommit).toLowerCase();
+  const b = String(metadataCommit).toLowerCase();
+  return a === b || a.startsWith(b) || b.startsWith(a);
+}
+
+function checkCanonicalFiles(anchors, omsPath) {
+  const errors = [];
+  if (!fs.existsSync(omsPath) || !fs.statSync(omsPath).isDirectory()) {
+    errors.push(
+      `CRITICAL: oh_my_skills_path does not resolve to a directory: ${omsPath}`,
+      `  hint: set OMS=/path/to/oh-my-skills or edit docs/_data/pinned.yaml`,
+    );
+    return errors;
+  }
+
+  for (const [skillName, spec] of Object.entries(anchors.skills)) {
+    const metadataPath = path.join(omsPath, 'skills', skillName, spec.version, skillName, 'metadata.json');
+
+    if (!fs.existsSync(metadataPath)) {
+      errors.push(`MISSING: ${skillName}@${spec.version} — expected ${metadataPath}`);
+      continue;
+    }
+
+    let metadata;
+    try {
+      metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    } catch (error) {
+      errors.push(`UNPARSEABLE: ${metadataPath} — ${error.message}`);
+      continue;
+    }
+
+    if (metadata.version !== spec.version) {
+      errors.push(`VERSION_DRIFT: ${skillName} — anchors say ${spec.version}, ` + `metadata.json says ${metadata.version}`);
+    }
+
+    if (!commitsMatch(spec.source_commit, metadata.source_commit)) {
+      const anchorShort = (spec.source_commit || '').slice(0, 12);
+      const realShort = (metadata.source_commit || '').slice(0, 12);
+      errors.push(`COMMIT_DRIFT: ${skillName} — anchors say ${anchorShort}, ` + `metadata.json says ${realShort}`);
+    }
+
+    if (metadata.confidence_tier !== spec.confidence_tier) {
+      errors.push(`TIER_DRIFT: ${skillName} — anchors say ${spec.confidence_tier}, ` + `metadata.json says ${metadata.confidence_tier}`);
+    }
+
+    if (metadata.source_authority !== spec.source_authority) {
+      errors.push(
+        `AUTHORITY_DRIFT: ${skillName} — anchors say ${spec.source_authority}, ` + `metadata.json says ${metadata.source_authority}`,
+      );
+    }
+  }
+
+  return errors;
+}
+
+function getMarkdownFiles(dir) {
+  const files = [];
+  function walk(currentDir) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('_')) continue;
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        files.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return files;
+}
+
+function checkDocsForStaleVersions(anchors) {
+  const errors = [];
+
+  // Build map: library-name → current-version
+  const libVersions = Object.fromEntries(Object.values(anchors.skills).map((spec) => [spec.library, spec.version]));
+  const libs = Object.keys(libVersions);
+  if (libs.length === 0) return errors;
+
+  const illustrative = new Set(anchors.illustrative_libraries || []);
+
+  // Pattern: <library-name><whitespace or @>v?<semver>
+  // Word-boundary anchored to avoid partial matches inside other words.
+  const libPattern = String.raw`\b(` + libs.map((l) => l.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`)).join('|') + ')';
+  const versionPattern = String.raw`[\s@]+v?(\d+\.\d+\.\d+)`;
+  const regex = new RegExp(libPattern + versionPattern, 'gi');
+
+  for (const mdFile of getMarkdownFiles(DOCS_DIR)) {
+    const content = fs.readFileSync(mdFile, 'utf8');
+    const lines = content.split('\n');
+    for (const [idx, line] of lines.entries()) {
+      for (const match of line.matchAll(regex)) {
+        const lib = match[1].toLowerCase();
+        if (illustrative.has(lib)) continue;
+        const found = match[2];
+        const expected = libVersions[lib];
+        if (expected && found !== expected) {
+          const relPath = path.relative(SKF_ROOT, mdFile);
+          errors.push(`STALE_VERSION: ${relPath}:${idx + 1} — ${lib} v${found} (expected v${expected})`);
+        }
+      }
+    }
+  }
+
+  return errors;
+}
+
+function main() {
+  const anchors = loadAnchors();
+  const omsPath = resolveOmsPath(anchors);
+
+  const errors = [...checkCanonicalFiles(anchors, omsPath), ...checkDocsForStaleVersions(anchors)];
+
+  if (errors.length > 0) {
+    console.error('DRIFT DETECTED:\n');
+    for (const err of errors) {
+      console.error(`  - ${err}`);
+    }
+    console.error(`\n${errors.length} drift finding(s). Fix the docs or update docs/_data/pinned.yaml.`);
+    console.error('\nAnchors file: docs/_data/pinned.yaml');
+    console.error(`Checked against: ${omsPath}`);
+    process.exit(1);
+  }
+
+  const skillCount = Object.keys(anchors.skills).length;
+  console.log(`OK: ${skillCount} skills checked against ${omsPath}, no drift.`);
+  process.exit(0);
+}
+
+main();

package/src/agents/forger.agent.yaml

@@ -1,114 +0,0 @@
-agent:
-  webskip: true
-  metadata:
-    id: "_bmad/skf/agents/forger.md"
-    name: Ferris
-    title: Skill Architect & Integrity Guardian
-    icon: "⚒️"
-    module: skf
-    hasSidecar: true
-    sidecar-folder: forger-sidecar
-    sidecar-path: "{project-root}/_bmad/_memory/forger-sidecar"
-
-  persona:
-    role: |
-      Skill compilation specialist who transforms code repositories, documentation, and developer discourse into verified agent skills.
-      Manages the full lifecycle: source analysis, skill briefing, AST-backed compilation,
-      integrity testing, and ecosystem-ready export across progressive capability tiers
-      (Quick/Forge/Forge+/Deep).
-
-    identity: |
-      The forge master — a precision-focused craftsman who works through four modes:
-      Architect (exploratory, assembling), Surgeon (precise, preserving), Audit
-      (judgmental, scoring), and Delivery (packaging, ecosystem-ready). Modes are
-      workflow-bound, not conversation-bound. Takes quiet pride in verified work and
-      treats every claim as something that must be proven.
-
-    communication_style: |
-      Structured reports with inline AST citations during work — no metaphor, no
-      commentary. At transitions, uses forge language: brief, warm, orienting. On
-      completion, quiet craftsman's pride. On errors, direct and actionable with no
-      hedging. Acknowledges loaded sidecar state naturally: current forge tier,
-      active preferences, and any prior session context.
-
-    principles:
-      - "Channel expert source code analysis wisdom: draw upon deep knowledge of AST patterns, function signatures, type systems, and what separates verified skill definitions from hallucinated ones"
-      - "Zero hallucination tolerance — every instruction traces to code; if it can't be cited, it doesn't exist"
-      - "Structural truth over semantic guessing — AST first, always; never infer what can be parsed"
-      - "Provenance is non-negotiable — every claim has a source, line number, and confidence tier"
-      - "Meet developers where they are — progressive capability means Quick is legitimate, not lesser"
-      - "Tools are backstage, the craft is center stage — users see results, not tool invocations"
-      - "Agent-level knowledge informs judgment across workflows — consult knowledge/ when a step directs, not from memory"
-
-  critical_actions:
-    - "GUARD: Verify {sidecar_path} resolves to an actual directory path (not a literal '{sidecar_path}' string). If it does not resolve — HARD HALT: '**Cannot initialize.** `sidecar_path` is not defined in your installed config.yaml. Add `sidecar_path: _bmad/_memory/forger-sidecar` to your project config.yaml and retry. This is a known installer issue with `prompt: false` config variables.'"
-    - "Load COMPLETE file {sidecar_path}/preferences.yaml"
-    - "Load COMPLETE file {sidecar_path}/forge-tier.yaml"
-    - "ONLY write STATE files to {project-root}/_bmad/_memory/forger-sidecar/ — reading from knowledge/ and workflow files is expected"
-    - "When a workflow step directs knowledge consultation, consult {project-root}/_bmad/skf/knowledge/skf-knowledge-index.csv to select the relevant fragment(s) and load only those files"
-    - "Load the referenced fragment(s) from {project-root}/_bmad/skf/ using the path in the fragment_file column (e.g., knowledge/overview.md resolves to {project-root}/_bmad/skf/knowledge/overview.md) before giving recommendations on the topic the step directed"
-
-  menu:
-    - trigger: SF or fuzzy match on setup-forge
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/setup-forge/workflow.md"
-      description: "[SF] Setup Forge — initialize environment, detect tools, set tier"
-
-    - trigger: AN or fuzzy match on analyze-source
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/analyze-source/workflow.md"
-      description: "[AN] Analyze Source — discover what to skill, recommend stack skill"
-
-    - trigger: BS or fuzzy match on brief-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/brief-skill/workflow.md"
-      description: "[BS] Brief Skill — design a skill scope through guided discovery"
-
-    - trigger: CS or fuzzy match on create-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/create-skill/workflow.md"
-      description: "[CS] Create Skill — compile a skill from brief"
-
-    - trigger: QS or fuzzy match on quick-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/quick-skill/workflow.md"
-      description: "[QS] Quick Skill — fast skill, no brief needed"
-
-    - trigger: SS or fuzzy match on create-stack-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/create-stack-skill/workflow.md"
-      description: "[SS] Stack Skill — consolidated project stack skill"
-
-    - trigger: US or fuzzy match on update-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/update-skill/workflow.md"
-      description: "[US] Update Skill — regenerate after changes, preserves [MANUAL]"
-
-    - trigger: AS or fuzzy match on audit-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/audit-skill/workflow.md"
-      description: "[AS] Audit Skill — check for drift"
-
-    - trigger: VS or fuzzy match on verify-stack
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/verify-stack/workflow.md"
-      description: "[VS] Verify Stack — validate tech stack feasibility against architecture and PRD"
-
-    - trigger: RA or fuzzy match on refine-architecture
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/refine-architecture/workflow.md"
-      description: "[RA] Refine Architecture — improve architecture doc using verified skill data"
-
-    - trigger: TS or fuzzy match on test-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/test-skill/workflow.md"
-      description: "[TS] Test Skill — verify completeness"
-
-    - trigger: EX or fuzzy match on export-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/export-skill/workflow.md"
-      description: "[EX] Export Skill — package for distribution"
-
-    - trigger: RS or fuzzy match on rename-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/rename-skill/workflow.md"
-      description: "[RS] Rename Skill — rename a skill across all its versions (transactional)"
-
-    - trigger: DS or fuzzy match on drop-skill
-      workflow: "{project-root}/_bmad/skf/workflows/skillforge/drop-skill/workflow.md"
-      description: "[DS] Drop Skill — deprecate (soft) or purge (hard) skill versions"
-
-    - trigger: KI or fuzzy match on knowledge-index
-      action: "Load and display {project-root}/_bmad/skf/knowledge/skf-knowledge-index.csv — cross-cutting knowledge fragments available for JiT loading"
-      description: "[KI] Knowledge Index — list available knowledge fragments"
-
-    - trigger: WS or fuzzy match on workflow-status
-      action: "Show current lifecycle position, active skill briefs, and forge tier status"
-      description: "[WS] Workflow Status — show current lifecycle position"