claude-code-pilot 3.1.1 → 3.3.0

package/src/commands/ccp/pr-ecc.md

@@ -0,0 +1,184 @@
+---
+description: "Create a GitHub PR from current branch with unpushed commits — discovers templates, analyzes changes, pushes"
+argument-hint: "[base-branch] (default: main)"
+---
+
+# Create Pull Request
+
+**Input**: `$ARGUMENTS` — optional, may contain a base branch name and/or flags (e.g., `--draft`).
+
+**Parse `$ARGUMENTS`**:
+- Extract any recognized flags (`--draft`)
+- Treat remaining non-flag text as the base branch name
+- Default base branch to `main` if none specified
+
+---
+
+## Phase 1 — VALIDATE
+
+Check preconditions:
+
+```bash
+git branch --show-current
+git status --short
+git log origin/<base>..HEAD --oneline
+```
+
+| Check | Condition | Action if Failed |
+|---|---|---|
+| Not on base branch | Current branch ≠ base | Stop: "Switch to a feature branch first." |
+| Clean working directory | No uncommitted changes | Warn: "You have uncommitted changes. Commit or stash first." |
+| Has commits ahead | `git log origin/<base>..HEAD` not empty | Stop: "No commits ahead of `<base>`. Nothing to PR." |
+| No existing PR | `gh pr list --head <branch> --json number` is empty | Stop: "PR already exists: #<number>. Use `gh pr view <number> --web` to open it." |
+
+If all checks pass, proceed.
+
+---
+
+## Phase 2 — DISCOVER
+
+### PR Template
+
+Search for PR template in order:
+
+1. `.github/PULL_REQUEST_TEMPLATE/` directory — if exists, list files and let user choose (or use `default.md`)
+2. `.github/PULL_REQUEST_TEMPLATE.md`
+3. `.github/pull_request_template.md`
+4. `docs/pull_request_template.md`
+
+If found, read it and use its structure for the PR body.
+
+### Commit Analysis
+
+```bash
+git log origin/<base>..HEAD --format="%h %s" --reverse
+```
+
+Analyze commits to determine:
+- **PR title**: Use conventional commit format with type prefix — `feat: ...`, `fix: ...`, etc.
+  - If multiple types, use the dominant one
+  - If single commit, use its message as-is
+- **Change summary**: Group commits by type/area
+
+### File Analysis
+
+```bash
+git diff origin/<base>..HEAD --stat
+git diff origin/<base>..HEAD --name-only
+```
+
+Categorize changed files: source, tests, docs, config, migrations.
+
+### Planning Artifacts
+
+Check for related artifacts produced by `/plan-prd`, `/plan`, or the legacy PRP workflow:
+- `.claude/prds/` — PRDs this PR implements a milestone of
+- `.claude/plans/` — Plans executed by this PR
+- `.claude/PRPs/prds/` — legacy PRP PRDs
+- `.claude/PRPs/plans/` — legacy PRP implementation plans
+- `.claude/PRPs/reports/` — legacy PRP implementation reports
+
+Reference these in the PR body if they exist.
+
+---
+
+## Phase 3 — PUSH
+
+```bash
+git push -u origin HEAD
+```
+
+If push fails due to divergence:
+```bash
+git fetch origin
+git rebase origin/<base>
+git push -u origin HEAD
+```
+
+If rebase conflicts occur, stop and inform the user.
+
+---
+
+## Phase 4 — CREATE
+
+### With Template
+
+If a PR template was found in Phase 2, fill in each section using the commit and file analysis. Preserve all template sections — leave sections as "N/A" if not applicable rather than removing them.
+
+### Without Template
+
+Use this default format:
+
+```markdown
+## Summary
+
+<1-2 sentence description of what this PR does and why>
+
+## Changes
+
+<bulleted list of changes grouped by area>
+
+## Files Changed
+
+<table or list of changed files with change type: Added/Modified/Deleted>
+
+## Testing
+
+<description of how changes were tested, or "Needs testing">
+
+## Related Issues
+
+<linked issues with Closes/Fixes/Relates to #N, or "None">
+```
+
+### Create the PR
+
+```bash
+gh pr create \
+  --title "<PR title>" \
+  --base <base-branch> \
+  --body "<PR body>"
+  # Add --draft if the --draft flag was parsed from $ARGUMENTS
+```
+
+---
+
+## Phase 5 — VERIFY
+
+```bash
+gh pr view --json number,url,title,state,baseRefName,headRefName,additions,deletions,changedFiles
+gh pr checks --json name,status,conclusion 2>/dev/null || true
+```
+
+---
+
+## Phase 6 — OUTPUT
+
+Report to user:
+
+```
+PR #<number>: <title>
+URL: <url>
+Branch: <head> → <base>
+Changes: +<additions> -<deletions> across <changedFiles> files
+
+CI Checks: <status summary or "pending" or "none configured">
+
+Artifacts referenced:
+  - <any PRDs/plans linked in PR body>
+
+Next steps:
+  - gh pr view <number> --web   → open in browser
+  - /code-review <number>       → review the PR
+  - gh pr merge <number>        → merge when ready
+```
+
+---
+
+## Edge Cases
+
+- **No `gh` CLI**: Stop with: "GitHub CLI (`gh`) is required. Install: <https://cli.github.com/>"
+- **Not authenticated**: Stop with: "Run `gh auth login` first."
+- **Force push needed**: If remote has diverged and rebase was done, use `git push --force-with-lease` (never `--force`).
+- **Multiple PR templates**: If `.github/PULL_REQUEST_TEMPLATE/` has multiple files, list them and ask user to choose.
+- **Large PR (>20 files)**: Warn about PR size. Suggest splitting if changes are logically separable.

package/src/commands/ccp/scan.md

@@ -0,0 +1,26 @@
+---
+name: ccp:scan
+description: Rapid codebase assessment — lightweight alternative to /ccp:map-codebase
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+---
+<objective>
+Run a focused codebase scan for a single area, producing targeted documents in `.planning/codebase/`.
+Accepts an optional `--focus` flag: `tech`, `arch`, `quality`, `concerns`, or `tech+arch` (default).
+
+Lightweight alternative to `/ccp:map-codebase` — spawns one mapper agent instead of four parallel ones.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/scan.md
+</execution_context>
+
+<process>
+Execute the scan workflow from @~/.claude/pilot/workflows/scan.md end-to-end.
+</process>

package/src/commands/ccp/security-scan.md

@@ -0,0 +1,74 @@
+---
+description: Scan your .claude/ configuration for security issues via AgentShield (external, opt-in via npx).
+argument-hint: [path] [--format json|markdown|html] [--min-severity low|medium|high|critical] [--fix]
+---
+
+# Security Scan
+
+Scan a project (agents, hooks, MCP servers, permissions, and secrets) for
+security issues. This command is a thin wrapper around the external
+`ecc-agentshield` scanner: nothing is installed at CCP install time — you opt in
+at run time via `npx`, so the scanner is fetched on demand and never vendored.
+
+## Usage
+
+`/ccp:security-scan [path] [--format json|markdown|html] [--min-severity low|medium|high|critical] [--fix]`
+
+- `path` (optional): defaults to the current project. Use a `.claude/` path, a
+  repo root, or a checked-in template directory.
+- `--format`: output format. Use `json` for CI, `markdown` for handoffs, `html`
+  for standalone review reports.
+- `--min-severity`: filters lower-priority findings.
+- `--fix`: applies only fixes the scanner explicitly marks safe and auto-fixable.
+
+## Deterministic Engine
+
+Run the external scanner against the target path:
+
+```bash
+npx ecc-agentshield scan --path "${TARGET_PATH:-.}"
+```
+
+For a plain-text report instead of the default output:
+
+```bash
+npx ecc-agentshield scan --path "${TARGET_PATH:-.}" --format text
+```
+
+Use AgentShield output as the source of truth; do not invent findings. Keep
+scanner facts separate from your follow-up judgment.
+
+## Remediation
+
+For each critical or high finding, return:
+
+- file path
+- severity
+- why it matters
+- the exact fix
+- whether `--fix` is safe to apply
+
+If `--fix` is requested, state the planned edits before applying them, then
+re-scan and report the before/after grade.
+
+## Full Reference
+
+The complete CLI surface, output formats, severity grades, and the policy schema
+live in the skill — read it for anything beyond the invocation above:
+
+@.claude/skills/security-scan/SKILL.md
+
+The policy schema and example documents are under
+`references/agentshield-policy-exception/` within that skill.
+
+## Arguments
+
+$ARGUMENTS:
+- optional target path
+- optional AgentShield flags (`--format`, `--min-severity`, `--fix`)
+
+## Source
+
+Thin wrapper for AgentShield (https://github.com/affaan-m/agentshield);
+external, not vendored. Pinned in `manifest.json` under
+`external.agentshield` (1.4.0).

package/src/commands/ccp/sketch-wrap-up.md

@@ -0,0 +1,31 @@
+---
+name: ccp:sketch-wrap-up
+description: Package sketch design findings into a persistent project skill for future build conversations
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+<objective>
+Curate sketch design findings and package them into a persistent project skill that Claude
+auto-loads when building the real UI. Also writes a summary to `.planning/sketches/` for
+project history. Output skill goes to `./.claude/skills/sketch-findings-[project]/` (project-local).
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/sketch-wrap-up.md
+@~/.claude/pilot/references/ui-brand.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `AskUserQuestion`.
+</runtime_note>
+
+<process>
+Execute the sketch-wrap-up workflow from @~/.claude/pilot/workflows/sketch-wrap-up.md end-to-end.
+Preserve all curation gates (per-sketch review, grouping approval, CLAUDE.md routing line).
+</process>

package/src/commands/ccp/sketch.md

@@ -0,0 +1,54 @@
+---
+name: ccp:sketch
+description: Sketch UI/design ideas with throwaway HTML mockups, or propose what to sketch next (frontier mode)
+argument-hint: "[design idea to explore] [--quick] [--text] or [frontier]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+  - WebSearch
+  - WebFetch
+  - mcp__context7__resolve-library-id
+  - mcp__context7__query-docs
+---
+<objective>
+Explore design directions through throwaway HTML mockups before committing to implementation.
+Each sketch produces 2-3 variants for comparison. Sketches live in `.planning/sketches/` and
+integrate with GSD commit patterns, state tracking, and handoff workflows. Loads spike
+findings to ground mockups in real data shapes and validated interaction patterns.
+
+Two modes:
+- **Idea mode** (default) — describe a design idea to sketch
+- **Frontier mode** (no argument or "frontier") — analyzes existing sketch landscape and proposes consistency and frontier sketches
+
+Does not require `/ccp:new-project` — auto-creates `.planning/sketches/` if needed.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/sketch.md
+@~/.claude/pilot/references/ui-brand.md
+@~/.claude/pilot/references/sketch-theme-system.md
+@~/.claude/pilot/references/sketch-interactivity.md
+@~/.claude/pilot/references/sketch-tooling.md
+@~/.claude/pilot/references/sketch-variant-patterns.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `AskUserQuestion`.
+</runtime_note>
+
+<context>
+Design idea: $ARGUMENTS
+
+**Available flags:**
+- `--quick` — Skip mood/direction intake, jump straight to decomposition and building. Use when the design direction is already clear.
+</context>
+
+<process>
+Execute the sketch workflow from @~/.claude/pilot/workflows/sketch.md end-to-end.
+Preserve all workflow gates (intake, decomposition, target stack research, variant evaluation, MANIFEST updates, commit patterns).
+</process>

package/src/commands/ccp/spec-phase.md

@@ -0,0 +1,62 @@
+---
+name: ccp:spec-phase
+description: Socratic spec refinement — clarify WHAT a phase delivers with ambiguity scoring before discuss-phase. Produces a SPEC.md with falsifiable requirements locked before implementation decisions begin.
+argument-hint: "<phase> [--auto] [--text]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+---
+
+<objective>
+Clarify phase requirements through structured Socratic questioning with quantitative ambiguity scoring.
+
+**Position in workflow:** `spec-phase → discuss-phase → plan-phase → execute-phase → verify`
+
+**How it works:**
+1. Load phase context (PROJECT.md, REQUIREMENTS.md, ROADMAP.md, STATE.md)
+2. Scout the codebase — understand current state before asking questions
+3. Run Socratic interview loop (up to 6 rounds, rotating perspectives)
+4. Score ambiguity across 4 weighted dimensions after each round
+5. Gate: ambiguity ≤ 0.20 AND all dimensions meet minimums → write SPEC.md
+6. Commit SPEC.md — discuss-phase picks it up automatically on next run
+
+**Output:** `{phase_dir}/{padded_phase}-SPEC.md` — falsifiable requirements that lock "what/why" before discuss-phase handles "how"
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/spec-phase.md
+@~/.claude/pilot/templates/spec.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `AskUserQuestion`. They are equivalent.
+</runtime_note>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+**Flags:**
+- `--auto` — Skip interactive questions; Claude selects recommended defaults and writes SPEC.md
+- `--text` — Use plain-text numbered lists instead of TUI menus (required for `/rc` remote sessions)
+
+Context files are resolved in-workflow using `init phase-op`.
+</context>
+
+<process>
+Execute the spec-phase workflow from @~/.claude/pilot/workflows/spec-phase.md end-to-end.
+
+**MANDATORY:** Read the workflow file BEFORE taking any action. The workflow contains the complete step-by-step process including the Socratic interview loop, ambiguity scoring gate, and SPEC.md generation. Do not improvise from the objective summary above.
+</process>
+
+<success_criteria>
+- Codebase scouted for current state before questioning begins
+- All 4 ambiguity dimensions scored after each interview round
+- Gate passed: ambiguity ≤ 0.20 AND all dimension minimums met
+- SPEC.md written with falsifiable requirements, explicit boundaries, and acceptance criteria
+- SPEC.md committed atomically
+- User knows they can now run /ccp:discuss-phase which will load SPEC.md automatically
+</success_criteria>

package/src/commands/ccp/spike-wrap-up.md

@@ -0,0 +1,31 @@
+---
+name: ccp:spike-wrap-up
+description: Package spike findings into a persistent project skill for future build conversations
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+---
+<objective>
+Curate spike experiment findings and package them into a persistent project skill that Claude
+auto-loads in future build conversations. Also writes a summary to `.planning/spikes/` for
+project history. Output skill goes to `./.claude/skills/spike-findings-[project]/` (project-local).
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/spike-wrap-up.md
+@~/.claude/pilot/references/ui-brand.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `AskUserQuestion`.
+</runtime_note>
+
+<process>
+Execute the spike-wrap-up workflow from @~/.claude/pilot/workflows/spike-wrap-up.md end-to-end.
+Preserve all workflow gates (auto-include, feature-area grouping, skill synthesis, CLAUDE.md routing line, intelligent next-step routing).
+</process>

package/src/commands/ccp/spike.md

@@ -0,0 +1,51 @@
+---
+name: ccp:spike
+description: Spike an idea through experiential exploration, or propose what to spike next (frontier mode)
+argument-hint: "[idea to validate] [--quick] [--text] or [frontier]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - AskUserQuestion
+  - WebSearch
+  - WebFetch
+  - mcp__context7__resolve-library-id
+  - mcp__context7__query-docs
+---
+<objective>
+Spike an idea through experiential exploration — build focused experiments to feel the pieces
+of a future app, validate feasibility, and produce verified knowledge for the real build.
+Spikes live in `.planning/spikes/` and integrate with GSD commit patterns, state tracking,
+and handoff workflows.
+
+Two modes:
+- **Idea mode** (default) — describe an idea to spike
+- **Frontier mode** (no argument or "frontier") — analyzes existing spike landscape and proposes integration and frontier spikes
+
+Does not require `/ccp:new-project` — auto-creates `.planning/spikes/` if needed.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/spike.md
+@~/.claude/pilot/references/ui-brand.md
+</execution_context>
+
+<runtime_note>
+**Copilot (VS Code):** Use `vscode_askquestions` wherever this workflow calls `AskUserQuestion`.
+</runtime_note>
+
+<context>
+Idea: $ARGUMENTS
+
+**Available flags:**
+- `--quick` — Skip decomposition/alignment, jump straight to building. Use when you already know what to spike.
+- `--text` — Use plain-text numbered lists instead of AskUserQuestion (for non-Claude runtimes).
+</context>
+
+<process>
+Execute the spike workflow from @~/.claude/pilot/workflows/spike.md end-to-end.
+Preserve all workflow gates (prior spike check, decomposition, research, risk ordering, observability assessment, verification, MANIFEST updates, commit patterns).
+</process>

package/src/commands/ccp/ultraplan-phase.md

@@ -0,0 +1,33 @@
+---
+name: ccp:ultraplan-phase
+description: "[BETA] Offload plan phase to Claude Code's ultraplan cloud — drafts remotely while terminal stays free, review in browser with inline comments, import back via /ccp:import. Claude Code only."
+argument-hint: "[phase-number]"
+allowed-tools:
+  - Read
+  - Bash
+  - Glob
+  - Grep
+---
+
+<objective>
+Offload GSD's plan phase to Claude Code's ultraplan cloud infrastructure.
+
+Ultraplan drafts the plan in a remote cloud session while your terminal stays free.
+Review and comment on the plan in your browser, then import it back via /ccp:import --from.
+
+⚠ BETA: ultraplan is in research preview. Use /ccp:plan-phase for stable local planning.
+Requirements: Claude Code v2.1.91+, claude.ai account, GitHub repository.
+</objective>
+
+<execution_context>
+@~/.claude/pilot/workflows/ultraplan-phase.md
+@~/.claude/pilot/references/ui-brand.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+</context>
+
+<process>
+Execute the ultraplan-phase workflow end-to-end.
+</process>

package/src/hooks/ccp-bash-hook-dispatcher.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+
+const { isHookEnabled } = require('../lib/hook-flags');
+
+const MAX_STDIN = 1024 * 1024;
+
+// GateGuard is the sole pre-bash chain member in CCP's minimal dispatcher.
+// It is lazy-required so this file does NOT hard-depend on the GateGuard hook
+// (ccp-write-gateguard, delivered by Plan 04) landing first. If the module is
+// absent, the member is a no-op that returns rawInput unchanged.
+//
+// NOTE: The upstream tmux / git-push / commit-quality / auto-tmux /
+// block-no-verify members are intentionally NOT ported. Those are external
+// workflow opinions; CCP ships a minimal, profile-gated dispatcher whose only
+// job is the GateGuard Bash branch. The runHooks loop below is preserved as an
+// extensible scaffold so future members can be appended to PRE_BASH_HOOKS.
+let _gateguardRun = null;
+try {
+  _gateguardRun = require('./ccp-write-gateguard').run;
+} catch (_) {
+  _gateguardRun = null;
+}
+
+const PRE_BASH_HOOKS = [
+  {
+    id: 'pre:bash:gateguard-fact-force',
+    profiles: 'standard,strict',
+    run: rawInput => (_gateguardRun ? _gateguardRun(rawInput) : rawInput),
+  },
+];
+
+function normalizeHookResult(previousRaw, output) {
+  if (typeof output === 'string' || Buffer.isBuffer(output)) {
+    return {
+      raw: String(output),
+      stderr: '',
+      exitCode: 0,
+    };
+  }
+
+  if (output && typeof output === 'object') {
+    const nextRaw = Object.prototype.hasOwnProperty.call(output, 'stdout')
+      ? String(output.stdout ?? '')
+      : !Number.isInteger(output.exitCode) || output.exitCode === 0
+        ? previousRaw
+        : '';
+
+    return {
+      raw: nextRaw,
+      stderr: typeof output.stderr === 'string' ? output.stderr : '',
+      exitCode: Number.isInteger(output.exitCode) ? output.exitCode : 0,
+    };
+  }
+
+  return {
+    raw: previousRaw,
+    stderr: '',
+    exitCode: 0,
+  };
+}
+
+function runHooks(rawInput, hooks) {
+  let currentRaw = rawInput;
+  let stderr = '';
+
+  for (const hook of hooks) {
+    if (!isHookEnabled(hook.id, { profiles: hook.profiles })) {
+      continue;
+    }
+
+    try {
+      const result = normalizeHookResult(currentRaw, hook.run(currentRaw));
+      currentRaw = result.raw;
+      if (result.stderr) {
+        stderr += result.stderr.endsWith('\n') ? result.stderr : `${result.stderr}\n`;
+      }
+      if (result.exitCode !== 0) {
+        return { output: currentRaw, stderr, exitCode: result.exitCode };
+      }
+    } catch (error) {
+      stderr += `[Hook] ${hook.id} failed: ${error.message}\n`;
+    }
+  }
+
+  return { output: currentRaw, stderr, exitCode: 0 };
+}
+
+function runPreBash(rawInput) {
+  return runHooks(rawInput, PRE_BASH_HOOKS);
+}
+
+module.exports = { PRE_BASH_HOOKS, runPreBash };
+
+// MAX_STDIN is exported indirectly for parity with the entrypoint cap.
+module.exports.MAX_STDIN = MAX_STDIN;

package/src/hooks/ccp-context-monitor.js

@@ -26,6 +26,21 @@ const CRITICAL_THRESHOLD = 25; // remaining_percentage <= 25%
 const STALE_SECONDS = 60;      // ignore metrics older than 60s
 const DEBOUNCE_CALLS = 5;      // min tool uses between warnings
 
+// Cost-warning opt-out (backport of ECC b47dfa95, re-expressed for CCP).
+// Set CCP_CONTEXT_MONITOR_COST_WARNINGS=0 (or false/off/no/disabled) to suppress
+// cost-warning emission. Default ON. CCP's monitor currently emits context
+// warnings only; this gate future-proofs any cost-warning emission point.
+function isEnabledEnv(value, defaultValue = true) {
+  if (value == null || String(value).trim() === '') return defaultValue;
+  const n = String(value).trim().toLowerCase();
+  if (['0', 'false', 'no', 'off', 'disabled'].includes(n)) return false;
+  if (['1', 'true', 'yes', 'on', 'enabled'].includes(n)) return true;
+  return defaultValue;
+}
+function costWarningsEnabled(env = process.env) {
+  return isEnabledEnv(env.CCP_CONTEXT_MONITOR_COST_WARNINGS, true); // CCP-branded rename of the upstream cost-warning opt-out (b47dfa95)
+}
+
 let input = '';
 // Timeout guard: if stdin doesn't close within 3s (e.g. pipe issues on
 // Windows/Git Bash), exit silently instead of hanging until Claude Code
@@ -134,6 +149,14 @@ process.stdin.on('end', () => {
     };
 
     process.stdout.write(JSON.stringify(output));
+
+    // --- Cost-warning emission point (gated by CCP_CONTEXT_MONITOR_COST_WARNINGS) ---
+    // CCP's statusline bridge does not currently surface per-session cost data, so
+    // this branch is a no-op today. When metrics.cost_* becomes available, emit the
+    // cost advisory HERE, guarded by the opt-out so users can suppress it.
+    if (costWarningsEnabled() && metrics && metrics.cost_warning) {
+      // (future) emit cost advisory via hookSpecificOutput.additionalContext
+    }
   } catch (e) {
     // Silent fail -- never block tool execution
     process.exit(0);