@pareto4/pp-core 1.5.0

package/commands/pp-workstreams.md

@@ -0,0 +1,70 @@
+---
+name: pp:workstreams
+description: Manage parallel workstreams — list, create, switch, status, progress, complete, and resume
+allowed-tools:
+  - Read
+  - Bash
+requires: [new-milestone, phase, progress, resume-work]
+---
+
+# /pp:workstreams
+
+Manage parallel workstreams for concurrent milestone work.
+
+## Usage
+
+`/pp:workstreams [subcommand] [args]`
+
+### Subcommands
+
+| Command | Description |
+|---------|-------------|
+| `list` | List all workstreams with status |
+| `create <name>` | Create a new workstream |
+| `status <name>` | Detailed status for one workstream |
+| `switch <name>` | Set active workstream |
+| `progress` | Progress summary across all workstreams |
+| `complete <name>` | Archive a completed workstream |
+| `resume <name>` | Resume work in a workstream |
+
+## Step 1: Parse Subcommand
+
+Parse the user's input to determine which workstream operation to perform.
+If no subcommand given, default to `list`.
+
+## Step 2: Execute Operation
+
+### list
+Run: `gsd-tools query workstream.list --raw --cwd "$CWD"`
+Display the workstreams in a table format showing name, status, current phase, and progress.
+
+### create
+Run: `gsd-tools query workstream.create <name> --raw --cwd "$CWD"`
+After creation, display the new workstream path and suggest next steps:
+- `/pp:new-milestone --ws <name>` to set up the milestone
+
+### status
+Run: `gsd-tools query workstream.status <name> --raw --cwd "$CWD"`
+Display detailed phase breakdown and state information.
+
+### switch
+Run: `gsd-tools query workstream.set <name> --raw --cwd "$CWD"`
+Also set `GSD_WORKSTREAM` for the current session when the runtime supports it.
+If the runtime exposes a session identifier, GSD also stores the active workstream
+session-locally so concurrent sessions do not overwrite each other.
+
+### progress
+Run: `gsd-tools query workstream.progress --raw --cwd "$CWD"`
+Display a progress overview across all workstreams.
+
+### complete
+Run: `gsd-tools query workstream.complete <name> --raw --cwd "$CWD"`
+Archive the workstream to milestones/.
+
+### resume
+Set the workstream as active and suggest `/pp:resume-work --ws <name>`.
+
+## Step 3: Display Results
+
+Format the JSON output from gsd-tools query into a human-readable display.
+Include the `${GSD_WS}` flag in any routing suggestions.

package/gemini-extension.json

@@ -0,0 +1,6 @@
+{
+  "name": "pp-core",
+  "version": "1.5.0",
+  "description": "PP Core — a meta-prompting, context engineering, and spec-driven development system for AI coding agents. Loads pp-core's operating context into every Gemini CLI session.",
+  "contextFileName": "GEMINI.md"
+}

package/hooks/dist/lib/git-cmd.js

@@ -0,0 +1,150 @@
+'use strict';
+
+/**
+ * git-cmd.js — token-walk git command classifier.
+ *
+ * Determines whether a shell command string invokes a specific git
+ * subcommand. Handles the four forms that a naive `^git\s+commit` regex
+ * misses:
+ *
+ *   bare:         git commit -m "..."                 ✓
+ *   -C path:      git -C /some/path commit -m "..."   ✓ (missed by regex)
+ *   env-prefix:   GIT_AUTHOR_NAME=x git commit "..."  ✓ (missed by regex)
+ *   full-path:    /usr/bin/git commit -m "..."         ✓ (missed by regex)
+ *
+ * This module is the single source of truth for git-commit detection so all
+ * hooks that need to gate on git commits share one implementation.
+ *
+ * Exported by the hooks/lib/ directory — require via a path relative to the
+ * hook's own __dirname:
+ *
+ *   const { isGitSubcommand } = require(path.join(__dirname, 'lib', 'git-cmd.js'));
+ */
+
+const path = require('path');
+
+/**
+ * Git global options that take a following argument.
+ * These must be consumed as (option, argument) pairs when walking tokens.
+ */
+const ARGUMENT_TAKING_FLAGS = new Set([
+  '-C',                // working directory
+  '--git-dir',         // path to git repository
+  '--work-tree',       // path to working tree
+  '--namespace',       // git namespace
+  '--super-prefix',    // superproject-relative prefix
+  '--exec-path',       // path to core git programs (when given an arg)
+  '--html-path',
+  '--man-path',
+  '--info-path',
+  '--list-cmds',
+]);
+
+/**
+ * Git global flags that consume no extra argument.
+ */
+const BOOLEAN_FLAGS = new Set([
+  '-p', '--paginate', '--no-pager',
+  '--no-replace-objects', '--bare',
+  '--literal-pathspecs', '--glob-pathspecs', '--noglob-pathspecs',
+  '--icase-pathspecs', '--no-optional-locks',
+  '-P', '--no-lazy-fetch',
+  '--version', '--help',
+]);
+
+/**
+ * Tokenize a shell command string.
+ * Handles single-quoted strings, double-quoted strings, and unquoted tokens.
+ * Does NOT perform variable expansion or brace expansion.
+ *
+ * @param {string} cmd
+ * @returns {string[]}
+ */
+function tokenize(cmd) {
+  const tokens = [];
+  let i = 0;
+  const len = cmd.length;
+
+  while (i < len) {
+    // Skip whitespace
+    while (i < len && /\s/.test(cmd[i])) i++;
+    if (i >= len) break;
+
+    let token = '';
+    while (i < len && !/\s/.test(cmd[i])) {
+      if (cmd[i] === "'") {
+        // Single-quoted string: take everything until closing '
+        i++;
+        while (i < len && cmd[i] !== "'") token += cmd[i++];
+        if (i < len) i++; // consume closing '
+      } else if (cmd[i] === '"') {
+        // Double-quoted string: take everything until closing " (no escape handling)
+        i++;
+        while (i < len && cmd[i] !== '"') token += cmd[i++];
+        if (i < len) i++; // consume closing "
+      } else {
+        token += cmd[i++];
+      }
+    }
+    if (token) tokens.push(token);
+  }
+
+  return tokens;
+}
+
+/**
+ * Return true if `cmd` invokes the git subcommand `sub`.
+ *
+ * @param {string} cmd  - Full shell command string (may include env vars, full paths)
+ * @param {string} sub  - Subcommand to test for, e.g. 'commit'
+ * @returns {boolean}
+ */
+function isGitSubcommand(cmd, sub) {
+  if (!cmd || !sub) return false;
+
+  const tokens = tokenize(cmd);
+  let i = 0;
+
+  // Phase 1: skip leading VAR=VALUE environment assignments
+  while (i < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[i])) {
+    i++;
+  }
+
+  // Phase 2: the next token must be the git executable
+  if (i >= tokens.length) return false;
+  const gitToken = tokens[i++];
+  if (path.basename(gitToken) !== 'git') return false;
+
+  // Phase 3: consume git global options
+  while (i < tokens.length) {
+    const t = tokens[i];
+
+    // --flag=value form for argument-taking flags
+    const eqIdx = t.indexOf('=');
+    const flagName = eqIdx !== -1 ? t.slice(0, eqIdx) : t;
+    if (ARGUMENT_TAKING_FLAGS.has(flagName)) {
+      if (eqIdx !== -1) {
+        // consumed as one token: --git-dir=.git
+        i++;
+      } else {
+        // consumed as two tokens: -C /path
+        i += 2;
+      }
+      continue;
+    }
+
+    if (BOOLEAN_FLAGS.has(t)) {
+      i++;
+      continue;
+    }
+
+    // Not a global option — this is the subcommand
+    break;
+  }
+
+  // Phase 4: check the subcommand
+  if (i >= tokens.length) return false;
+  return tokens[i] === sub;
+}
+
+module.exports = { isGitSubcommand, tokenize };

package/hooks/dist/lib/pp-graphify-rebuild.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# gsd-graphify-rebuild.sh — detached rebuild runner for hooks/gsd-graphify-update.sh.
+#
+# Usage:
+#   gsd-graphify-rebuild.sh <STATUS_FILE> <LOCK_FILE> <HEAD_SHA> <MS_START> <GRAPHIFY_BIN>
+#
+# Writes its own PID into LOCK_FILE on start, removes LOCK_FILE on exit (any cause),
+# runs `graphify update .` from the project root (cwd inherited from caller), copies
+# the produced graphify-out/* into .planning/graphs/, and rewrites STATUS_FILE to
+# reflect the final status ("ok" if graphify exited 0, "failed" otherwise).
+#
+# Designed to be invoked via `setsid ... &` so it is reparented away from the hook
+# caller and never blocks the user-facing tool call.
+
+set -uo pipefail
+
+STATUS_FILE="${1:?STATUS_FILE required}"
+LOCK_FILE="${2:?LOCK_FILE required}"
+HEAD_SHA="${3:?HEAD_SHA required}"
+MS_START="${4:?MS_START required}"
+GRAPHIFY_BIN="${5:?GRAPHIFY_BIN required}"
+
+# Atomic-ish lock acquire: write our PID and trap cleanup
+echo "$$" > "$LOCK_FILE"
+trap 'rm -f "$LOCK_FILE"' EXIT
+
+"$GRAPHIFY_BIN" update . >/dev/null 2>&1
+EXIT_CODE=$?
+
+# Copy outputs only on success — failure path preserves the prior valid graph.
+if [ "$EXIT_CODE" -eq 0 ] && [ -f graphify-out/graph.json ]; then
+  cp graphify-out/graph.json .planning/graphs/graph.json
+  cp graphify-out/graph.html .planning/graphs/graph.html 2>/dev/null || true
+  cp graphify-out/GRAPH_REPORT.md .planning/graphs/GRAPH_REPORT.md 2>/dev/null || true
+  cp .planning/graphs/graph.json .planning/graphs/.last-build-snapshot.json 2>/dev/null || true
+fi
+
+# Compute duration in ms
+MS_END=$(node -e 'process.stdout.write(String(Date.now()))' 2>/dev/null || echo "$MS_START")
+DURATION=$((MS_END - MS_START))
+
+STATUS_NAME="ok"
+[ "$EXIT_CODE" -eq 0 ] || STATUS_NAME="failed"
+
+TS_END=$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "")
+
+# Write the final status file. Use Node for safe JSON encoding.
+GSD_STATUS_TS="$TS_END" \
+GSD_STATUS_NAME="$STATUS_NAME" \
+GSD_EXIT_CODE="$EXIT_CODE" \
+GSD_DURATION="$DURATION" \
+GSD_HEAD_SHA="$HEAD_SHA" \
+GSD_STATUS_FILE="$STATUS_FILE" \
+node -e '
+  const fs = require("node:fs");
+  const status = {
+    ts: process.env.GSD_STATUS_TS,
+    status: process.env.GSD_STATUS_NAME,
+    exit_code: parseInt(process.env.GSD_EXIT_CODE, 10),
+    duration_ms: parseInt(process.env.GSD_DURATION, 10),
+    head_at_build: process.env.GSD_HEAD_SHA,
+    graphify_version: null,
+  };
+  fs.writeFileSync(process.env.GSD_STATUS_FILE, JSON.stringify(status, null, 2) + "\n");
+' 2>/dev/null || true

package/hooks/dist/managed-hooks-registry.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Authoritative list of PP-managed hook files.
+ *
+ * Extracted from the worker script into a shared CJS module so that:
+ *  1. pp-check-update-worker.js can require() it directly (no source-level
+ *     duplication).
+ *  2. Tests can assert against the exported array instead of regex-parsing
+ *     the worker source (retiring the pending-migration-to-typed-ir token
+ *     on managed-hooks.test.cjs and orphaned-hooks.test.cjs, per #455).
+ *
+ * These are the files PP ships into ~/.claude/hooks/ (or equivalent) and
+ * checks for staleness after an update. Orphaned files from removed features
+ * (e.g., pp-intel-*.js) must NOT be listed here — that would cause permanent
+ * stale warnings for users who haven't cleaned up manually (#1750).
+ */
+const MANAGED_HOOKS = [
+  'pp-check-update-worker.js',
+  'pp-check-update.js',
+  'pp-config-reload.js',
+  'pp-context-monitor.js',
+  'pp-cursor-post-tool.js',
+  'pp-cursor-session-start.js',
+  'pp-ensure-canonical-path.js',
+  'pp-graphify-update.sh',
+  'pp-phase-boundary.sh',
+  'pp-prompt-guard.js',
+  'pp-read-guard.js',
+  'pp-read-injection-scanner.js',
+  'pp-session-state.sh',
+  'pp-statusline.js',
+  'pp-update-banner.js',
+  'pp-validate-commit.sh',
+  'pp-workflow-guard.js',
+  'pp-worktree-path-guard.js',
+];
+
+module.exports = { MANAGED_HOOKS };

package/hooks/dist/pp-check-update-worker.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// pp-hook-version: {{PP_VERSION}}
+// Background worker spawned by gsd-check-update.js (SessionStart hook).
+// Checks for GSD updates and stale hooks, writes result to cache file.
+// Receives paths via environment variables set by the parent hook.
+//
+// Using a separate file (rather than node -e '<inline code>') avoids the
+// template-literal regex-escaping problem: regex source is plain JS here.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { isSemverNewer } = require('../pp-core/bin/lib/semver-compare.cjs');
+// Latest-version lookup is delegated to the single deterministic adapter
+// (#498). checkLatestVersion() owns the npm-view call, the timeout/semver
+// policy, and the package name — sourced from the baked Package Identity seam.
+// The previous `require('../package.json').name` (#378) resolved to undefined
+// in the installed tree (only a {"type":"commonjs"} marker ships), so the
+// background check never reported updates.
+const { checkLatestVersion } = require('../gsd-core/bin/check-latest-version.cjs');
+const { PACKAGE_NAME } = require('../pp-core/bin/lib/package-identity.cjs');
+// Authoritative list of managed hooks — shared with tests to retire source-grep
+// assertions (pending-migration-to-typed-ir [#455]).
+// NOTE: managed-hooks-registry.cjs must be in HOOKS_TO_COPY (scripts/build-hooks.js)
+// so it is present in hooks/dist/ and ships to the installed runtime hooks/ dir.
+// If it is missing (e.g., installed from an older dist), catch and degrade gracefully
+// so the worker always proceeds to compute and write the result cache record.
+let MANAGED_HOOKS = [];
+try {
+  ({ MANAGED_HOOKS } = require('./managed-hooks-registry.cjs'));
+} catch (e) {
+  // Module not found in installed runtime — stale-hook detection degrades to
+  // no-op (empty list means no hooks are checked for staleness). The worker
+  // still runs and writes package_name / installed / latest / update_available.
+}
+
+const cacheFile = process.env.GSD_CACHE_FILE;
+const projectVersionFile = process.env.GSD_PROJECT_VERSION_FILE;
+const globalVersionFile = process.env.GSD_GLOBAL_VERSION_FILE;
+
+// Check project directory first (local install), then global
+let installed = '0.0.0';
+let configDir = '';
+try {
+  if (fs.existsSync(projectVersionFile)) {
+    installed = fs.readFileSync(projectVersionFile, 'utf8').trim();
+    configDir = path.dirname(path.dirname(projectVersionFile));
+  } else if (fs.existsSync(globalVersionFile)) {
+    installed = fs.readFileSync(globalVersionFile, 'utf8').trim();
+    configDir = path.dirname(path.dirname(globalVersionFile));
+  }
+} catch (e) {}
+
+// Check for stale hooks — compare hook version headers against installed VERSION
+// Hooks are installed at configDir/hooks/ (e.g. ~/.claude/hooks/) (#1421)
+// Only check hooks that GSD currently ships — orphaned files from removed features
+// (e.g., gsd-intel-*.js) must be ignored to avoid permanent stale warnings (#1750)
+// MANAGED_HOOKS is imported from ./managed-hooks-registry.cjs above.
+
+let staleHooks = [];
+if (configDir) {
+  const hooksDir = path.join(configDir, 'hooks');
+  try {
+    if (fs.existsSync(hooksDir)) {
+      const hookFiles = fs.readdirSync(hooksDir).filter(f => MANAGED_HOOKS.includes(f));
+      for (const hookFile of hookFiles) {
+        try {
+          const content = fs.readFileSync(path.join(hooksDir, hookFile), 'utf8');
+          // Match both JS (//) and bash (#) comment styles
+          const versionMatch = content.match(/(?:\/\/|#) pp-hook-version:\s*(.+)/);
+          if (versionMatch) {
+            const hookVersion = versionMatch[1].trim();
+            if (isSemverNewer(installed, hookVersion) && !hookVersion.includes('{{')) {
+              staleHooks.push({ file: hookFile, hookVersion, installedVersion: installed });
+            }
+          } else {
+            // No version header at all — definitely stale (pre-version-tracking)
+            staleHooks.push({ file: hookFile, hookVersion: 'unknown', installedVersion: installed });
+          }
+        } catch (e) {}
+      }
+    }
+  } catch (e) {}
+}
+
+// Single adapter for the registry lookup (#498). checkLatestVersion() routes
+// through the shell-projection seam, which already owns the Windows shell-flag
+// policy, the timeout, and semver validation. A non-ok result leaves latest
+// null, exactly as the previous inline try/catch did.
+let latest = null;
+try {
+  const lv = checkLatestVersion();
+  if (lv && lv.ok) latest = lv.version;
+} catch (e) {}
+
+const result = {
+  update_available: latest && isSemverNewer(latest, installed),
+  installed,
+  latest: latest || 'unknown',
+  checked: Math.floor(Date.now() / 1000),
+  stale_hooks: staleHooks.length > 0 ? staleHooks : undefined,
+  package_name: PACKAGE_NAME,
+};
+
+if (cacheFile) {
+  try { fs.writeFileSync(cacheFile, JSON.stringify(result)); } catch (e) {}
+}

package/hooks/dist/pp-check-update.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// pp-hook-version: {{PP_VERSION}}
+// Check for GSD updates in background, write result to cache
+// Called by SessionStart hook - runs once per session
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const { updateCacheFileName } = require('../pp-core/bin/lib/package-identity.cjs');
+
+const homeDir = os.homedir();
+const cwd = process.cwd();
+
+// Detect runtime config directory (supports Claude, OpenCode, Kilo, Gemini)
+// Respects CLAUDE_CONFIG_DIR for custom config directory setups
+function detectConfigDir(baseDir) {
+  // Check env override first (supports multi-account setups)
+  const envDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envDir && fs.existsSync(path.join(envDir, 'pp-core', 'VERSION'))) {
+    return envDir;
+  }
+  for (const dir of ['.claude', '.gemini', '.config/kilo', '.kilo', '.config/opencode', '.opencode']) {
+    if (fs.existsSync(path.join(baseDir, dir, 'pp-core', 'VERSION'))) {
+      return path.join(baseDir, dir);
+    }
+  }
+  return envDir || path.join(baseDir, '.claude');
+}
+
+const globalConfigDir = detectConfigDir(homeDir);
+const projectConfigDir = detectConfigDir(cwd);
+// Use a shared, tool-agnostic cache directory to avoid multi-runtime
+// resolution mismatches where check-update writes to one runtime's cache
+// but statusline reads from another (#1421).
+const cacheDir = path.join(homeDir, '.cache', 'gsd');
+const cacheFile = path.join(cacheDir, updateCacheFileName);
+
+// VERSION file locations (check project first, then global)
+const projectVersionFile = path.join(projectConfigDir, 'pp-core', 'VERSION');
+const globalVersionFile = path.join(globalConfigDir, 'pp-core', 'VERSION');
+
+// Ensure cache directory exists
+if (!fs.existsSync(cacheDir)) {
+  fs.mkdirSync(cacheDir, { recursive: true });
+}
+
+// Run check in background via a dedicated worker script.
+// Spawning a file (rather than node -e '<inline code>') keeps the worker logic
+// in plain JS with no template-literal regex-escaping concerns, and makes the
+// worker independently testable.
+const workerPath = path.join(__dirname, 'pp-check-update-worker.js');
+const child = spawn(process.execPath, [workerPath], {
+  stdio: 'ignore',
+  windowsHide: true,
+  detached: true,  // Required on Windows for proper process detachment
+  env: {
+    ...process.env,
+    GSD_CACHE_FILE: cacheFile,
+    GSD_PROJECT_VERSION_FILE: projectVersionFile,
+    GSD_GLOBAL_VERSION_FILE: globalVersionFile,
+  },
+});
+
+child.unref();

package/hooks/dist/pp-config-reload.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// pp-hook-version: {{PP_VERSION}}
+// gsd-config-reload.js — FileChanged hook: hot-reload GSD config context
+// Fires when .planning/config.json is modified, created, or deleted.
+//
+// When the user edits .planning/config.json mid-session, this hook reads the
+// updated config and injects a summary as additionalContext so the agent knows
+// the new configuration without requiring a session restart.
+//
+// Input (from Claude Code):
+//   { session_id, cwd, hook_event_name: "FileChanged",
+//     file_path: "/abs/path/.planning/config.json", event: "change"|"add"|"unlink" }
+//
+// Output:
+//   { hookSpecificOutput: { hookEventName: "FileChanged", additionalContext: "..." } }
+//   or exits 0 silently (if config absent, unreadable, or event is "unlink").
+//
+// Enabled for all Claude Code installs. This hook is always-on — it is a
+// no-op when .planning/config.json is absent (ENOENT → exit 0).
+
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+// Timeout guard: if stdin does not close within 8s exit silently rather than
+// hanging until Claude Code kills the process and reports "hook error".
+const stdinTimeout = setTimeout(() => process.exit(0), 8000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => (input += chunk));
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const event = data.event; // "change" | "add" | "unlink"
+    const filePath = data.file_path || '';
+    const cwd = data.cwd || process.cwd();
+
+    // Only handle the GSD planning config — verify both basename and that the
+    // resolved path is .planning/config.json relative to cwd.  The hook
+    // matcher ('config.json') fires on any watched config.json; this guard
+    // ensures an unrelated config.json in node_modules/ or elsewhere does not
+    // inject spurious additionalContext.
+    const basename = path.basename(filePath);
+    if (basename !== 'config.json') {
+      process.exit(0);
+    }
+    const expectedPath = path.resolve(cwd, '.planning', 'config.json');
+    if (path.resolve(filePath) !== expectedPath) {
+      process.exit(0);
+    }
+
+    // On unlink (deletion) emit a brief notice and exit
+    if (event === 'unlink') {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'FileChanged',
+          additionalContext:
+            'GSD config (.planning/config.json) was deleted. ' +
+            'Falling back to built-in defaults for this session.',
+        },
+      }));
+      process.exit(0);
+    }
+
+    // Read the updated config file
+    let config;
+    try {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      config = JSON.parse(raw);
+    } catch (e) {
+      if (e && e.code === 'ENOENT') process.exit(0);
+      // Malformed JSON — inform the agent without crashing
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'FileChanged',
+          additionalContext:
+            'GSD config (.planning/config.json) was modified but could not be parsed. ' +
+            'Check the file for JSON syntax errors.',
+        },
+      }));
+      process.exit(0);
+    }
+
+    // Build a concise summary of key config fields the agent cares about
+    const lines = ['GSD config reloaded (.planning/config.json updated):'];
+
+    if (config.runtime) lines.push(`  runtime: ${config.runtime}`);
+    if (config.mode) lines.push(`  mode: ${config.mode}`);
+
+    // hooks section (opt-in toggles agents act on)
+    if (config.hooks && typeof config.hooks === 'object') {
+      const hookKeys = Object.entries(config.hooks)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+      if (hookKeys) lines.push(`  hooks: { ${hookKeys} }`);
+    }
+
+    // workflow section (key toggles)
+    if (config.workflow && typeof config.workflow === 'object') {
+      const wfKeys = Object.entries(config.workflow)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+      if (wfKeys) lines.push(`  workflow: { ${wfKeys} }`);
+    }
+
+    // model overrides (agents use these)
+    if (config.models && typeof config.models === 'object') {
+      const modelKeys = Object.entries(config.models)
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(', ');
+      if (modelKeys) lines.push(`  models: { ${modelKeys} }`);
+    }
+
+    if (lines.length === 1) {
+      // No notable fields — still confirm the reload happened
+      lines.push('  (no notable keys changed)');
+    }
+
+    const additionalContext = lines.join('\n');
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'FileChanged',
+        additionalContext,
+      },
+    }));
+  } catch (e) {
+    // Silent fail — never block the session on a config reload error
+    process.exit(0);
+  }
+});