@hegemonart/get-design-done 1.24.2 → 1.26.0

package/hooks/budget-enforcer.ts

@@ -72,6 +72,38 @@ function resolveHookPath(): string {
 const nodeRequire = createRequire(resolveHookPath());
 const rateGuard = nodeRequire('../scripts/lib/rate-guard.cjs') as typeof import('../scripts/lib/rate-guard.cjs');
 const iterationBudget = nodeRequire('../scripts/lib/iteration-budget.cjs') as typeof import('../scripts/lib/iteration-budget.cjs');
+// Plan 26-05: shared cost-computation backend for the resolved_models
+// consumer path. Pure module — takes (model_id, runtime, token_counts) →
+// cost_usd by reading per-runtime price tables under reference/prices/.
+// See scripts/lib/budget-enforcer.cjs for the lookup chain.
+interface BudgetEnforcerBackend {
+  computeCost(args: {
+    model_id?: string | null;
+    tier?: string | null;
+    runtime: string;
+    tokens_in: number;
+    tokens_out: number;
+    cache_hit?: boolean;
+  }): {
+    cost_usd: number | null;
+    model: string | null;
+    tier: string | null;
+    runtime_used: string | null;
+    fallback: boolean;
+    reason: string | null;
+  };
+  modelFromResolved(resolved: unknown, agent: string): string | null;
+}
+const budgetBackend = nodeRequire('../scripts/lib/budget-enforcer.cjs') as BudgetEnforcerBackend;
+// Plan 26-05: runtime detection for the cost-event runtime tag. Returns
+// 'claude' for the CC hook context (CLAUDE_CONFIG_DIR is set when CC is
+// the host), null when running outside any of the 14 runtime envs (e.g.
+// CI matrix). The hook defaults the null case to 'claude' since the .ts
+// hook only runs inside CC anyway.
+interface RuntimeDetectModule {
+  detect(): string | null;
+}
+const runtimeDetect = nodeRequire('../scripts/lib/runtime-detect.cjs') as RuntimeDetectModule;
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
@@ -80,6 +112,45 @@ const iterationBudget = nodeRequire('../scripts/lib/iteration-budget.cjs') as ty
  * for every hook invocation. The tool_input shape is tool-specific;
  * this hook only consumes Agent-shaped tool_input so we narrow here.
  */
+/** Phase 25 / D-04, D-05: router complexity-class enum. */
+export type ComplexityClass = 'S' | 'M' | 'L' | 'XL';
+
+/**
+ * Phase 25 / D-05: router decision payload as surfaced on
+ * tool_input.context.router_decision. Only the fields this hook reads
+ * are typed; the router emits more (model_tier_overrides,
+ * estimated_cost_usd, cache_hits) but they are not consumed here.
+ */
+interface RouterDecision {
+  path?: 'fast' | 'quick' | 'full';
+  complexity_class?: ComplexityClass;
+  /**
+   * Phase 26 / D-07: per-agent concrete model name resolved by the
+   * router via `scripts/lib/tier-resolver.cjs`. Strict superset of
+   * `model_tier_overrides` — existing consumers still read tier names
+   * from `model_tier_overrides`; new consumers read `resolved_models`
+   * for runtime-correct cost lookup.
+   */
+  resolved_models?: Record<string, string>;
+  /**
+   * Phase 26 / D-08: runtime ID the router computed `resolved_models`
+   * against. Optional; the hook falls back to `runtime-detect.cjs`
+   * when absent.
+   */
+  runtime?: string;
+  /**
+   * Phase 25 back-compat: tier-name overrides per agent. Phase 26 keeps
+   * this as the legacy fallback path when `resolved_models` is absent.
+   */
+  model_tier_overrides?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+interface ToolInputContext {
+  router_decision?: RouterDecision;
+  [key: string]: unknown;
+}
+
 interface ToolInput {
   subagent_type?: string;
   agent?: string;
@@ -91,6 +162,7 @@ interface ToolInput {
   _default_tier?: string;
   _tier_downgraded?: boolean;
   lazy_skipped?: boolean;
+  context?: ToolInputContext;
   [key: string]: unknown;
 }
 
@@ -199,6 +271,46 @@ const BUDGET_DEFAULTS: Required<
   enforcement_mode: 'enforce',
 };
 
+/**
+ * Phase 25 / D-05: optional per-class cap map on .design/budget.json.
+ * Documented in reference/config-schema.md as `class_caps_usd?: { S?: number; M?: number; L?: number; XL?: number }`.
+ * Read through the BudgetSchema index signature so we don't have to
+ * regenerate the schema for an additive optional field.
+ */
+type ClassCapsUsd = Partial<Record<ComplexityClass, number>>;
+
+function readClassCaps(budget: BudgetSchema): ClassCapsUsd | undefined {
+  const raw = (budget as { class_caps_usd?: unknown }).class_caps_usd;
+  if (raw === undefined || raw === null || typeof raw !== 'object') {
+    return undefined;
+  }
+  const out: ClassCapsUsd = {};
+  for (const k of ['S', 'M', 'L', 'XL'] as const) {
+    const v = (raw as Record<string, unknown>)[k];
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+/**
+ * Phase 25 / D-05: resolve the per-spawn cap. If the router decision
+ * payload contains a `complexity_class` AND `.design/budget.json#class_caps_usd[class]`
+ * is defined, use that. Otherwise fall back to `per_task_cap_usd`.
+ */
+function resolvePerSpawnCap(
+  budget: ResolvedBudget,
+  complexityClass: ComplexityClass | undefined,
+): number {
+  if (complexityClass !== undefined) {
+    const caps = readClassCaps(budget);
+    const classCap = caps?.[complexityClass];
+    if (classCap !== undefined) return classCap;
+  }
+  return budget.per_task_cap_usd;
+}
+
 /**
  * Concrete budget shape after defaults-merge. Every field becomes
  * non-optional so downstream branches don't have to null-guard. Defined
@@ -459,6 +571,53 @@ function emitHookFired(decision: HookDecision, cycle?: string): void {
   }
 }
 
+/**
+ * Plan 26-05 / D-08: emit a `cost_recorded` event with runtime tag,
+ * concrete model, tier, token counts, and computed cost. Cost-aggregator
+ * downstream rolls these up per-runtime AND per-tier so reflector class-
+ * specific cost analysis (Phase 26-06) can compare apples-to-apples
+ * across runtimes.
+ *
+ * The event uses the BaseEvent envelope shape (free-form `type` per
+ * Phase 22 events.jsonl contract). Fail-open like every other emit in
+ * this hook — never block the spawn on a telemetry failure.
+ */
+function emitCostRecorded(
+  payload: {
+    runtime: string;
+    agent: string;
+    model_id: string | null;
+    tier: string | null;
+    tokens_in: number;
+    tokens_out: number;
+    cost_usd: number | null;
+  },
+  cycle?: string,
+): void {
+  const ev = {
+    type: 'cost_recorded',
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    ...(cycle !== undefined && cycle !== 'unknown' ? { cycle } : {}),
+    payload: {
+      runtime: payload.runtime,
+      agent: payload.agent,
+      model_id: payload.model_id,
+      tier: payload.tier,
+      tokens_in: payload.tokens_in,
+      tokens_out: payload.tokens_out,
+      cost_usd: payload.cost_usd,
+    },
+  };
+  try {
+    // BaseEvent shape; cost_recorded is a free-form subtype (the
+    // Phase 22 events stream is structurally validated, not enum-locked).
+    appendEvent(ev as unknown as HookFiredEvent);
+  } catch {
+    // Fail open.
+  }
+}
+
 // ── main ────────────────────────────────────────────────────────────────────
 
 async function readStdin(): Promise<string> {
@@ -490,6 +649,27 @@ export async function main(): Promise<void> {
   const inputHash =
     typeof toolInput._input_hash === 'string' ? toolInput._input_hash : null;
 
+  // Phase 25 / D-05: extract complexity_class from router decision.
+  // Absent payload → legacy per_task_cap behavior (no regression).
+  // Present payload with class === 'S' → skip enforcement entirely
+  // (defensive: the typical S path is upstream short-circuit where
+  // router never ran and this hook still applies legacy caps; an
+  // explicit S signal here means a caller bypassed the upstream skip
+  // and is asking us to honor the class).
+  const routerDecision: RouterDecision | undefined =
+    toolInput.context?.router_decision !== undefined &&
+    typeof toolInput.context.router_decision === 'object' &&
+    toolInput.context.router_decision !== null
+      ? toolInput.context.router_decision
+      : undefined;
+  const complexityClass: ComplexityClass | undefined =
+    routerDecision?.complexity_class !== undefined &&
+    (['S', 'M', 'L', 'XL'] as const).includes(
+      routerDecision.complexity_class as ComplexityClass,
+    )
+      ? (routerDecision.complexity_class as ComplexityClass)
+      : undefined;
+
   const { cycle, phase } = readCycleAndPhase();
   const cyclePhase = { cycle, phase };
 
@@ -513,6 +693,38 @@ export async function main(): Promise<void> {
 
   const budget = loadBudget();
 
+  // Phase 25 / D-05: explicit S-class short-circuit. The typical S path
+  // skips the router entirely and this hook never runs at all (the
+  // command's SKILL.md does the deterministic skip upstream). When we
+  // DO see complexity_class === 'S' in the payload it means a caller
+  // routed an S-class command through the hook anyway — honor the
+  // class by skipping enforcement (no cap check, no downgrade) but
+  // still write a zero-cost telemetry row + emit an 'allow' event so
+  // observability stays consistent.
+  if (complexityClass === 'S') {
+    writeTelemetry({
+      agent,
+      tier:
+        toolInput._tier_override ??
+        toolInput._default_tier ??
+        'haiku',
+      tokens_in: Number(toolInput._tokens_in_est ?? 0),
+      tokens_out: Number(toolInput._tokens_out_est ?? 0),
+      cache_hit: false,
+      est_cost_usd: Number(toolInput._est_cost_usd ?? 0),
+      enforcement_mode: budget.enforcement_mode,
+      _cyclePhase: cyclePhase,
+    });
+    emitHookFired('allow', cycle);
+    const response: ToolOutput = {
+      continue: true,
+      suppressOutput: true,
+      modified_tool_input: toolInput,
+    };
+    process.stdout.write(JSON.stringify(response));
+    return;
+  }
+
   // Branch B: cache short-circuit (D-05).
   if (inputHash !== null) {
     const cached = cacheLookup(agent, inputHash);
@@ -589,9 +801,15 @@ export async function main(): Promise<void> {
   const estCost = Number(toolInput._est_cost_usd ?? 0);
   const phaseSpend = currentPhaseSpend(phase);
 
+  // Phase 25 / D-05: per-spawn cap is class-specific when
+  // complexity_class is present and class_caps_usd[class] is defined.
+  // Falls back to per_task_cap_usd for backwards compatibility — when
+  // no router decision is supplied, behavior is identical to pre-25.
+  const perSpawnCap = resolvePerSpawnCap(budget, complexityClass);
+
   if (budget.enforcement_mode === 'enforce') {
-    // Branch C: 100% per_task cap hard block.
-    if (estCost >= budget.per_task_cap_usd) {
+    // Branch C: 100% per-spawn cap hard block (class-specific or per_task).
+    if (estCost >= perSpawnCap) {
       writeTelemetry({
         agent,
         tier:
@@ -607,10 +825,14 @@ export async function main(): Promise<void> {
         _cyclePhase: cyclePhase,
       });
       emitHookFired('block', cycle);
+      const capLabel =
+        complexityClass !== undefined && perSpawnCap !== budget.per_task_cap_usd
+          ? `class_caps_usd.${complexityClass}`
+          : 'per-task';
       const response: ToolOutput = {
         continue: false,
         suppressOutput: false,
-        message: `Budget cap reached for per-task. Estimated: $${estCost.toFixed(4)}, cap: $${budget.per_task_cap_usd.toFixed(2)}. Raise cap in .design/budget.json or retry after next task.`,
+        message: `Budget cap reached for ${capLabel}. Estimated: $${estCost.toFixed(4)}, cap: $${perSpawnCap.toFixed(2)}. Raise cap in .design/budget.json or retry after next task.`,
       };
       process.stdout.write(JSON.stringify(response));
       return;
@@ -640,18 +862,19 @@ export async function main(): Promise<void> {
       process.stdout.write(JSON.stringify(response));
       return;
     }
-    // 80% soft-threshold downgrade (D-03): task-scoped.
+    // 80% soft-threshold downgrade (D-03): task-scoped, against the
+    // resolved per-spawn cap so class-specific caps participate.
     if (
       budget.auto_downgrade_on_cap &&
-      estCost >= 0.8 * budget.per_task_cap_usd
+      estCost >= 0.8 * perSpawnCap
     ) {
       toolInput._tier_override = 'haiku';
       toolInput._tier_downgraded = true;
     }
   } else if (budget.enforcement_mode === 'warn') {
-    if (estCost >= budget.per_task_cap_usd) {
+    if (estCost >= perSpawnCap) {
       process.stderr.write(
-        `gdd-budget-enforcer WARN: per-task cap will be exceeded ($${estCost.toFixed(4)} >= $${budget.per_task_cap_usd})\n`,
+        `gdd-budget-enforcer WARN: per-spawn cap will be exceeded ($${estCost.toFixed(4)} >= $${perSpawnCap})\n`,
       );
     }
   }
@@ -662,13 +885,54 @@ export async function main(): Promise<void> {
     toolInput._tier_override = budget.tier_overrides[agent];
   }
 
+  // Plan 26-05 / D-07 + D-08: resolved_models consumer path. When the
+  // router decision payload carries a concrete model ID for this agent
+  // under `resolved_models`, look up the cost in the per-runtime price
+  // table by model ID. Otherwise fall back to the legacy tier-name
+  // lookup (which still resolves through claude.md as the default
+  // runtime — back-compat with v1.25.x callers).
+  const resolvedModelId = budgetBackend.modelFromResolved(
+    routerDecision?.resolved_models,
+    agent,
+  );
+  const resolvedTier =
+    toolInput._tier_override ?? toolInput._default_tier ?? 'sonnet';
+  // Runtime tag: prefer the router's explicit `runtime` (D-08) field;
+  // fall back to env-var detection; default to 'claude' since the .ts
+  // hook itself only runs inside Claude Code.
+  const runtimeId =
+    (typeof routerDecision?.runtime === 'string' && routerDecision.runtime.length > 0
+      ? routerDecision.runtime
+      : runtimeDetect.detect()) ?? 'claude';
+
+  // Compute runtime-aware cost via the shared backend. Failures return
+  // null cost; we emit the event regardless so the cost-aggregator sees
+  // the lookup attempt (Phase 22 events.jsonl tagging).
+  const costLookup = budgetBackend.computeCost({
+    model_id: resolvedModelId,
+    tier: resolvedTier,
+    runtime: runtimeId,
+    tokens_in: Number(toolInput._tokens_in_est ?? 0),
+    tokens_out: Number(toolInput._tokens_out_est ?? 0),
+    cache_hit: false,
+  });
+  emitCostRecorded(
+    {
+      runtime: runtimeId,
+      agent,
+      model_id: resolvedModelId ?? costLookup.model,
+      tier: costLookup.tier ?? resolvedTier,
+      tokens_in: Number(toolInput._tokens_in_est ?? 0),
+      tokens_out: Number(toolInput._tokens_out_est ?? 0),
+      cost_usd: costLookup.cost_usd,
+    },
+    cycle,
+  );
+
   // Branch E: standard spawn-allowed (includes tier-downgraded path).
   writeTelemetry({
     agent,
-    tier:
-      toolInput._tier_override ??
-      toolInput._default_tier ??
-      'sonnet',
+    tier: resolvedTier,
     tokens_in: Number(toolInput._tokens_in_est ?? 0),
     tokens_out: Number(toolInput._tokens_out_est ?? 0),
     cache_hit: false,

package/hooks/gdd-decision-injector.js

@@ -23,6 +23,7 @@ const { spawnSync } = require('child_process');
 
 const MIN_BYTES = 1500;
 const TOP_N = 15;
+const PROTOTYPING_TOP_N = 5;
 const MATCHER_RE = /[\\/](?:\.design|reference|\.planning)[\\/][^\n]*\.md$/;
 
 // Phase 19.5: try FTS5 backend first; fall back to grep silently.
@@ -111,6 +112,174 @@ function sortKeyFor(tag) {
   return 0;
 }
 
+/**
+ * Parse a self-closing-tag attribute string ("a=\"x\" b=\"y\"") into a kv map.
+ * Self-contained: avoids a TS-parser import to keep the hook hot path JS-only.
+ */
+function parseAttrs(attrStr) {
+  const out = {};
+  if (!attrStr) return out;
+  const re = /(\w+)\s*=\s*"([^"]*)"/g;
+  let m;
+  while ((m = re.exec(attrStr)) !== null) out[m[1]] = m[2];
+  return out;
+}
+
+/**
+ * One-shot read of STATE.md. Returns `{ prototyping, decisionsMap }` where
+ * `prototyping` is the inner body of `<prototyping>...</prototyping>` (or '')
+ * and `decisionsMap` is a `D-XX -> rationale` lookup parsed from `<decisions>`.
+ * Both fields default to safe empties on unreadable file / absent blocks.
+ *
+ * Single read keeps the hot path tight (STATE.md is small but reading once
+ * beats reading twice).
+ */
+function readStateForPrototyping(stateFile) {
+  const empty = { prototyping: '', decisionsMap: Object.create(null) };
+  if (!stateFile) return empty;
+  let content;
+  try { content = fs.readFileSync(stateFile, 'utf8'); } catch { return empty; }
+  const out = { prototyping: '', decisionsMap: Object.create(null) };
+  const protoMatch = content.match(/<prototyping>([\s\S]*?)<\/prototyping>/);
+  if (protoMatch) out.prototyping = protoMatch[1];
+  const decBlock = content.match(/<decisions>([\s\S]*?)<\/decisions>/);
+  if (decBlock) {
+    const re = /^\s*(D-\d+)\s*:\s*(.+?)\s*$/gm;
+    let m;
+    while ((m = re.exec(decBlock[1])) !== null) {
+      // Strip a trailing `(locked)` / `(tentative)` qualifier if present.
+      out.decisionsMap[m[1]] = m[2].replace(/\s*\((?:locked|tentative)\)\s*$/i, '').trim();
+    }
+  }
+  return out;
+}
+
+/**
+ * Parse `<prototyping>` body into typed entries. Skips comments and unknown tags.
+ */
+function parsePrototypingEntries(body) {
+  const entries = [];
+  if (!body) return entries;
+  const re = /<(sketch|spike|skipped)\b([^>]*?)\/>/g;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const type = m[1];
+    const attrs = parseAttrs(m[2]);
+    entries.push({ type, attrs });
+  }
+  return entries;
+}
+
+/**
+ * Tokenize a slug / basename / path for fuzzy comparison.
+ * Splits on hyphens, underscores, dots, and path separators; lowercases;
+ * drops common no-signal tokens (`md`, file extensions, single chars).
+ */
+function tokenize(s) {
+  if (!s) return [];
+  const parts = String(s).toLowerCase().split(/[-_./\\\s]+/).filter(Boolean);
+  const stop = new Set(['md', 'txt', 'json', 'ts', 'js', 'plan', 'context', 'state']);
+  return parts.filter((p) => p.length > 1 && !stop.has(p));
+}
+
+/**
+ * Score a prototyping entry against the opened file's basename + relPath tokens.
+ * Returns the entry's matcher term if any slug-token is shared with a
+ * basename/relPath token (case-insensitive). Falls back to plain substring
+ * for terms that don't tokenize (e.g., free-form `reason` strings).
+ *
+ * Symmetric with the D-XX matcher: the existing recall path greps source
+ * lines for the opened file's basename; here we surface a prototyping entry
+ * whenever it would have grepped successfully — when the entry's slug
+ * mentions the same concept the file's name encodes.
+ */
+function matchPrototypingEntry(entry, basename, relPath) {
+  let term;
+  if (entry.type === 'sketch' || entry.type === 'spike') {
+    term = entry.attrs.slug;
+  } else if (entry.type === 'skipped') {
+    term = entry.attrs.reason;
+  }
+  if (!term) return null;
+  const fileTokens = new Set([...tokenize(basename), ...tokenize(relPath)]);
+  if (fileTokens.size === 0) return null;
+  const termTokens = tokenize(term);
+  for (const t of termTokens) {
+    if (fileTokens.has(t)) return term;
+  }
+  // Fallback: plain substring (helps `reason` strings and slugs containing
+  // tokens that don't survive the stop-word filter).
+  const needle = String(term).toLowerCase();
+  if (basename.toLowerCase().includes(needle) || relPath.toLowerCase().includes(needle)) return term;
+  return null;
+}
+
+/**
+ * Format a single prototyping entry for the additionalContext block.
+ * Shape: "Prototyping outcome (cycle <cycle>): <type>/<slug> — D-<id> — <verdict-or-status>: <rationale>"
+ * Falls back gracefully when fields are missing (e.g., skipped entries lack a D-XX).
+ */
+function formatPrototypingEntry(entry, decisionsMap) {
+  const a = entry.attrs;
+  const cycle = a.cycle || '?';
+  const ident = a.slug || a.at || '?';
+  const segs = [`Prototyping outcome (cycle ${cycle}): ${entry.type}/${ident}`];
+  if (a.decision) {
+    const rationale = decisionsMap[a.decision];
+    segs.push(rationale ? `${a.decision} — ${rationale}` : a.decision);
+  }
+  if (entry.type === 'spike' && a.verdict) {
+    segs.push(`verdict: ${a.verdict}`);
+  } else if (a.status) {
+    segs.push(`status: ${a.status}`);
+  } else if (entry.type === 'skipped' && a.reason) {
+    segs.push(`reason: ${a.reason}`);
+  }
+  return segs.join(' — ');
+}
+
+/**
+ * Build the prototyping outcomes block. Returns null when nothing matches so the
+ * caller can decide whether to omit the heading entirely.
+ *
+ * Sort: most recent cycle first (matches the existing sortKeyFor recency bias).
+ */
+function buildPrototypingBlock(stateFile, basename, relPath) {
+  if (!stateFile) return null;
+  const { prototyping, decisionsMap } = readStateForPrototyping(stateFile);
+  if (!prototyping) return null;
+  const entries = parsePrototypingEntries(prototyping);
+  if (!entries.length) return null;
+
+  const matched = [];
+  for (const e of entries) {
+    const term = matchPrototypingEntry(e, basename, relPath);
+    if (term) matched.push(e);
+  }
+  if (!matched.length) return null;
+
+  // Recency: cycle is typically `cycle-N` or `N`; coerce to a number for sorting.
+  const cycleNum = (e) => {
+    const c = String(e.attrs.cycle || '');
+    const m = c.match(/(\d+)/);
+    return m ? Number(m[1]) : 0;
+  };
+  matched.sort((a, b) => cycleNum(b) - cycleNum(a));
+  const top = matched.slice(0, PROTOTYPING_TOP_N);
+
+  const lines = [];
+  lines.push('');
+  lines.push('### Prior prototyping outcomes');
+  for (const e of top) {
+    lines.push(`> - ${formatPrototypingEntry(e, decisionsMap)}`);
+  }
+  if (matched.length > PROTOTYPING_TOP_N) {
+    lines.push(`> … (${matched.length - PROTOTYPING_TOP_N} more prototyping entr${matched.length - PROTOTYPING_TOP_N === 1 ? 'y' : 'ies'})`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
 function buildRecallBlock(matches, basename, backendLabel) {
   if (!matches.length) return null;
   const uniq = [];
@@ -202,16 +371,27 @@ async function main() {
 
   const backendLabel = BACKEND || (useRgGlobal ? 'ripgrep' : 'node-grep');
   const block = buildRecallBlock(hits, basename, backendLabel);
-  if (!block) {
+
+  // Phase 25 (plan 25-06): surface <prototyping> outcomes when an opened
+  // planning/design .md ≥1500 bytes shares a slug/reason token with a
+  // resolved sketch/spike/skipped entry. STATE.md is the canonical home for
+  // the block (D-01); we read it directly here rather than via the TS parser
+  // so the hook stays self-contained JS.
+  const stateFile = sources.find((p) => p.endsWith(path.sep + 'STATE.md') || p.endsWith('/STATE.md'));
+  const protoBlock = buildPrototypingBlock(stateFile, basename, relPath);
+
+  if (!block && !protoBlock) {
     try { require('./_hook-emit.js').emitHookFired('gdd-decision-injector', 'no-hits', { backend: backendLabel }); } catch { /* swallow */ }
     process.stdout.write(JSON.stringify({ continue: true }));
     return;
   }
 
-  try { require('./_hook-emit.js').emitHookFired('gdd-decision-injector', 'inject', { backend: backendLabel, hit_count: hits.length }); } catch { /* swallow */ }
+  const additionalContext = [block, protoBlock].filter(Boolean).join('\n');
+
+  try { require('./_hook-emit.js').emitHookFired('gdd-decision-injector', 'inject', { backend: backendLabel, hit_count: hits.length, prototyping: !!protoBlock }); } catch { /* swallow */ }
   process.stdout.write(JSON.stringify({
     continue: true,
-    hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext: block },
+    hookSpecificOutput: { hookEventName: 'PreToolUse', additionalContext },
   }));
 }