@entelligentsia/forgecli 0.10.1 → 0.11.2

package/dist/forge-payload/tools/check-structure.cjs

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+'use strict';
+
+// Forge tool: check-structure
+// Checks that all files listed in structure-manifest.json are present
+// in a project's generated output.
+// Usage: node check-structure.cjs [--strict] [--path <project-root>] [--validate-manifest] [--forge-root <path>]
+//   --path <project-root>  Directory to check against (default: process.cwd())
+//   --strict               Also report files present but NOT in the manifest (extra files)
+//   --validate-manifest    Validate manifest against base-pack source files
+//   --forge-root <path>    Path to the forge/ plugin directory (required with --validate-manifest)
+//
+// Reads .forge/config.json paths.* for directory overrides.
+// Falls back to manifest dir field if config is absent or unparseable.
+//
+// Exit 0: all expected files present (or only extras found without --strict)
+// Exit 1: any missing files detected; also exit 1 if extras found with --strict
+
+const fs = require('fs');
+const path = require('path');
+const { getCommandsSubdir } = require('./lib/paths.cjs');
+
+// ── Per-namespace verification logic ──────────────────────────────────────────
+//
+// Returns { present, missing, extra, total } without calling process.exit.
+// - present: number of expected files found
+// - missing: array of { nsKey, dir, filename }
+// - extra:   array of { nsKey, dir, filename } (populated only when strict=true)
+// - total:   total number of expected files across all namespaces
+
+function checkNamespaces(manifest, projectRoot, options = {}) {
+  const { strict = false, configPaths = null } = options;
+
+  // Resolve config path overrides
+  let resolvedConfigPaths;
+  let projectPrefix = '';
+  if (configPaths !== null) {
+    resolvedConfigPaths = configPaths;
+  } else {
+    resolvedConfigPaths = {};
+    const configFile = path.join(projectRoot, '.forge', 'config.json');
+    if (fs.existsSync(configFile)) {
+      try {
+        const cfg = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        resolvedConfigPaths = (cfg && cfg.paths) ? cfg.paths : {};
+        projectPrefix = (cfg && cfg.project && cfg.project.prefix)
+          ? getCommandsSubdir(cfg.project.prefix)
+          : '';
+      } catch {
+        // unparseable — use defaults
+      }
+    }
+  }
+
+  let totalPresent = 0;
+  let totalExpected = 0;
+  const allMissing = [];
+  const allExtra = [];
+
+  for (const [nsKey, ns] of Object.entries(manifest.namespaces)) {
+    const logicalKey = ns.logicalKey || nsKey;
+    let resolvedDir = (resolvedConfigPaths[logicalKey] && typeof resolvedConfigPaths[logicalKey] === 'string')
+      ? resolvedConfigPaths[logicalKey]
+      : ns.dir;
+    if (ns.prefixed && projectPrefix) {
+      resolvedDir = resolvedDir + '/' + projectPrefix;
+    }
+    const absDir = path.join(projectRoot, resolvedDir);
+
+    const expected = ns.files || [];
+    totalExpected += expected.length;
+
+    const present = [];
+    const missing = [];
+    for (const filename of expected) {
+      const fullPath = path.join(absDir, filename);
+      if (fs.existsSync(fullPath)) {
+        present.push(filename);
+      } else {
+        missing.push({ nsKey, dir: resolvedDir, filename });
+      }
+    }
+
+    totalPresent += present.length;
+    allMissing.push(...missing);
+
+    if (strict) {
+      if (fs.existsSync(absDir)) {
+        try {
+          const expectedSet = new Set(expected);
+          const found = fs.readdirSync(absDir);
+          for (const f of found) {
+            if (!expectedSet.has(f)) {
+              allExtra.push({ nsKey, dir: resolvedDir, filename: f });
+            }
+          }
+        } catch {}
+      }
+    }
+  }
+
+  return {
+    present: totalPresent,
+    missing: allMissing,
+    extra: allExtra,
+    total: totalExpected,
+  };
+}
+
+// ── Manifest validation against base-pack ──────────────────────────────────────
+//
+// Convention-based reverse mapping: each manifest namespace's dir field maps
+// to a base-pack source directory. For schemas, the source is forgeRoot/schemas/.
+// This function validates that every file in the manifest has a corresponding
+// base-pack source, and vice versa.
+//
+// Returns { manifestOnly, basePackOnly }
+
+function validateManifest(manifest, forgeRoot) {
+  const basePackDir = path.join(forgeRoot, 'init', 'base-pack');
+
+  // Convention-based reverse mapping from manifest dir to base-pack source dir
+  const nsToSourceDir = {
+    personas:  path.join(basePackDir, 'personas'),
+    skills:    path.join(basePackDir, 'skills'),
+    workflows: path.join(basePackDir, 'workflows'),
+    fragments: path.join(basePackDir, 'workflows', '_fragments'),
+    templates: path.join(basePackDir, 'templates'),
+    commands:  path.join(basePackDir, 'commands'),
+    // schemas: not base-pack-sourced — source is forgeRoot/schemas/
+  };
+
+  const manifestOnly = [];  // Files in manifest but not in base-pack
+  const basePackOnly = [];   // Files in base-pack but not in manifest
+
+  for (const [nsKey, ns] of Object.entries(manifest.namespaces)) {
+    // Skip schemas — they ship from forgeRoot/schemas/, not base-pack
+    if (nsKey === 'schemas') continue;
+
+    const sourceDir = nsToSourceDir[nsKey];
+    if (!sourceDir) continue;
+
+    const manifestFiles = new Set(ns.files || []);
+
+    // Read base-pack source directory
+    let basePackFiles = [];
+    try {
+      basePackFiles = fs.readdirSync(sourceDir).filter(f => {
+        // Only include regular files, skip subdirectories (like _fragments under workflows)
+        const stat = fs.statSync(path.join(sourceDir, f));
+        return stat.isFile();
+      });
+    } catch {
+      // Directory doesn't exist — all manifest files are manifestOnly
+      for (const f of manifestFiles) {
+        manifestOnly.push({ nsKey, filename: f, dir: ns.dir });
+      }
+      continue;
+    }
+
+    const basePackFileSet = new Set(basePackFiles);
+
+    // Files in manifest but not in base-pack
+    for (const f of manifestFiles) {
+      if (!basePackFileSet.has(f)) {
+        manifestOnly.push({ nsKey, filename: f, dir: ns.dir });
+      }
+    }
+
+    // Files in base-pack but not in manifest
+    for (const f of basePackFileSet) {
+      if (!manifestFiles.has(f)) {
+        basePackOnly.push({ nsKey, filename: f, dir: ns.dir });
+      }
+    }
+  }
+
+  return { manifestOnly, basePackOnly };
+}
+
+// ── Exports ────────────────────────────────────────────────────────────────────
+
+module.exports = { checkNamespaces, validateManifest };
+
+// ── CLI ────────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+try {
+  // ── Parse arguments ──────────────────────────────────────────────────────────
+
+  const argv = process.argv.slice(2);
+  let projectRoot = process.cwd();
+  let strict = false;
+  let validateManifestFlag = false;
+  let forgeRoot = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--path' && argv[i + 1]) {
+      projectRoot = path.resolve(argv[++i]);
+    } else if (argv[i] === '--strict') {
+      strict = true;
+    } else if (argv[i] === '--validate-manifest') {
+      validateManifestFlag = true;
+    } else if (argv[i] === '--forge-root' && argv[i + 1]) {
+      forgeRoot = path.resolve(argv[++i]);
+    }
+  }
+
+  // ── Load structure-manifest.json ─────────────────────────────────────────────
+
+  const manifestPath = forgeRoot
+    ? path.join(forgeRoot, 'schemas', 'structure-manifest.json')
+    : path.join(__dirname, '..', 'schemas', 'structure-manifest.json');
+  if (!fs.existsSync(manifestPath)) {
+    process.stderr.write(`× structure-manifest.json not found at ${manifestPath}\n`);
+    process.exit(1);
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (e) {
+    process.stderr.write(`× Failed to parse structure-manifest.json: ${e.message}\n`);
+    process.exit(1);
+  }
+
+  // ── Validate manifest against base-pack (if requested) ──────────────────────
+
+  if (validateManifestFlag) {
+    if (!forgeRoot) {
+      process.stderr.write('× --validate-manifest requires --forge-root <path>\n');
+      process.exit(1);
+    }
+
+    const { manifestOnly, basePackOnly } = validateManifest(manifest, forgeRoot);
+
+    if (manifestOnly.length > 0) {
+      process.stdout.write('× Files in manifest but absent from base-pack:\n');
+      for (const { nsKey, filename, dir } of manifestOnly) {
+        process.stdout.write(`    × ${dir}/${filename} (namespace: ${nsKey})\n`);
+      }
+    }
+
+    if (basePackOnly.length > 0) {
+      process.stdout.write('△ Files in base-pack but absent from manifest:\n');
+      for (const { nsKey, filename, dir } of basePackOnly) {
+        process.stdout.write(`    △ ${dir}/${filename} (namespace: ${nsKey})\n`);
+      }
+    }
+
+    if (manifestOnly.length === 0 && basePackOnly.length === 0) {
+      process.stdout.write('〇 Manifest and base-pack are in sync.\n');
+    }
+
+    if (manifestOnly.length > 0) {
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // ── Check namespaces ─────────────────────────────────────────────────────────
+
+  const result = checkNamespaces(manifest, projectRoot, { strict });
+
+  // ── Format output ────────────────────────────────────────────────────────────
+
+  // Group results by namespace for display
+  const byNs = {};
+  for (const m of result.missing) {
+    if (!byNs[m.nsKey]) byNs[m.nsKey] = { present: 0, missing: [], extra: [] };
+    byNs[m.nsKey].missing.push(m.filename);
+  }
+  for (const e of result.extra) {
+    if (!byNs[e.nsKey]) byNs[e.nsKey] = { present: 0, missing: [], extra: [] };
+    byNs[e.nsKey].extra.push(e.filename);
+  }
+
+  // Count present per namespace
+  for (const [nsKey, ns] of Object.entries(manifest.namespaces)) {
+    if (!byNs[nsKey]) byNs[nsKey] = { present: 0, missing: [], extra: [] };
+    const total = (ns.files || []).length;
+    const missingCount = byNs[nsKey].missing.length;
+    byNs[nsKey].present = total - missingCount;
+  }
+
+  const lines = [];
+  let anyMissing = result.missing.length > 0;
+  let anyExtra = result.extra.length > 0;
+
+  for (const [nsKey, ns] of Object.entries(manifest.namespaces)) {
+    const logicalKey = ns.logicalKey || nsKey;
+    const info = byNs[nsKey] || { present: 0, missing: [], extra: [] };
+    const total = (ns.files || []).length;
+    const dir = ns.dir;
+
+    if (info.missing.length === 0 && info.extra.length === 0) {
+      lines.push(`〇 ${dir}/ — ${info.present}/${total} present`);
+    } else {
+      if (info.missing.length > 0) {
+        lines.push(`× ${dir}/ — ${info.present}/${total} present, ${info.missing.length} missing:`);
+        for (const f of info.missing) {
+          lines.push(`    × ${f}`);
+        }
+      }
+      if (info.extra.length > 0) {
+        if (info.missing.length === 0) {
+          lines.push(`△ ${dir}/ — ${info.present}/${total} present, ${info.extra.length} extra:`);
+        }
+        for (const f of info.extra) {
+          lines.push(`    △ ${f} (not in manifest)`);
+        }
+      }
+    }
+  }
+
+  for (const line of lines) {
+    process.stdout.write(line + '\n');
+  }
+
+  if (!anyMissing && !anyExtra) {
+    process.stdout.write(`〇 Structure check: all ${result.total} expected files present.\n`);
+    process.exit(0);
+  }
+
+  const parts = [`${result.present} present`];
+  if (result.missing.length > 0) parts.push(`${result.missing.length} missing`);
+  if (strict && result.extra.length > 0) parts.push(`${result.extra.length} extra`);
+  process.stdout.write(`── Structure check: ${parts.join(', ')} (of ${result.total} expected)\n`);
+
+  if (anyMissing) {
+    process.exit(1);
+  }
+  // Extra-only without --strict → exit 0 already handled above
+  // Extra-only with --strict
+  if (strict && anyExtra) {
+    process.exit(1);
+  }
+  process.exit(0);
+
+} catch (err) {
+  process.stderr.write(`× check-structure fatal: ${err.message}\n${err.stack}\n`);
+  process.exit(1);
+}
+} // end if (require.main === module)

package/dist/forge-payload/tools/list-skills.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// Forge skill query helper
+//
+// Usage:
+//   node list-skills.js                  — print all available skill names (one per line)
+//   node list-skills.js <skill-name>     — exit 0 if available, exit 1 if not
+//
+// Sources checked:
+//   ~/.claude/plugins/installed_plugins.json  — marketplace plugins
+//     scope "user"  → always available
+//     scope "local" → only if projectPath matches cwd
+//   ~/.claude/skills/                          — personal skills (subdirs with SKILL.md)
+//
+// Uses only Node.js built-ins — no npm dependencies required.
+// Works on Linux, macOS, and Windows wherever Claude Code runs.
+
+'use strict';
+
+// On unexpected failure, exit 0 so hook callers degrade gracefully
+// (assume skill absent / no output) rather than propagating an error.
+process.on('uncaughtException', () => process.exit(0));
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const pluginsFile = process.env.CLAUDE_PLUGIN_DATA_ROOT
+  ? path.join(process.env.CLAUDE_PLUGIN_DATA_ROOT, 'installed_plugins.json')
+  : path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+
+const personalSkillsDir = process.env.CLAUDE_SKILLS_DIR
+  || path.join(os.homedir(), '.claude', 'skills');
+
+const cwd = process.cwd();
+const skills = new Set();
+
+// Source 1: marketplace plugins from installed_plugins.json
+if (fs.existsSync(pluginsFile)) {
+  try {
+    const data = JSON.parse(fs.readFileSync(pluginsFile, 'utf8'));
+    for (const [key, installs] of Object.entries(data.plugins || {})) {
+      for (const install of installs) {
+        const isUser = install.scope === 'user';
+        const isLocal = install.scope === 'local' && install.projectPath === cwd;
+        if (isUser || isLocal) {
+          skills.add(key.split('@')[0]);
+        }
+      }
+    }
+  } catch { /* non-fatal */ }
+}
+
+// Source 2: personal skills — subdirectories containing a SKILL.md
+if (fs.existsSync(personalSkillsDir)) {
+  try {
+    for (const entry of fs.readdirSync(personalSkillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillMd = path.join(personalSkillsDir, entry.name, 'SKILL.md');
+      if (fs.existsSync(skillMd)) {
+        skills.add(entry.name);
+      }
+    }
+  } catch { /* non-fatal */ }
+}
+
+const sorted = [...skills].sort();
+const query = process.argv[2];
+
+if (!query) {
+  // Print all available skill names
+  if (sorted.length > 0) process.stdout.write(sorted.join('\n') + '\n');
+  process.exit(0);
+} else {
+  // Exit 0 if skill is available, 1 if not
+  process.exit(sorted.includes(query) ? 0 : 1);
+}

package/dist/forge-payload/tools/store-cli.cjs

@@ -389,6 +389,32 @@ function listEntities(entity, filter) {
     case 'task':    return store.listTasks(filter);
     case 'bug':     return store.listBugs(filter);
     case 'feature': return store.listFeatures(filter);
+    case 'event': {
+      // Defect D fix: traverse all sub-directories under events/ — sprints write
+      // to events/<sprintId>/, bugs to events/bugs/, enhancements to events/enhancement/.
+      // Return the union of all event JSONs across every sub-directory, skipping
+      // sidecar files (_-prefixed) and non-JSON files.
+      const eventsBase = path.join(store.impl.storeRoot, 'events');
+      if (!fs.existsSync(eventsBase)) return [];
+      const allEvents = [];
+      const subDirs = fs.readdirSync(eventsBase, { withFileTypes: true });
+      for (const entry of subDirs) {
+        if (!entry.isDirectory()) continue;
+        const subDir = path.join(eventsBase, entry.name);
+        const files = fs.readdirSync(subDir).filter(
+          (f) => f.endsWith('.json') && !f.startsWith('_')
+        );
+        for (const file of files) {
+          try {
+            const rec = JSON.parse(fs.readFileSync(path.join(subDir, file), 'utf8'));
+            if (rec && (!filter || Object.entries(filter).every(([k, v]) => rec[k] === v))) {
+              allEvents.push(rec);
+            }
+          } catch (_) { /* skip malformed files */ }
+        }
+      }
+      return allEvents;
+    }
     default:
       console.error(`Unknown entity type: ${entity}${formatSuggestion(suggestEntityType(entity, ['sprint', 'task', 'bug', 'feature']))}`);
       process.exit(1);
@@ -635,7 +661,7 @@ function cmdList() {
   }
 
   if (!ENTITY_TYPES.includes(entity)) {
-    console.error(`Unknown entity type: ${entity}${formatSuggestion(suggestEntityType(entity, ['sprint', 'task', 'bug', 'feature']))}`);
+    console.error(`Unknown entity type: ${entity}${formatSuggestion(suggestEntityType(entity, ['sprint', 'task', 'bug', 'event', 'feature']))}`);
     process.exit(1);
   }
 

package/dist/forge-payload/tools/substitute-placeholders.cjs

@@ -343,13 +343,14 @@ function renderDeploymentTable(envs) {
  * Advisory Note 3: every output path is resolved and checked to be under outRoot
  * to prevent path traversal via symlinks or '..' segments.
  *
- * @param {string} basePack       — absolute path to the base-pack directory
+ * @param {string} basePack           — absolute path to the base-pack directory
  * @param {Map<string, string>} map
- * @param {string} outRoot        — absolute project root (e.g. '/home/user/myproject')
- * @param {boolean} dryRun        — if true, perform no writes
- * @param {{ warn: function }} io  — pluggable stderr for warnings
+ * @param {string} outRoot            — absolute project root (e.g. '/home/user/myproject')
+ * @param {boolean} dryRun            — if true, perform no writes
+ * @param {{ warn: function }} io     — pluggable stderr for warnings
+ * @param {Set<string>|null} categoryFilter — Defect E: if set, only walk matching subdirs
  */
-function walkBasePack(basePack, map, outRoot, dryRun, io) {
+function walkBasePack(basePack, map, outRoot, dryRun, io, categoryFilter) {
   const warn = (io && io.warn) || ((msg) => process.stderr.write(msg + '\n'));
 
   // Extract prefix from substitution map for commands path computation
@@ -363,6 +364,11 @@ function walkBasePack(basePack, map, outRoot, dryRun, io) {
     const stat = fs.statSync(subdirPath);
     if (!stat.isDirectory()) continue;
 
+    // Defect E: skip subdirs not in the category filter when one is provided
+    if (categoryFilter !== null && categoryFilter !== undefined && !categoryFilter.has(subdir)) {
+      continue;
+    }
+
     let relOutputDir;
     if (subdir === 'commands') {
       relOutputDir = path.join('.claude', 'commands', commandsSubdir);
@@ -464,6 +470,32 @@ function walkBasePackPi(src, outRoot, dryRun, io) {
 if (require.main === module) {
   try {
     const argv = process.argv.slice(2);
+
+    // ── Defect C fix: short-circuit --help/-h BEFORE any path resolution ────────
+    if (argv.includes('--help') || argv.includes('-h')) {
+      process.stdout.write([
+        'substitute-placeholders.cjs — Phase 3 (Materialize) engine.',
+        '',
+        'Usage:',
+        '  node substitute-placeholders.cjs [options]',
+        '',
+        'Options:',
+        '  --target <claude-code|pi>  Output layout target (default: claude-code)',
+        '  --src <path>               Base-pack source dir for --target pi',
+        '  --forge-root <path>        Forge plugin root directory',
+        '  --base-pack <path>         Base-pack directory (probes .base-pack/ then init/base-pack/)',
+        '  --config <path>            Path to .forge/config.json',
+        '  --context <path>           Path to project-context.json',
+        '  --rules <path>             Path to build-base-pack-rules.json',
+        '  --out <path>               Output root directory (default: cwd)',
+        '  --dry-run                  Preview without writing',
+        '  --category <name[,name]>   Limit materialisation to named subdirectories',
+        '                             (personas, skills, workflows, templates, commands)',
+        '  --help, -h                 Show this message and exit',
+      ].join('\n') + '\n');
+      process.exit(0);
+    }
+
     const args = parseCliArgs(argv);
 
     const dryRun = args.dryRun || false;
@@ -515,8 +547,20 @@ if (require.main === module) {
     // Resolve forge root
     const forgeRoot = args.forgeRoot || resolveForgeRoot();
 
-    // Resolve base-pack
-    const basePack = args.basePack || path.join(forgeRoot, 'init', 'base-pack');
+    // Resolve base-pack — Defect C fix: when no --base-pack flag given,
+    // probe .base-pack/ (bundled layout) before init/base-pack (source layout).
+    let basePack;
+    if (args.basePack) {
+      basePack = args.basePack;
+    } else {
+      const dotBasePack = path.resolve(process.cwd(), '.base-pack');
+      const initBasePack = path.join(forgeRoot, 'init', 'base-pack');
+      if (fs.existsSync(dotBasePack)) {
+        basePack = dotBasePack;
+      } else {
+        basePack = initBasePack;
+      }
+    }
     if (!fs.existsSync(basePack)) {
       process.stderr.write(`substitute-placeholders: base-pack not found at ${basePack}\n`);
       process.exit(1);
@@ -563,8 +607,15 @@ if (require.main === module) {
       process.exit(1);
     }
 
+    // Defect E: parse --category flag into a Set<string> filter (or null for all)
+    let categoryFilter = null;
+    if (args.category) {
+      const cats = args.category.split(',').map((c) => c.trim()).filter(Boolean);
+      categoryFilter = new Set(cats);
+    }
+
     // Walk and materialise
-    walkBasePack(basePack, map, outRoot, dryRun, null);
+    walkBasePack(basePack, map, outRoot, dryRun, null, categoryFilter);
 
     if (dryRun) {
       process.stdout.write('substitute-placeholders: dry run complete (no files written)\n');
@@ -593,6 +644,7 @@ function parseCliArgs(argv) {
     if (a === '--context' && argv[i + 1]) { args.context = argv[++i]; continue; }
     if (a === '--rules' && argv[i + 1]) { args.rules = argv[++i]; continue; }
     if (a === '--out' && argv[i + 1]) { args.out = argv[++i]; continue; }
+    if (a === '--category' && argv[i + 1]) { args.category = argv[++i]; continue; }
   }
   return args;
 }

package/dist/forge-payload/tools/verify-integrity.cjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+
+// Forge tool: verify-integrity
+// Runtime integrity verifier — reads integrity.json, re-hashes each file, reports drift.
+// Usage: node verify-integrity.cjs [--forge-root <path>]
+// Exit codes: 0 = all clean, 1 = one or more files modified or missing, 2 = manifest missing
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function computeHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+function verifyIntegrity(forgeRoot) {
+  const manifestPath = path.join(forgeRoot, 'integrity.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    const output = '× integrity.json not found — run /forge:update to restore';
+    return { exitCode: 1, output, modified: [], missing: [] };
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (e) {
+    const output = `× integrity.json is not valid JSON: ${e.message}`;
+    return { exitCode: 1, output, modified: [], missing: [] };
+  }
+
+  const { files } = manifest;
+  if (!files || typeof files !== 'object') {
+    const output = '× integrity.json has no "files" field';
+    return { exitCode: 1, output, modified: [], missing: [] };
+  }
+
+  const modified = [];
+  const missing = [];
+
+  for (const [rel, expectedHash] of Object.entries(files)) {
+    const abs = path.join(forgeRoot, rel);
+    if (!fs.existsSync(abs)) {
+      missing.push(rel);
+      continue;
+    }
+    const actual = computeHash(abs);
+    if (actual !== expectedHash) {
+      modified.push(rel);
+    }
+  }
+
+  const totalFiles = Object.keys(files).length;
+  const problemCount = modified.length + missing.length;
+
+  if (problemCount === 0) {
+    const output = `〇 Plugin integrity — all ${totalFiles} files unmodified`;
+    return { exitCode: 0, output, modified: [], missing: [] };
+  }
+
+  const lines = [`△ Plugin integrity — ${problemCount} file${problemCount === 1 ? '' : 's'} modified or missing:`];
+  for (const f of modified) {
+    lines.push(`  · ${f} (hash mismatch — run /forge:update to restore)`);
+  }
+  for (const f of missing) {
+    lines.push(`  · ${f} (missing — run /forge:update to restore)`);
+  }
+
+  return { exitCode: 1, output: lines.join('\n'), modified, missing };
+}
+
+module.exports = { verifyIntegrity };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const forgeRootIdx = args.indexOf('--forge-root');
+  const forgeRoot = forgeRootIdx !== -1
+    ? path.resolve(args[forgeRootIdx + 1])
+    : path.resolve(__dirname, '..');
+
+  const result = verifyIntegrity(forgeRoot);
+  console.log(result.output);
+  process.exit(result.exitCode);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entelligentsia/forgecli",
-  "version": "0.10.1",
+  "version": "0.11.2",
   "description": "Forge SDLC ported onto @earendil-works/pi-coding-agent — production launcher with three bin aliases (forge/forgecli/4ge). Bundles a curated fork of pi-coding-agent vendored under earendil-works names.",
   "license": "MIT",
   "author": "Entelligentsia",
@@ -49,7 +49,7 @@
     ]
   },
   "forge": {
-    "bundledVersion": "0.44.3",
+    "bundledVersion": "0.44.6",
     "forgeRoot": "../forge/forge"
   },
   "scripts": {