@entelligentsia/forgecli 1.0.10 → 1.0.14

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

@@ -132,9 +132,17 @@ function validateManifest(manifest, forgeRoot) {
     fragments: path.join(basePackDir, 'workflows', '_fragments'),
     templates: path.join(basePackDir, 'templates'),
     commands:  path.join(basePackDir, 'commands'),
+    'workflows-js': path.join(basePackDir, 'workflows-js'),
+    // tools: not base-pack-sourced — source is forgeRoot/tools/ (verbatim vendor).
+    // Uses recursive enumeration to include lib/*.cjs with the lib/ prefix.
+    tools: path.join(forgeRoot, 'tools'),
     // schemas: not base-pack-sourced — source is forgeRoot/schemas/
   };
 
+  // Namespaces that require recursive enumeration (files may include path prefixes
+  // like lib/*.cjs). The walker returns relative paths with forward slashes.
+  const recursiveNs = new Set(['tools']);
+
   const manifestOnly = [];  // Files in manifest but not in base-pack
   const basePackOnly = [];   // Files in base-pack but not in manifest
 
@@ -147,14 +155,31 @@ function validateManifest(manifest, forgeRoot) {
 
     const manifestFiles = new Set(ns.files || []);
 
-    // Read base-pack source directory
+    // Read base-pack source directory (flat or recursive depending on namespace)
     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();
-      });
+      if (recursiveNs.has(nsKey)) {
+        // Recursive walk: enumerate all files, returning paths relative to sourceDir
+        // (with forward-slash separators). Excludes *.test.cjs files.
+        const walkDir = (dir, prefix) => {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+              walkDir(path.join(dir, entry.name), relPath);
+            } else if (entry.isFile() && !entry.name.endsWith('.test.cjs')) {
+              basePackFiles.push(relPath);
+            }
+          }
+        };
+        walkDir(sourceDir, '');
+      } else {
+        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) {
@@ -183,9 +208,65 @@ function validateManifest(manifest, forgeRoot) {
   return { manifestOnly, basePackOnly };
 }
 
+// Checks whether the vendored .forge/tools/ directory is present, and whether
+// the version marker (.forge/tools/.forge-tools-version) matches the active
+// plugin version from .forge/config.json (paths.forgeRef).
+//
+// Returns:
+//   { present, vendoredVersion, activeVersion, stale, reason }
+//
+//   present        — true if .forge/tools/ directory exists
+//   vendoredVersion — version string from .forge-tools-version (or null)
+//   activeVersion   — version string from paths.forgeRef in config (or null)
+//   stale          — true when: dir absent=false; marker absent=true; versions differ=true
+//   reason         — 'ok' | 'missing' | 'marker-absent' | 'version-mismatch'
+function checkToolsVersion(projectRoot) {
+  const toolsDir = path.join(projectRoot, '.forge', 'tools');
+  const markerFile = path.join(toolsDir, '.forge-tools-version');
+  const configFile = path.join(projectRoot, '.forge', 'config.json');
+
+  // Dir absent → not stale (just missing)
+  if (!fs.existsSync(toolsDir)) {
+    return { present: false, vendoredVersion: null, activeVersion: null, stale: false, reason: 'missing' };
+  }
+
+  // Read active version from config
+  let activeVersion = null;
+  if (fs.existsSync(configFile)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      activeVersion = (cfg && cfg.paths && cfg.paths.forgeRef) ? cfg.paths.forgeRef : null;
+    } catch {
+      // unparseable — leave activeVersion null
+    }
+  }
+
+  // Marker absent → stale
+  if (!fs.existsSync(markerFile)) {
+    return { present: true, vendoredVersion: null, activeVersion, stale: true, reason: 'marker-absent' };
+  }
+
+  // Read vendored version from marker
+  let vendoredVersion = null;
+  try {
+    const marker = JSON.parse(fs.readFileSync(markerFile, 'utf8'));
+    vendoredVersion = (marker && marker.version) ? marker.version : null;
+  } catch {
+    // unparseable marker → treat as marker-absent
+    return { present: true, vendoredVersion: null, activeVersion, stale: true, reason: 'marker-absent' };
+  }
+
+  // Version mismatch → stale
+  if (activeVersion && vendoredVersion && vendoredVersion !== activeVersion) {
+    return { present: true, vendoredVersion, activeVersion, stale: true, reason: 'version-mismatch' };
+  }
+
+  return { present: true, vendoredVersion, activeVersion, stale: false, reason: 'ok' };
+}
+
 // ── Exports ────────────────────────────────────────────────────────────────────
 
-module.exports = { checkNamespaces, validateManifest };
+module.exports = { checkNamespaces, validateManifest, checkToolsVersion };
 
 // ── CLI ────────────────────────────────────────────────────────────────────────
 

package/dist/forge-payload/tools/collate.cjs

@@ -108,9 +108,23 @@ function resolveTaskDir(task, sprintDirPath, engPath) {
   const normalizedTaskPath = task.path ? task.path.replace(/\\/g, '/').replace(/\/$/, '') : null;
   const normalizedEngPath  = engPath   ? engPath.replace(/\\/g, '/').replace(/\/$/, '')  : '';
 
-  // Case 1: path is under the engineering root — it IS the task directory
+  // Case 1: path is under the engineering root — it IS (or is a file inside)
+  // the task directory. Some store records carry task.path pointing at a file
+  // inside the task dir (e.g. .../FORGE-S22-T04/PLAN.md) rather than the dir
+  // itself; in that case basename(path) is the filename, not the dir. Only
+  // trust Case 1 when its candidate resolves to a real directory on disk —
+  // otherwise fall through to the filesystem scan, which resolves by taskId.
   if (normalizedTaskPath && normalizedEngPath && normalizedTaskPath.startsWith(normalizedEngPath + '/')) {
-    return resultOk(path.basename(normalizedTaskPath));
+    const candidate = path.basename(normalizedTaskPath);
+    // Can't verify against disk — preserve legacy behaviour and trust the path.
+    if (!sprintDirPath) return resultOk(candidate);
+    const candidatePath = path.join(sprintDirPath, candidate);
+    // Trust Case 1 only when the candidate is a real directory. If it's a file
+    // (task.path pointed at a doc inside the dir) or absent, fall through to the
+    // filesystem scan below, which resolves the dir by taskId.
+    if (fs.existsSync(candidatePath) && fs.statSync(candidatePath).isDirectory()) {
+      return resultOk(candidate);
+    }
   }
 
   // Case 2 (and fallback for case 1 missing): filesystem scan

package/dist/forge-payload/tools/manage-config.cjs

@@ -418,7 +418,7 @@ if (subcmd === 'resolve-forge-root') {
 
   const { config } = readConfig();
   const forgeRef = getByPath(config, 'paths.forgeRef');
-  const forgeRoot = getByPath(config, 'paths.forgeRoot');
+  // Note: paths.forgeRoot read removed in FORGE-S29-T03 (Priority 3 deprecated).
 
   // Priority 2: Scan cache/marketplace directories by forgeRef
   if (forgeRef && typeof forgeRef === 'string') {
@@ -442,14 +442,12 @@ if (subcmd === 'resolve-forge-root') {
     }
   }
 
-  // Priority 3: Fallback to paths.forgeRoot (deprecated but still read)
-  if (forgeRoot && typeof forgeRoot === 'string') {
-    console.log(forgeRoot);
-    process.exit(0);
-  }
+  // Priority 3 (paths.forgeRoot fallback) removed — FORGE-S29-T03.
+  // paths.forgeRoot is deprecated and no longer used as a resolution fallback.
+  // Relying on it masks misconfigured projects and blocks the FORGE_ROOT retirement.
 
   // No resolution possible
-  console.error('× Cannot resolve Forge plugin root: no CLAUDE_PLUGIN_ROOT env var, no forgeRef cache match, and no forgeRoot in config.');
+  console.error('× Cannot resolve Forge plugin root: no CLAUDE_PLUGIN_ROOT env var and no forgeRef cache match. Run /forge:update to refresh.');
   process.exit(1);
 }
 

package/dist/forge-payload/tools/parse-gates.cjs

@@ -154,4 +154,76 @@ function parseAfter(rest, lineNo) {
   return { phase: m[1], verdict };
 }
 
-module.exports = { parseGates };
+// parseOutputs — same fence-scan logic as parseGates but for ```outputs phase=X blocks.
+// Closed grammar: only `artifact` and `require` directives are allowed.
+// Unknown directives throw (parity with parseGates).
+const OUTPUTS_FENCE_OPEN = /^```outputs\s+phase=([A-Za-z0-9_-]+)\s*$/;
+
+function parseOutputs(markdown) {
+  if (typeof markdown !== 'string' || markdown.length === 0) return {};
+  const lines = markdown.split('\n');
+  const result = {};
+  let currentPhase = null;
+  let inFence = false;
+  let fenceStartLine = -1;
+  let fenceBuffer = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    if (!inFence) {
+      const m = line.match(OUTPUTS_FENCE_OPEN);
+      if (m) {
+        currentPhase = m[1];
+        if (result[currentPhase]) {
+          throw new Error(
+            `parse-gates: line ${lineNo}: duplicate outputs block for phase "${currentPhase}"`,
+          );
+        }
+        inFence = true;
+        fenceStartLine = lineNo;
+        fenceBuffer = [];
+      }
+      continue;
+    }
+    // Inside an outputs fence
+    if (FENCE_CLOSE.test(line)) {
+      result[currentPhase] = parseOutputsBlock(fenceBuffer, fenceStartLine);
+      inFence = false;
+      currentPhase = null;
+      fenceBuffer = [];
+      continue;
+    }
+    fenceBuffer.push({ text: line, lineNo });
+  }
+  if (inFence) {
+    throw new Error(`parse-gates: unterminated \`\`\`outputs fence opened at line ${fenceStartLine}`);
+  }
+  return result;
+}
+
+function parseOutputsBlock(bufferedLines, _fenceStartLine) {
+  const spec = { artifacts: [], require: [] };
+  for (const { text, lineNo } of bufferedLines) {
+    const trimmed = text.trim();
+    if (trimmed === '' || trimmed.startsWith('#')) continue;
+    const firstSpace = trimmed.search(/\s/);
+    if (firstSpace < 0) {
+      throw new Error(`parse-gates: line ${lineNo}: malformed directive "${trimmed}"`);
+    }
+    const directive = trimmed.slice(0, firstSpace);
+    const rest = trimmed.slice(firstSpace + 1).trim();
+    switch (directive) {
+      case 'artifact':
+        spec.artifacts.push(parseArtifact(rest, lineNo));
+        break;
+      case 'require':
+        spec.require.push(parsePredicate(rest, lineNo));
+        break;
+      default:
+        throw new Error(`parse-gates: line ${lineNo}: unknown directive "${directive}"`);
+    }
+  }
+  return spec;
+}
+
+module.exports = { parseGates, parseOutputs };

package/dist/forge-payload/tools/postflight-gate.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+// postflight-gate.cjs — evaluates a phase's declared outputs block against
+// the filesystem / task state, post-subagent-return. Returns structured failure
+// data so the orchestrator (run-task.ts) can halt before FSM advance when outputs
+// are not satisfied.
+//
+// Pure function: only fs.existsSync / fs.statSync / fs.readFileSync. No writes,
+// no network, no LLM, no process spawns.
+//
+// CLI shim: node postflight-gate.cjs --phase <name> --task <taskId>
+// Exit codes: 0 (ok), 1 (guard failed), 2 (invalid args / parse error)
+// Stdout on exit 1: single JSON line { phase, reasonCode, detail, remediation }
+//
+// New reasonCodes (FORGE-S26-T19):
+//   output-missing  — artifact path does not exist
+//   output-stub     — artifact exists but size < min= bytes
+//   require-failed  — require predicate over state field failed
+//   tool-error      — internal parse or store-read failure
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * postflight({ phase, outputs, state, substitutions })
+ *
+ * @param {string} phase - Phase name (e.g. 'implement')
+ * @param {object} outputs - Parsed outputs spec from parseOutputs() — { [phase]: { artifacts, require } }
+ * @param {object} [state] - Task/bug state for require predicates (e.g. { task: {...} })
+ * @param {object} [substitutions] - Template variable substitutions (e.g. { engineering, sprint, task })
+ * @returns {{ ok: boolean, missing: string[], reasonCode: string, detail: string, remediation: string }}
+ */
+function postflight({ phase, outputs, state = {}, substitutions = {} }) {
+  const spec = outputs && outputs[phase];
+  if (!spec) {
+    // No outputs block for this phase — pass through (no-op)
+    return { ok: true, missing: [], reasonCode: null, detail: '', remediation: '' };
+  }
+
+  const missing = [];
+
+  for (const art of spec.artifacts || []) {
+    const resolved = applySubstitutions(art.path, substitutions);
+    let exists = false;
+    let size = 0;
+    try {
+      const st = fs.statSync(resolved);
+      exists = st.isFile();
+      size = st.size;
+    } catch (_) {
+      exists = false;
+    }
+    if (!exists) {
+      missing.push(`output-missing: artifact absent: ${resolved}`);
+    } else if (size < (art.minBytes || 0)) {
+      missing.push(
+        `output-stub: artifact too small: ${resolved} (${size} bytes, need >= ${art.minBytes})`,
+      );
+    }
+  }
+
+  for (const pred of spec.require || []) {
+    if (!evalPredicate(pred, state)) {
+      missing.push(
+        `require-failed: ${describePredicate(pred)} (got ${JSON.stringify(readField(pred.field, state))})`,
+      );
+    }
+  }
+
+  if (missing.length === 0) {
+    return { ok: true, missing: [], reasonCode: null, detail: '', remediation: '' };
+  }
+
+  const { reasonCode, detail, remediation } = buildStructuredFailure(phase, missing);
+  return { ok: false, missing, reasonCode, detail, remediation };
+}
+
+function applySubstitutions(template, subs) {
+  return template.replace(/\{(\w+)\}/g, (full, key) => {
+    if (Object.prototype.hasOwnProperty.call(subs, key)) return String(subs[key]);
+    return full;
+  });
+}
+
+function readField(dottedPath, state) {
+  const parts = dottedPath.split('.');
+  let cur = state;
+  for (const p of parts) {
+    if (cur === null || cur === undefined) return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function evalPredicate(pred, state) {
+  const actual = readField(pred.field, state);
+  switch (pred.op) {
+    case '==':
+      return String(actual) === String(pred.value);
+    case '!=':
+      return String(actual) !== String(pred.value);
+    case 'in':
+      return (pred.value || []).map(String).includes(String(actual));
+    default:
+      throw new Error(`postflight-gate: unknown predicate op "${pred.op}"`);
+  }
+}
+
+function describePredicate(pred) {
+  if (pred.op === 'in') return `${pred.field} in [${(pred.value || []).join(', ')}]`;
+  return `${pred.field} ${pred.op} ${pred.value}`;
+}
+
+function buildStructuredFailure(phase, missing) {
+  let reasonCode = 'tool-error';
+  const detailParts = [];
+
+  for (const m of missing) {
+    detailParts.push(m);
+    if (reasonCode === 'tool-error') {
+      if (/^output-missing/i.test(m)) {
+        reasonCode = 'output-missing';
+      } else if (/^output-stub/i.test(m)) {
+        reasonCode = 'output-stub';
+      } else if (/^require-failed/i.test(m)) {
+        reasonCode = 'require-failed';
+      }
+    }
+  }
+
+  const detail = detailParts.join('; ');
+
+  const remediationMap = {
+    'output-missing': 'Re-run the phase that produces this artifact (e.g. /forge:implement), then retry.',
+    'output-stub': 'The artifact was produced but appears incomplete (stub). Ensure the phase wrote a complete file.',
+    'require-failed': 'Correct the task/bug state so it satisfies the postflight require predicate, then retry.',
+    'tool-error': 'Check the outputs block configuration and store records; run node .forge/tools/postflight-gate.cjs manually for diagnostics.',
+  };
+
+  return {
+    reasonCode,
+    detail,
+    remediation: remediationMap[reasonCode],
+  };
+}
+
+module.exports = { postflight };
+
+// CLI shim — only runs when invoked directly
+if (require.main === module) {
+  const args = parseArgs(process.argv.slice(2));
+  if (!args.phase || !args.task) {
+    process.stderr.write('Usage: postflight-gate.cjs --phase <phaseName> --task <taskId>\n');
+    process.exit(2);
+  }
+
+  const { parseOutputs } = require('./parse-gates.cjs');
+
+  // Resolve config
+  let engineeringRoot = 'engineering';
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), '.forge/config.json'), 'utf8'));
+    if (cfg.paths && cfg.paths.engineering) engineeringRoot = cfg.paths.engineering;
+  } catch (_) { /* fall back to default */ }
+
+  // Load task record
+  let taskRecord = null;
+  try {
+    const store = require('./store.cjs');
+    taskRecord = store.getTask(args.task);
+  } catch (_) {
+    // store.cjs not available or task not found — continue with substitutions from args
+  }
+
+  // Build substitutions
+  const sprintId = taskRecord ? taskRecord.sprintId : undefined;
+  const substitutions = {
+    engineering: engineeringRoot,
+    sprint: sprintId,
+    task: args.task,
+  };
+
+  // Load workflow markdown (scan .forge/workflows/ for phase)
+  const workflowMd = loadWorkflowMarkdown(args.phase);
+  if (!workflowMd) {
+    process.stderr.write(`postflight-gate: no outputs block defined for phase "${args.phase}" — skipping\n`);
+    process.exit(0);
+  }
+
+  let outputs;
+  try {
+    outputs = parseOutputs(workflowMd);
+  } catch (err) {
+    process.stderr.write(`postflight-gate: ${err.message}\n`);
+    process.exit(2);
+  }
+
+  if (!outputs[args.phase]) {
+    process.stderr.write(`postflight-gate: no outputs block for phase "${args.phase}" — skipping\n`);
+    process.exit(0);
+  }
+
+  // Build state from task record
+  const state = {};
+  if (taskRecord) state.task = taskRecord;
+
+  const result = postflight({ phase: args.phase, outputs, state, substitutions });
+
+  if (result.ok) process.exit(0);
+
+  process.stderr.write(`Postflight guard failed for phase "${args.phase}":\n`);
+  for (const m of result.missing) process.stderr.write(`  - ${m}\n`);
+
+  // Emit structured JSON on stdout for orchestrators
+  process.stdout.write(JSON.stringify({
+    phase: args.phase,
+    reasonCode: result.reasonCode,
+    detail: result.detail,
+    remediation: result.remediation,
+  }) + '\n');
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--phase') out.phase = argv[++i];
+    else if (a === '--task') out.task = argv[++i];
+  }
+  return out;
+}
+
+function loadWorkflowMarkdown(phaseName) {
+  const workflowsDir = path.resolve(process.cwd(), '.forge/workflows');
+  let entries;
+  try {
+    entries = fs.readdirSync(workflowsDir).filter((f) => f.endsWith('.md'));
+  } catch (_) {
+    return null;
+  }
+  const fencePattern = new RegExp('^```outputs\\s+phase=' + escapeRegex(phaseName) + '\\s*$', 'm');
+  for (const entry of entries) {
+    const md = fs.readFileSync(path.join(workflowsDir, entry), 'utf8');
+    if (fencePattern.test(md)) return md;
+  }
+  return null;
+}
+
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/forge-payload/tools/preflight-gate.cjs

@@ -349,9 +349,56 @@ if (require.main === module) {
   if (result.ok) process.exit(0);
   process.stderr.write(`Gate failed for phase "${args.phase}":\n`);
   for (const m of result.missing) process.stderr.write(`  - ${m}\n`);
+  // Emit structured JSON on stdout for orchestrators to parse and render.
+  // Shape: { phase, reasonCode, detail, remediation }
+  const structured = buildStructuredFailure(args.phase, result.missing);
+  process.stdout.write(JSON.stringify(structured) + '\n');
   process.exit(1);
 }
 
+// Build a structured gate-failure object for orchestrators.
+// Maps the human-readable `missing[]` strings to a typed { phase, reasonCode, detail, remediation }.
+// reasonCode is derived from the dominant failure pattern:
+//   artifact-missing            — artifact missing / too small
+//   predecessor-verdict-missing — after-clause verdict absent or wrong
+//   illegal-status              — require/forbid predicate fired
+//   tool-error                  — internal error / unrecognised pattern
+// When multiple failures exist, reasonCode reflects the first recognised pattern;
+// detail combines all messages; only a single JSON object is ever emitted.
+function buildStructuredFailure(phase, missing) {
+  let reasonCode = 'tool-error';
+  const detailParts = [];
+
+  for (const m of missing) {
+    detailParts.push(m);
+    if (reasonCode === 'tool-error') {
+      if (/^artifact (missing|too small)/i.test(m)) {
+        reasonCode = 'artifact-missing';
+      } else if (/^predecessor verdict (missing|unreadable)/i.test(m) || /verdict is "/i.test(m)) {
+        reasonCode = 'predecessor-verdict-missing';
+      } else if (/^(require failed|forbid triggered)/i.test(m)) {
+        reasonCode = 'illegal-status';
+      }
+    }
+  }
+
+  const detail = detailParts.join('; ');
+
+  const remediationMap = {
+    'artifact-missing': `Re-run the phase that produces this artifact (e.g. /forge:plan or /forge:implement), then retry.`,
+    'predecessor-verdict-missing': `Ensure the predecessor review phase completed and recorded a verdict via set-summary, then retry.`,
+    'illegal-status': `Correct the task/bug status (use store-cli update-status) so it satisfies the gate predicate, then retry.`,
+    'tool-error': `Check the gate configuration and store records for this task; run node .forge/tools/preflight-gate.cjs manually for diagnostics.`,
+  };
+
+  return {
+    phase,
+    reasonCode,
+    detail,
+    remediation: remediationMap[reasonCode],
+  };
+}
+
 function parseArgs(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {

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

@@ -120,10 +120,11 @@ const RUNTIME_PASSTHROUGH_KEYS = new Set([
  * project prefix via getCommandsSubdir() — see walkBasePack.
  */
 const SUBDIR_OUTPUT_MAP = {
-  personas:  path.join('.forge', 'personas'),
-  skills:    path.join('.forge', 'skills'),
-  workflows: path.join('.forge', 'workflows'),
-  templates: path.join('.forge', 'templates'),
+  personas:       path.join('.forge', 'personas'),
+  skills:         path.join('.forge', 'skills'),
+  workflows:      path.join('.forge', 'workflows'),
+  templates:      path.join('.forge', 'templates'),
+  'workflows-js': path.join('.claude', 'workflows'),
 };
 
 /**

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

@@ -194,6 +194,14 @@ function verifyPhase2(cwd, kbPath) {
 
 const PHASE3_DIRS = ['workflows', 'personas', 'skills', 'templates'];
 
+// JS workflow files that substitute-placeholders.cjs emits from
+// base-pack/workflows-js/ into .claude/workflows/ (FORGE-S28-T01).
+// These are checked in addition to the .forge/ directory checks.
+const PHASE3_JS_FILES = [
+  path.join('.claude', 'workflows', 'wfl-run-task.js'),
+  path.join('.claude', 'workflows', 'wfl-run-sprint.js'),
+];
+
 function verifyPhase3(cwd) {
   const missing = [];
   const checked = [];
@@ -213,6 +221,15 @@ function verifyPhase3(cwd) {
     }
   }
 
+  // Assert generated JS workflow files are present (FORGE-S28-T01)
+  for (const relFile of PHASE3_JS_FILES) {
+    checked.push(relFile);
+    const absFile = path.join(cwd, relFile);
+    if (!fs.existsSync(absFile)) {
+      missing.push(relFile);
+    }
+  }
+
   return {
     phase: 3,
     ok: missing.length === 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entelligentsia/forgecli",
-  "version": "1.0.10",
+  "version": "1.0.14",
   "description": "Forge SDLC ported onto @earendil-works/pi-coding-agent \u2014 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",

package/dist/bin/forgecli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/bin/forgecli.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-// Stage 1 scaffold (FORGE-S15-T01). Real CLI entry lands in FORGE-S15-T03.
-console.log("forgecli stub — see FORGE-S15-T03");
-process.exit(0);
-export {};
-//# sourceMappingURL=forgecli.js.map

package/dist/bin/forgecli.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"forgecli.js","sourceRoot":"","sources":["../../src/bin/forgecli.ts"],"names":[],"mappings":";AACA,2EAA2E;AAE3E,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;AACjD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC"}

package/dist/extensions/forgecli/config-tui/index.d.ts

@@ -1,5 +0,0 @@
-export { createConfigTuiComponent, type ConfigTuiComponentOptions } from "./component.js";
-export type { ConfigLayer } from "../config-writer.js";
-export type { View, ConfigBuffer, AvailableModel, InitOptions, ConfigTuiState, ConfigTuiAction, PhaseOverride, ResolvedPersonaEntry, PersonaPickerEntry, PipelineOverrideSummary, TierAssignment, } from "./state/model.js";
-export { CANONICAL_PHASES, initialState, reducer, getActiveView, listResolvedPersonas, listPersonaPickerEntries, uniqueProviders, listPipelineOverrideSummaries, getPhaseOverride, getTierAssignment, getAllTierAssignments, getTierForPersona, getPersonasInTier, writePersonaEntry, deletePersonaEntry, writePhaseOverride, clearPhaseOverride, writeTierAssignment, isConfigEmpty, personaSourceLabel, } from "./state.js";
-export type { InputResult, Screen } from "./screens/types.js";

package/dist/extensions/forgecli/config-tui/index.js

@@ -1,5 +0,0 @@
-// Config-TUI public re-exports.
-// Phase 3: theming + width safety + data-driven menus + auth error surfacing.
-export { createConfigTuiComponent } from "./component.js";
-export { CANONICAL_PHASES, initialState, reducer, getActiveView, listResolvedPersonas, listPersonaPickerEntries, uniqueProviders, listPipelineOverrideSummaries, getPhaseOverride, getTierAssignment, getAllTierAssignments, getTierForPersona, getPersonasInTier, writePersonaEntry, deletePersonaEntry, writePhaseOverride, clearPhaseOverride, writeTierAssignment, isConfigEmpty, personaSourceLabel, } from "./state.js";
-//# sourceMappingURL=index.js.map

package/dist/extensions/forgecli/config-tui/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/extensions/forgecli/config-tui/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,8EAA8E;AAE9E,OAAO,EAAE,wBAAwB,EAAkC,MAAM,gBAAgB,CAAC;AAkB1F,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,OAAO,EACP,aAAa,EACb,oBAAoB,EACpB,wBAAwB,EACxB,eAAe,EACf,6BAA6B,EAC7B,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,GACnB,MAAM,YAAY,CAAC"}