@entelligentsia/forgecli 1.0.25 → 1.0.40

package/dist/forge-payload/schemas/payload-manifest.schema.json

@@ -0,0 +1,100 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/Entelligentsia/forge/schemas/payload-manifest.schema.json",
+  "title": "Forge Payload Manifest",
+  "description": "Declarative inventory of every artifact the Forge payload ships: source path (under forge/forge/) -> bundle path (dist/forge-payload/) -> install destination (bootstrapped project root) -> removal owner (uninstall grouping). Replaces the hand-maintained copy lists in build-payload.cjs / bootstrap.ts / uninstall.ts (FORGE-S32). The owner enum and select shape are provisional pending FORGE-S32-T03 consumer wiring.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["entries"],
+  "properties": {
+    "$schema": { "type": "string" },
+    "_doc": { "type": "string" },
+    "entries": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/entry" }
+    }
+  },
+  "definitions": {
+    "entry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["source", "bundle", "owner", "kind"],
+      "if": {
+        "properties": { "bundleOnly": { "const": true } },
+        "required": ["bundleOnly"]
+      },
+      "then": {
+        "not": { "required": ["install"] }
+      },
+      "else": {
+        "required": ["install"]
+      },
+      "properties": {
+        "source": {
+          "type": "string",
+          "description": "Repo-relative path under forge/forge/ (file or directory root)."
+        },
+        "bundle": {
+          "type": "string",
+          "description": "Destination path inside dist/forge-payload/ that build-payload.cjs emits."
+        },
+        "install": {
+          "type": "string",
+          "description": "Destination inside a bootstrapped project, relative to project root (e.g. .forge/tools/, .claude/commands/forge/). Required unless bundleOnly:true (the if/then/else contract); forbidden when bundleOnly:true."
+        },
+        "bundleOnly": {
+          "type": "boolean",
+          "description": "True when the artifact ships to dist/forge-payload/ for tool/migration-engine resolution but is NOT installed into a bootstrapped project's tree. Such entries MUST NOT declare install (enforced by the if/then/else contract and check-payload-manifest.cjs). FORGE-BUG-044."
+        },
+        "owner": {
+          "type": "string",
+          "description": "Removal owner consumed by uninstall.ts, encoding the per-subtree removal grouping.",
+          "enum": ["forge-scaffold", "claude-commands", "claude-assets", "workflows"]
+        },
+        "kind": {
+          "type": "string",
+          "enum": ["file", "dir"]
+        },
+        "synthesized": {
+          "type": "boolean",
+          "description": "True when build-payload.cjs generates this artifact rather than copying it from source (e.g. tools/package.json CJS scope marker). Source-drift checks skip the missing-source assertion for synthesized entries."
+        },
+        "select": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "Selection filter for dir entries, mirroring build-payload.cjs Pass-2 logic.",
+          "properties": {
+            "recursive": {
+              "type": "boolean",
+              "description": "When false, only top-level files are selected; subdirectories are not descended."
+            },
+            "ext": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Allowed file-name suffixes (e.g. .cjs, .schema.json)."
+            },
+            "include": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Explicit allowlist of names for curated subtrees (tools/, skills/). Curated entries are forward-checked only; unlisted siblings are NOT orphans."
+            },
+            "exclude": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Path segments or file names to skip (e.g. __tests__, README.md)."
+            },
+            "prefix": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Required file-name prefixes (e.g. discover-, wfl-, phase-)."
+            }
+          }
+        },
+        "note": {
+          "type": "string",
+          "description": "Free-text rationale, preserving the inline citation comments that today live in build-payload.cjs (FORGE-BUG-030 marker, forge-cli#25 defects, etc.)."
+        }
+      }
+    }
+  }
+}

package/dist/forge-payload/schemas/structure-manifest.json

@@ -1,6 +1,6 @@
 {
-  "version": "1.2.21",
-  "generatedAt": "2026-06-06T15:46:43.003Z",
+  "version": "1.4.11",
+  "generatedAt": "2026-06-11T06:08:57.968Z",
   "generatedByTool": "build-manifest.cjs",
   "namespaces": {
     "personas": {
@@ -109,6 +109,7 @@
       "dir": ".claude/workflows",
       "files": [
         "wfl-fix-bug.js",
+        "wfl-init.js",
         "wfl-run-sprint.js",
         "wfl-run-task.js"
       ]
@@ -125,6 +126,7 @@
         "event-sidecar.schema.json",
         "event.schema.json",
         "feature.schema.json",
+        "payload-manifest.schema.json",
         "progress-entry.schema.json",
         "project-context.schema.json",
         "project-overlay.schema.json",
@@ -142,43 +144,34 @@
         "artifact.cjs",
         "backfill-provider.cjs",
         "banners.cjs",
-        "build-base-pack.cjs",
         "build-context-pack.cjs",
-        "build-enum-catalog.cjs",
         "build-init-context.cjs",
-        "build-manifest.cjs",
         "build-overlay.cjs",
         "build-persona-pack.cjs",
-        "check-no-skipped-tests.cjs",
         "check-structure.cjs",
         "collate.cjs",
         "commit-task.cjs",
         "compression-gate.cjs",
         "delete-candidate-detector.cjs",
-        "estimate-usage.cjs",
         "forge-preflight.cjs",
         "friction-emit.cjs",
-        "gen-integrity.cjs",
         "generation-manifest.cjs",
         "judge-proposal.cjs",
         "manage-config.cjs",
         "manage-versions.cjs",
-        "migrate-slug-maxlen.cjs",
         "parse-gates.cjs",
         "postflight-gate.cjs",
         "preflight-gate.cjs",
-        "proposal-normalize.cjs",
         "query-logger.cjs",
         "queue-drain.cjs",
         "read-verdict.cjs",
         "replay-scoring.cjs",
-        "rewrite-plugin-urls.cjs",
+        "reset-plan.cjs",
         "seed-store.cjs",
         "store-cli.cjs",
         "store-query.cjs",
         "store.cjs",
         "substitute-placeholders.cjs",
-        "token-forensics.cjs",
         "validate-store.cjs",
         "verify-apply.cjs",
         "verify-integrity.cjs",

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
+}