@entelligentsia/forgecli 1.0.21 → 1.0.36

package/dist/forge-payload/tools/commit-task.cjs

@@ -0,0 +1,218 @@
+'use strict';
+
+// commit-task.cjs — deterministic commit choreography (forge-engineering#40).
+//
+// The commit phase was the most expensive phase of the SDLC pipeline
+// (15–31% of run input tokens across instrumented runs) because an LLM
+// re-derived deterministic choreography turn-by-turn: gate, state check,
+// staging-set discovery, boundary verification, commit, terminal status
+// transition. This tool owns the whole sequence; the agent supplies only the
+// commit message (the single judgement-worthy step).
+//
+// Staging-set derivation (the commit boundary mirrors the task boundary):
+//   1. record.path — the task/bug artifact directory (always staged)
+//   2. record.summaries.implementation.files_changed — provenance recorded
+//      by the implement phase (PHASE_SUMMARY_SCHEMA.files_changed)
+//   3. --also <path> extras (each validated to stay inside the project root)
+//
+// Usage:
+//   node commit-task.cjs --task <id> | --bug <id>
+//        --message <msg>      commit subject/body (required unless --dry-run)
+//        [--trailer <line>]   optional Co-authored-by trailer
+//        [--also <path>]      extra path to stage (repeatable)
+//        [--skip-gate]        skip preflight-gate (orchestrator already ran it)
+//        [--force]            bypass the status precondition
+//        [--dry-run]          print the staging plan as JSON; no writes
+//
+// Exit codes: 0 ok | 1 failure (message on stderr).
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { findProjectRoot } = require('./lib/project-root.cjs');
+
+const ALLOWED_STATUS = { task: 'approved', bug: 'in-progress' };
+const TERMINAL_STATUS = { task: 'committed', bug: 'fixed' };
+
+function fail(msg) {
+  console.error(`commit-task: ${msg}`);
+  process.exit(1);
+}
+
+function parseArgs(argv) {
+  const opts = { also: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '--task': opts.entityKind = 'task'; opts.recordId = argv[++i]; break;
+      case '--bug': opts.entityKind = 'bug'; opts.recordId = argv[++i]; break;
+      case '--message': opts.message = argv[++i]; break;
+      case '--trailer': opts.trailer = argv[++i]; break;
+      case '--also': opts.also.push(argv[++i]); break;
+      case '--skip-gate': opts.skipGate = true; break;
+      case '--force': opts.force = true; break;
+      case '--dry-run': opts.dryRun = true; break;
+      default: fail(`unknown argument: ${a}`);
+    }
+  }
+  if (!opts.entityKind || !opts.recordId) {
+    fail('usage: commit-task.cjs --task <id> | --bug <id> --message <msg> [--trailer <line>] [--also <path>]... [--skip-gate] [--force] [--dry-run]');
+  }
+  if (!opts.dryRun && (!opts.message || !opts.message.trim())) {
+    fail('--message is required (the commit message is the only input the agent supplies)');
+  }
+  return opts;
+}
+
+function git(root, args, { allowFail = false } = {}) {
+  const r = spawnSync('git', args, { cwd: root, encoding: 'utf8' });
+  if (r.status !== 0 && !allowFail) {
+    fail(`git ${args.join(' ')} failed: ${(r.stderr || r.stdout || '').trim()}`);
+  }
+  return r;
+}
+
+// Resolve a repo-relative path and reject anything escaping the project root.
+function insideRoot(root, p) {
+  const abs = path.resolve(root, p);
+  const rel = path.relative(root, abs);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  return rel;
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const root = findProjectRoot();
+  if (!root) fail('no .forge/config.json found above the current directory');
+
+  // 1. Record read (store facade — never raw .forge/store writes).
+  const store = require('./store.cjs');
+  const record = opts.entityKind === 'task' ? store.getTask(opts.recordId) : store.getBug(opts.recordId);
+  if (!record) fail(`${opts.entityKind} ${opts.recordId} not found in the store`);
+
+  // 2. Status precondition (deterministic version of the Pipeline Step Guard).
+  const allowed = ALLOWED_STATUS[opts.entityKind];
+  if (record.status !== allowed && !opts.force) {
+    const hint = opts.entityKind === 'task' ? "; /forge:approve must complete first" : '';
+    fail(`× ${opts.recordId} is in state '${record.status}' — commit requires '${allowed}'${hint}. Use --force to bypass (operator-gated, user-invoked re-runs only).`);
+  }
+
+  // 3. Preflight gate (skippable when the orchestrator already ran it).
+  if (!opts.skipGate) {
+    const gate = spawnSync(process.execPath,
+      [path.join(__dirname, 'preflight-gate.cjs'), '--phase', 'commit', `--${opts.entityKind}`, opts.recordId],
+      { cwd: root, encoding: 'utf8' });
+    if (gate.status !== 0) {
+      fail(`preflight gate failed (exit ${gate.status}):\n${(gate.stderr || gate.stdout || '').trim()}`);
+    }
+  }
+
+  // 4. Staging set: artifact dir + implementation provenance + --also extras.
+  const stage = [];
+  const warnings = [];
+  if (record.path) {
+    const rel = insideRoot(root, record.path);
+    if (rel && fs.existsSync(path.join(root, rel))) stage.push(rel);
+    else warnings.push(`artifact dir missing on disk: ${record.path}`);
+  }
+  const provenance = record.summaries?.implementation?.files_changed;
+  if (Array.isArray(provenance) && provenance.length > 0) {
+    for (const p of provenance) {
+      const rel = insideRoot(root, p);
+      if (rel === null) { warnings.push(`provenance path outside the project root, skipped: ${p}`); continue; }
+      if (!fs.existsSync(path.join(root, rel))) {
+        // Deleted files are legitimate changes — git add stages deletions of
+        // tracked paths; only warn when git knows nothing about the path.
+        const known = git(root, ['ls-files', '--error-unmatch', '--', rel], { allowFail: true });
+        if (known.status !== 0) { warnings.push(`provenance path not found (skipped): ${p}`); continue; }
+      }
+      stage.push(rel);
+    }
+  } else {
+    warnings.push('no files_changed provenance in summaries.implementation — staging the artifact dir only. Pass source files via --also if the task changed code.');
+  }
+  for (const p of opts.also) {
+    const rel = insideRoot(root, p);
+    if (rel === null) fail(`--also path outside the project root: ${p}`);
+    stage.push(rel);
+  }
+  let stageSet = [...new Set(stage)];
+  if (stageSet.length === 0) fail('nothing to stage — no artifact dir, no provenance, no --also paths');
+
+  // Pre-filter gitignored paths (live-run finding, forge-engineering#40):
+  // `git add` of the whole set is all-or-nothing — one ignored path aborts
+  // everything. check-ignore each path; warn-skip the ignored ones.
+  const ignored = [];
+  for (const rel of stageSet) {
+    const ci = git(root, ['check-ignore', '-q', '--', rel], { allowFail: true });
+    if (ci.status === 0) ignored.push(rel);
+  }
+  if (ignored.length > 0) {
+    warnings.push(`gitignored path(s) skipped from the staging set: ${ignored.join(', ')} — track them or stage explicitly with git add -f outside this tool.`);
+    stageSet = stageSet.filter((p) => !ignored.includes(p));
+  }
+
+  for (const w of warnings) console.error(`commit-task: warning: ${w}`);
+
+  if (opts.dryRun) {
+    process.stdout.write(JSON.stringify({ dryRun: true, entityKind: opts.entityKind, recordId: opts.recordId, stage: stageSet }, null, 2) + '\n');
+    return;
+  }
+
+  // 5. Commit-boundary guard: a pre-populated index means someone else's
+  //    changes would be swept into this commit. Abort loudly (Iron Law:
+  //    the commit boundary mirrors the task boundary).
+  const preStaged = git(root, ['diff', '--cached', '--name-only']).stdout.trim();
+  if (preStaged) {
+    fail(`index already has staged changes — refusing to sweep them into the ${opts.recordId} commit:\n${preStaged}\nUnstage them (git reset) or commit them separately, then re-run.`);
+  }
+
+  // 6. Terminal status transition helper — through store-cli (single source
+  //    of truth for transition legality — never reimplemented here).
+  const target = TERMINAL_STATUS[opts.entityKind];
+  const transition = (context) => {
+    const updArgs = [path.join(__dirname, 'store-cli.cjs'), 'update-status', opts.entityKind, opts.recordId, 'status', target];
+    if (opts.force) updArgs.push('--force'); // --force bypasses the transition map too (user-invoked re-runs)
+    const upd = spawnSync(process.execPath, updArgs, { cwd: root, encoding: 'utf8' });
+    if (upd.status !== 0) {
+      fail(`${context} but status transition to '${target}' failed:\n${(upd.stderr || upd.stdout || '').trim()}`);
+    }
+  };
+
+  // 7. Stage exactly the derived set. A clean staging set is a legitimate
+  //    terminal state (e.g. a bug whose fix is already at HEAD): no commit,
+  //    but the record is still sealed (live-run finding, forge-engineering#40).
+  const noop = (why) => {
+    console.error(`commit-task: ${why} — nothing to commit; sealing the record without a commit.`);
+    transition('no-op commit');
+    process.stdout.write(JSON.stringify(
+      { ok: true, committed: false, reason: 'nothing-to-commit', skippedIgnored: ignored, status: target }, null, 2) + '\n');
+  };
+  if (stageSet.length === 0) {
+    noop('entire staging set is gitignored');
+    return;
+  }
+  git(root, ['add', '--', ...stageSet]);
+  const staged = git(root, ['diff', '--cached', '--name-only']).stdout.trim().split('\n').filter(Boolean);
+  if (staged.length === 0) {
+    noop('working tree already clean for the staging set');
+    return;
+  }
+
+  // 8. Commit. Message comes from the agent; the optional trailer is appended
+  //    after a blank line per git convention.
+  const message = opts.trailer ? `${opts.message.trim()}\n\n${opts.trailer.trim()}\n` : `${opts.message.trim()}\n`;
+  git(root, ['commit', '-m', message]);
+  const sha = git(root, ['rev-parse', 'HEAD']).stdout.trim();
+
+  transition(`commit ${sha} created`);
+
+  process.stdout.write(JSON.stringify({ ok: true, committed: true, sha, staged, status: target }, null, 2) + '\n');
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(`commit-task: ${err.message}`);
+  process.exit(1);
+}

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

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+'use strict';
+
+// forge-preflight.cjs — FORGE-S27-T01 (item A1).
+//
+// Bundles the deterministic pre-dispatch glue the LLM orchestrator currently
+// hand-runs turn-by-turn — FORGE_ROOT resolution, config reconciliation,
+// generation-manifest state, calibration-baseline freshness, MASTER_INDEX
+// hashing, structure check, run timestamp — into ONE compact JSON blob,
+// emitted once. The orchestrator reads this single blob instead of issuing
+// ~20 separate round-trips before the first phase dispatch.
+//
+// Design: a PURE AGGREGATOR. It composes the existing deterministic tools
+// (generation-manifest.cjs's hashContent, check-structure.cjs's
+// checkNamespaces/validateManifest) and reads config — it does NOT reimplement
+// their logic, so there is one source of truth per concern.
+//
+// Contract:
+//   - Reads and checks only by default; no implicit side effects (idempotent).
+//   - Fast-fail-safe: any probed-concern failure is captured into warnings[]
+//     and sets ok:false; the tool NEVER throws uncaught and never half-writes
+//     state. It always emits a parseable JSON blob on stdout.
+//   - Output is keyed for a freshness/idempotency guard via masterIndexHash +
+//     configMtime so callers can skip recompute when the blob is current.
+//
+// Usage:
+//   node forge-preflight.cjs [--sprint <id>] [--task <id>] [--bug <id>]
+//                            [--path <project-root>]
+
+// Fast-fail-safe: an uncaught error must still surface as a blob, not a stack
+// trace. We register a last-resort handler that emits ok:false and exits 0
+// (the orchestrator branches on blob.ok, not on the exit code).
+process.on('uncaughtException', (err) => {
+  try {
+    process.stdout.write(JSON.stringify({
+      ok: false,
+      forgeRoot: null,
+      masterIndexHash: null,
+      generatedAt: new Date().toISOString(),
+      warnings: [`uncaught: ${err && err.message ? err.message : String(err)}`],
+    }) + '\n');
+  } catch (_) { /* nothing more we can do */ }
+  process.exit(0);
+});
+
+const fs = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Arg parsing (tolerant — unknown flags are ignored, not fatal).
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+  const out = { projectRoot: process.cwd() };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--sprint' && argv[i + 1]) { out.sprintId = argv[++i]; }
+    else if (a === '--task' && argv[i + 1]) { out.taskId = argv[++i]; }
+    else if (a === '--bug' && argv[i + 1]) { out.bugId = argv[++i]; }
+    else if (a === '--path' && argv[i + 1]) { out.projectRoot = path.resolve(argv[++i]); }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Pure helpers. Each concern is wrapped so a single failure becomes a warning
+// rather than aborting the whole preflight.
+// ---------------------------------------------------------------------------
+
+// Compose generation-manifest.cjs's hashing primitive — single source of truth
+// for content hashing across the plugin.
+function loadHashContent(forgeRoot) {
+  try {
+    const mod = require(path.join(forgeRoot, 'tools', 'generation-manifest.cjs'));
+    if (mod && typeof mod.hashContent === 'function') return mod.hashContent;
+  } catch (_) { /* fall through to local */ }
+  // Fallback that matches generation-manifest's algorithm (sha256 hex) so the
+  // blob is still useful if the module cannot be required.
+  const crypto = require('crypto');
+  return (content) => crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+}
+
+function readConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.forge', 'config.json');
+  const stat = fs.statSync(configPath); // throws if missing -> caught by caller
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const config = JSON.parse(raw); // throws on malformed -> caught by caller
+  return { config, configMtime: stat.mtimeMs };
+}
+
+function hashMasterIndex(projectRoot, config, hashContent) {
+  const engineering = (config.paths && config.paths.engineering) || 'engineering';
+  const indexPath = path.join(projectRoot, engineering, 'MASTER_INDEX.md');
+  if (!fs.existsSync(indexPath)) return null;
+  return hashContent(fs.readFileSync(indexPath, 'utf8'));
+}
+
+// calibrationFresh carries ACTIONABLE detail, not a bare boolean: when stale,
+// it names the remedy and the reason so the orchestrator can act on the blob
+// without re-deriving the signal.
+function assessCalibration(config, masterIndexHash) {
+  const baseline = config.calibrationBaseline;
+  if (!baseline) {
+    return { fresh: false, suggest: '/forge:calibrate', reason: 'no calibrationBaseline in config' };
+  }
+  if (masterIndexHash && baseline.masterIndexHash && baseline.masterIndexHash !== masterIndexHash) {
+    return { fresh: false, suggest: '/forge:calibrate', reason: 'masterIndexHash drift since last calibration' };
+  }
+  return { fresh: true, lastCalibrated: baseline.lastCalibrated || null };
+}
+
+// Compose check-structure.cjs's namespace check. Returns actionable detail.
+function assessStructure(forgeRoot, projectRoot, warnings) {
+  try {
+    const cs = require(path.join(forgeRoot, 'tools', 'check-structure.cjs'));
+    const manifestPath = path.join(forgeRoot, 'schemas', 'structure-manifest.json');
+    if (typeof cs.checkNamespaces !== 'function' || !fs.existsSync(manifestPath)) {
+      return { ok: null, reason: 'structure check unavailable' };
+    }
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const result = cs.checkNamespaces(manifest, projectRoot, {});
+    // checkNamespaces returns a structured result; treat any missing-file
+    // namespace as "not ok" but non-fatal (a warning, not a throw).
+    const allOk = result && (result.ok === true || result.allPresent === true ||
+      (Array.isArray(result.namespaces) && result.namespaces.every((n) => n.missing === 0 || (n.missing && n.missing.length === 0))));
+    if (!allOk) warnings.push('structure check reported missing namespace files');
+    return { ok: !!allOk };
+  } catch (err) {
+    warnings.push(`structure check error: ${err.message}`);
+    return { ok: null, reason: err.message };
+  }
+}
+
+// generation-manifest status — actionable manifest state.
+function assessManifest(forgeRoot, projectRoot, warnings) {
+  const manifestPath = path.join(projectRoot, '.forge', 'schemas', 'generation-manifest.json');
+  // The manifest lives in the generated instance; absence is informational,
+  // not an error (e.g. fresh project or fast-mode).
+  if (!fs.existsSync(manifestPath)) {
+    return { present: false, reason: 'no generation-manifest in instance (informational)' };
+  }
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const count = manifest.files ? Object.keys(manifest.files).length : 0;
+    return { present: true, trackedFiles: count };
+  } catch (err) {
+    warnings.push(`generation-manifest parse error: ${err.message}`);
+    return { present: true, error: err.message };
+  }
+}
+
+// Resolve FORGE_ROOT via forgeRef-based cache scan — mirrors manage-config.cjs
+// Priority 2 logic (FORGE-S29-T03). paths.forgeRoot is deprecated and no longer read.
+function resolveForgeRootFromConfig(config) {
+  const forgeRef = config.paths && config.paths.forgeRef;
+  if (!forgeRef) return null;
+  const homeDir = require('os').homedir();
+  const candidates = [
+    path.join(homeDir, '.claude', 'plugins', 'cache', 'forge', 'forge', forgeRef),
+    path.join(homeDir, '.claude', 'plugins', 'marketplaces', 'skillforge', 'forge', 'forge', forgeRef),
+  ];
+  for (const c of candidates) {
+    try {
+      const pluginJsonPath = path.join(c, '.claude-plugin', 'plugin.json');
+      if (fs.existsSync(pluginJsonPath)) {
+        const manifest = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8'));
+        if (manifest.version === forgeRef) return c;
+      }
+    } catch (_) { /* try next candidate */ }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main aggregation.
+// ---------------------------------------------------------------------------
+function preflight(opts) {
+  const warnings = [];
+  const blob = {
+    ok: true,
+    forgeRoot: null,
+    sprintId: opts.sprintId || null,
+    configReconciled: false,
+    manifestState: null,
+    calibrationFresh: null,
+    masterIndexHash: null,
+    configMtime: null,
+    structureOk: null,
+    generatedAt: new Date().toISOString(),
+    warnings,
+  };
+
+  // 1. Config — the load-bearing input. A failure here is fatal to ok.
+  let config;
+  try {
+    const r = readConfig(opts.projectRoot);
+    config = r.config;
+    blob.configMtime = r.configMtime;
+    blob.configReconciled = true;
+  } catch (err) {
+    blob.ok = false;
+    warnings.push(`config unreadable: ${err.message}`);
+    return blob; // fast-fail-safe: cannot proceed without config, but no throw
+  }
+
+  // 2. FORGE_ROOT resolution — mirrors manage-config.cjs Priority 2 (forgeRef cache scan).
+  // paths.forgeRoot is deprecated (FORGE-S29-T03); we resolve via forgeRef only.
+  // blob.forgeRoot is still emitted for backward-compatible telemetry.
+  blob.forgeRoot = resolveForgeRootFromConfig(config);
+  if (!blob.forgeRoot) {
+    const forgeRef = (config.paths && config.paths.forgeRef) || null;
+    const hint = forgeRef
+      ? `Cannot resolve Forge plugin root from forgeRef "${forgeRef}" — run /forge:update to refresh.`
+      : 'paths.forgeRef missing from config — cannot resolve Forge plugin root.';
+    blob.ok = false;
+    warnings.push(hint);
+    return blob;
+  }
+
+  const hashContent = loadHashContent(blob.forgeRoot);
+
+  // 3. MASTER_INDEX hash (freshness key + calibration input).
+  try {
+    blob.masterIndexHash = hashMasterIndex(opts.projectRoot, config, hashContent);
+    if (!blob.masterIndexHash) warnings.push('MASTER_INDEX.md absent — hash null');
+  } catch (err) {
+    warnings.push(`master-index hash error: ${err.message}`);
+  }
+
+  // 4. Calibration freshness (actionable).
+  try {
+    blob.calibrationFresh = assessCalibration(config, blob.masterIndexHash);
+  } catch (err) {
+    warnings.push(`calibration assessment error: ${err.message}`);
+  }
+
+  // 5. Manifest state (actionable).
+  try {
+    blob.manifestState = assessManifest(blob.forgeRoot, opts.projectRoot, warnings);
+  } catch (err) {
+    warnings.push(`manifest assessment error: ${err.message}`);
+  }
+
+  // 6. Structure check.
+  try {
+    const s = assessStructure(blob.forgeRoot, opts.projectRoot, warnings);
+    blob.structureOk = s.ok;
+  } catch (err) {
+    warnings.push(`structure assessment error: ${err.message}`);
+  }
+
+  // Aggregate verdict: ok stays true for soft/informational warnings (absent
+  // master index, missing optional manifest); it is only flipped false above
+  // for hard failures (no config / no forgeRoot). This keeps the orchestrator
+  // running on a healthy-but-fresh project while still surfacing advisories.
+  return blob;
+}
+
+// ---------------------------------------------------------------------------
+// CLI entry.
+// ---------------------------------------------------------------------------
+if (require.main === module) {
+  const opts = parseArgs(process.argv.slice(2));
+  const blob = preflight(opts);
+  process.stdout.write(JSON.stringify(blob) + '\n');
+  process.exit(0); // exit code is always 0; callers branch on blob.ok
+}
+
+module.exports = { preflight, parseArgs, assessCalibration };

package/dist/forge-payload/tools/lib/paths.cjs

@@ -7,23 +7,24 @@
  * consistent across substitute-placeholders.cjs, check-structure.cjs, etc.
  *
  * Exported API:
- *   getCommandsSubdir(prefix) — returns prefix.toLowerCase()
+ *   getCommandsSubdir() — returns 'forge' (fixed namespace)
  */
 
 /**
- * Compute the commands subdirectory name from a project prefix.
+ * Commands subdirectory name under .claude/commands/.
  *
- * The canonical commands subfolder under .claude/commands/ is derived
- * from the project prefix (lowercased), NOT hardcoded as 'forge'.
+ * CLI-first redesign: the namespace is FIXED to 'forge'. Project-prefix
+ * command namespaces (/acme:*, /hello:*) are retired — every project gets
+ * the same /forge:* surface, matching what the 4ge bootstrap vendors into
+ * .claude/commands/forge/. The prefix-derived namespace existed to avoid
+ * collisions with the Forge *plugin's* own /forge:* commands; moot now
+ * that the plugin mechanism is retired.
  *
- * @param {string} prefix — project prefix (e.g. 'ACME', 'FORGE')
- * @returns {string} lowercased prefix (e.g. 'acme', 'forge')
+ * @param {string} [_prefix] — vestigial, ignored (kept for caller compat)
+ * @returns {string} always 'forge'
  */
-function getCommandsSubdir(prefix) {
-  if (typeof prefix !== 'string' || prefix.length === 0) {
-    throw new Error('paths.getCommandsSubdir: prefix must be a non-empty string');
-  }
-  return prefix.toLowerCase();
+function getCommandsSubdir(_prefix) {
+  return 'forge';
 }
 
 module.exports = { getCommandsSubdir };

package/dist/forge-payload/tools/lib/pricing.cjs

@@ -13,9 +13,15 @@
  *                              Returns number (may be 0), or null for unknown model.
  *
  * This module is a pure library — no CLI, no process.exit.
- * Published Anthropic pricing (USD/MTok → divide by 1,000,000 for per-token rate):
- *   claude-opus-4-5:   input $15.00, output $75.00, cacheRead $1.50, cacheWrite $18.75
- *   claude-opus-4-7:   input $15.00, output $75.00, cacheRead $1.50, cacheWrite $18.75
+ * Published Anthropic pricing (USD/MTok → divide by 1,000,000 for per-token rate).
+ * Verified against Anthropic support + the pi vendor model table on 2026-06-08.
+ * cacheWrite uses the 5-minute-TTL rate; Forge phases run inside the 5-min cache
+ * window, so the 5-min write rate is the one that bills (1-hour TTL is higher but
+ * not used). All Opus 4.x generations share one rate tier:
+ *   claude-opus-4-5:   input $5.00,  output $25.00, cacheRead $0.50, cacheWrite $6.25
+ *   claude-opus-4-6:   input $5.00,  output $25.00, cacheRead $0.50, cacheWrite $6.25
+ *   claude-opus-4-7:   input $5.00,  output $25.00, cacheRead $0.50, cacheWrite $6.25
+ *   claude-opus-4-8:   input $5.00,  output $25.00, cacheRead $0.50, cacheWrite $6.25
  *   claude-sonnet-4-5: input $3.00,  output $15.00, cacheRead $0.30, cacheWrite $3.75
  *   claude-sonnet-4-6: input $3.00,  output $15.00, cacheRead $0.30, cacheWrite $3.75
  *   claude-haiku-3-5:  input $0.80,  output $4.00,  cacheRead $0.08, cacheWrite $1.00
@@ -24,16 +30,28 @@
 // All rates in USD per token (divide MTok rate by 1,000,000)
 const MODEL_PRICING = Object.freeze({
   'claude-opus-4-5': {
-    input:      15.00  / 1_000_000,
-    output:     75.00  / 1_000_000,
-    cacheRead:   1.50  / 1_000_000,
-    cacheWrite: 18.75  / 1_000_000,
+    input:       5.00  / 1_000_000,
+    output:     25.00  / 1_000_000,
+    cacheRead:   0.50  / 1_000_000,
+    cacheWrite:  6.25  / 1_000_000,
+  },
+  'claude-opus-4-6': {
+    input:       5.00  / 1_000_000,
+    output:     25.00  / 1_000_000,
+    cacheRead:   0.50  / 1_000_000,
+    cacheWrite:  6.25  / 1_000_000,
   },
   'claude-opus-4-7': {
-    input:      15.00  / 1_000_000,
-    output:     75.00  / 1_000_000,
-    cacheRead:   1.50  / 1_000_000,
-    cacheWrite: 18.75  / 1_000_000,
+    input:       5.00  / 1_000_000,
+    output:     25.00  / 1_000_000,
+    cacheRead:   0.50  / 1_000_000,
+    cacheWrite:  6.25  / 1_000_000,
+  },
+  'claude-opus-4-8': {
+    input:       5.00  / 1_000_000,
+    output:     25.00  / 1_000_000,
+    cacheRead:   0.50  / 1_000_000,
+    cacheWrite:  6.25  / 1_000_000,
   },
   'claude-sonnet-4-5': {
     input:       3.00  / 1_000_000,
@@ -63,7 +81,9 @@ const MODEL_PRICING = Object.freeze({
  */
 const MODEL_FAMILIES = [
   // Opus family
+  'claude-opus-4-8',
   'claude-opus-4-7',
+  'claude-opus-4-6',
   'claude-opus-4-5',
   // Sonnet family
   'claude-sonnet-4-6',

package/dist/forge-payload/tools/query-logger.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+// query-logger.cjs — PostToolUse hook: logs store-cli query invocations
+// Reads TOOL_INPUT env var, appends entry to .forge/store/query-log.jsonl
+
+const fs = require('fs');
+const path = require('path');
+
+try {
+  const toolInput = process.env.TOOL_INPUT || '';
+  if (!/store-cli(?:\.cjs)?["']?\s+query/.test(toolInput)) process.exit(0);
+
+  const logEntry = {
+    timestamp: new Date().toISOString(),
+    tool: 'store-cli',
+    command: 'query',
+    input: toolInput.substring(0, 500),
+  };
+
+  let storeRel = '.forge/store';
+  try {
+    const cfgPath = path.join(process.cwd(), '.forge', 'config.json');
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+      if (cfg.paths?.store) storeRel = cfg.paths.store;
+    }
+  } catch {}
+
+  const logPath = path.join(process.cwd(), storeRel, 'query-log.jsonl');
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, JSON.stringify(logEntry) + '\n');
+} catch {
+  // Silent fail — hooks must not crash the session
+}

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

@@ -77,7 +77,12 @@ const PHASE_SUMMARY_SCHEMA = {
     verdict:     { type: 'string', enum: ['approved', 'revision', 'n/a'] },
     written_at:  { type: 'string' },
     artifact_ref:{ type: 'string' },
-    route:       { type: 'string', enum: ['A', 'B'] }
+    route:       { type: 'string', enum: ['A', 'B'] },
+    // forge-engineering#40: implement-phase file provenance. The implement
+    // workflow records the repo-relative paths it created/modified;
+    // commit-task.cjs derives its staging set from this list instead of the
+    // LLM re-deriving the change surface from git each run.
+    files_changed: { type: 'array', items: { type: 'string', maxLength: 300 }, maxItems: 100 }
   },
   additionalProperties: false
 };

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

@@ -9,7 +9,7 @@
  * output to the appropriate output directories.
  *
  * Output path mapping (--target claude-code, default):
- *   base-pack/commands/  → <outRoot>/.claude/commands/<prefix>/
+ *   base-pack/commands/  → <outRoot>/.claude/commands/forge/  (fixed namespace)
  *   base-pack/personas/  → <outRoot>/.forge/personas/
  *   base-pack/skills/    → <outRoot>/.forge/skills/
  *   base-pack/workflows/ → <outRoot>/.forge/workflows/
@@ -116,8 +116,8 @@ const RUNTIME_PASSTHROUGH_KEYS = new Set([
 
 /**
  * Maps a base-pack subdirectory name to an output directory path relative to
- * the project root. The 'commands' entry is computed dynamically from the
- * project prefix via getCommandsSubdir() — see walkBasePack.
+ * the project root. The 'commands' entry is the fixed 'forge' namespace via
+ * getCommandsSubdir() — see walkBasePack.
  */
 const SUBDIR_OUTPUT_MAP = {
   personas:       path.join('.forge', 'personas'),
@@ -392,9 +392,8 @@ function renderDeploymentTable(envs) {
 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
-  const prefix = map.get('PREFIX') || '';
-  const commandsSubdir = prefix ? getCommandsSubdir(prefix) : 'forge';
+  // Commands namespace is fixed to 'forge' (CLI-first redesign)
+  const commandsSubdir = getCommandsSubdir();
 
   // Sorted readdir for deterministic idempotent output (Advisory Note 7)
   const topEntries = fs.readdirSync(basePack).sort();