@hegemonart/get-design-done 1.31.0 → 1.32.0

package/skills/router/router-pick-emitter.md

@@ -0,0 +1,78 @@
+# gdd-router — router_pick emitter (Phase 32-08 / D-02)
+
+Co-located reference for `skills/router/SKILL.md` — split out per the Phase 28.5
+contract (router SKILL ≤100 lines) and the Phase 28.6 co-location pattern (same
+convention as the sibling `./capability-gap-emitter.md`).
+
+## When to emit
+
+When the router resolves an intent to a concrete pick — i.e. it has selected the
+`path` / `complexity_class` / `resolved_models` decision and is about to return
+its decision JSON — emit ONE `router_pick` event recording WHICH skill/agent it
+auto-picked. Emit exactly once per resolved pick, as the LAST step before
+returning the decision JSON to the caller.
+
+This is the D-02 router_pick instrument: GDD routes by description-match but has
+no record of what the router actually reaches for, so there is no data on
+under-reached skills. Phase 33 reads these events from the chain file
+(`.design/gep/events.jsonl`) to baseline per-skill auto-pick rates (the
+"pick-rate regression" expansion in the ROADMAP).
+
+`router_pick` is NOT `capability_gap`: emit `router_pick` when the router DID
+resolve a pick; emit `capability_gap` (see `./capability-gap-emitter.md`) only
+when it could not resolve the intent at all. They are disjoint surfaces.
+
+## Synchronous emitter snippet
+
+Builds the 7-field `RouterPickPayload` and writes it via `appendChainEvent`.
+The intent is hashed — the raw prompt is NEVER stored (no PII). `picked_skill`,
+`rank`, and `alternatives` come from the router's resolved decision:
+
+```bash
+node -e '
+const { appendChainEvent } = require("./scripts/lib/event-chain.cjs");
+const { createHash, randomUUID } = require("node:crypto");
+const intent = process.env.GDD_INTENT || "";
+const payload = {
+  event_id: randomUUID(),
+  source: "router",
+  picked_skill: process.env.GDD_PICKED_SKILL || "",
+  context_hash: createHash("sha256").update(intent).digest("hex"),
+  rank: Number(process.env.GDD_PICK_RANK || 0),
+  alternatives: (process.env.GDD_ALTERNATIVES || "").split(",").filter(Boolean),
+  ts: new Date().toISOString(),
+};
+appendChainEvent({
+  agent: "router",
+  outcome: "router_pick",
+  payload,
+  type: "router_pick",
+  timestamp: new Date().toISOString(),
+  sessionId: process.env.GDD_SESSION_ID || "router-cli",
+});
+'
+```
+
+`GDD_PICKED_SKILL` is the resolved pick; `GDD_PICK_RANK` is its rank among
+candidates (0 = top pick); `GDD_ALTERNATIVES` is a comma-separated list of the
+OTHER candidate skill/agent names the router considered (names only — no scores,
+no prompt text). `GDD_INTENT` is hashed in-process and is never written to disk.
+
+## Notes
+
+- **No PII**: only `context_hash` (sha256 of the intent) is stored — never the
+  raw prompt or intent string. The `RouterPickPayload` is
+  `additionalProperties: false`, so a stray `raw_prompt` field would be rejected
+  by `events.schema.json` validation. This mirrors `capability_gap`'s hash
+  discipline.
+- **Router output JSON contract is UNCHANGED** — `router_pick` is a SIDE EFFECT,
+  not a new output field. Back-compat is preserved exactly as the existing
+  `## Output schema versioning` table in `SKILL.md` guarantees; the emitter runs
+  AFTER the decision is computed and does not alter the returned blob.
+- The 7-field payload flows through `appendChainEvent`'s opaque-extras pattern
+  verbatim; the chain row carries `type`, `timestamp`, `sessionId`, `payload` as
+  opaque extras and is projected back to the events-schema envelope by Phase 33
+  aggregation (same projection the capability_gap aggregation uses).
+- Validated against the additive `RouterPickPayload` branch (allOf[2]) in
+  `reference/schemas/events.schema.json` — see
+  `test/suite/router-pick-event.test.cjs`.

package/skills/using-gdd/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: using-gdd
+description: "Use when starting any GDD session — establishes how to find and apply GDD skills."
+disable-model-invocation: true
+---
+<SUBAGENT-STOP>
+
+# Using GDD
+
+This is the bootstrap discipline contract for every Get Design Done session. Read it
+first; it tells you how to find and apply the right GDD skill before you act.
+
+## The 1% rule
+
+**If you think there is even a 1% chance a skill might apply, you ABSOLUTELY MUST invoke the skill.**
+
+In GDD, almost every request maps to a pipeline stage — brief, explore, plan, design,
+verify — or to a cross-cutting skill (discuss, audit, style, darkmode). When in doubt,
+search for and read the skill's body. The cost of reading a skill is trivial; the cost of
+free-handing a stage is rework, scope creep, and a broken pipeline state.
+
+## Red flags — Thought → Reality
+
+When you catch yourself thinking any of the following, STOP and check for a skill.
+
+| Thought | Reality |
+| --- | --- |
+| This is just a simple design question. | Questions are tasks. Check for a skill. |
+| I'll just tweak the CSS directly. | Token changes go through the pipeline — check /gdd:design. |
+| I already know the codebase, skip explore. | Explore probes connections you haven't re-checked this cycle. |
+| This change is too small to plan. | Plan-skipped tasks blow scope per cycle telemetry. Run /gdd:plan. |
+| I can write the brief later. | No brief means no shared problem statement — /gdd:brief comes first. |
+| The user clearly wants X, I'll skip discuss. | Ambiguity hides here. /gdd:discuss surfaces the real constraint. |
+| I'll verify by eyeballing it. | Verification is a stage with criteria — run /gdd:verify, don't guess. |
+| It's obviously a dark-mode tweak. | Color-scheme work has its own skill — check /gdd:darkmode. |
+| Let me just compare these two designs quickly. | Comparison is an audit task — /gdd:compare has the rubric. |
+| This is a one-off, no skill needed. | "One-off" is the most common rationalization in the telemetry. Check anyway. |
+| I'll refactor the style tokens by hand. | /gdd:style owns token edits so the pipeline stays consistent. |
+| The audit can wait until after I ship. | An un-audited cycle is an unverified cycle — /gdd:audit before close. |
+
+## Skill priority order
+
+When more than one skill could apply, resolve in this order:
+
+1. **Process** — brief / explore / discuss. Establish the problem and context first.
+2. **Implementation** — design / style / darkmode. Only after process is settled.
+3. **Audit** — verify / compare / audit. Close the loop before declaring done.
+
+Never run an Implementation skill before the Process skills that gate it have produced
+their artifact. Never declare a cycle complete without an Audit skill.
+
+## Instruction priority
+
+When instructions conflict, obey this precedence (highest first):
+
+1. **The user's CLAUDE.md** — project- and user-level directives always win.
+2. **GDD skills** — the skill body is the source of truth for how a stage runs.
+3. **Defaults** — your own general training and habits come last.
+
+If a GDD skill contradicts the user's CLAUDE.md, the CLAUDE.md wins and you flag the
+conflict. If your instinct contradicts a GDD skill, the skill wins.
+
+## GDD pipeline flow
+
+The core flow is **Brief → Explore → Plan → Design → Verify**, with branch points:
+
+- **Brief** captures the problem (`/gdd:brief`). Branch: a rough idea can sketch or spike
+  off the brief before exploration; a changed problem loops back via `--re-brief`.
+- **Explore** scans the codebase and connections (`/gdd:explore`) — even on a familiar
+  repo, because connections drift each cycle.
+- **Plan** decomposes work into tasks (`/gdd:plan`). Skipping it is the top cause of scope
+  blow-up; small tasks still get a plan.
+- **Design** implements (`/gdd:design`, with `/gdd:style` and `/gdd:darkmode` as
+  implementation peers). Implementation never runs ahead of an approved plan.
+- **Verify** checks against criteria (`/gdd:verify`), then `/gdd:audit` / `/gdd:compare`
+  close the loop. On pass the cycle completes; on fail it loops back to the failing stage.
+
+`/gdd:discuss` runs alongside any stage to resolve ambiguity before it propagates.

package/skills/verify/SKILL.md

@@ -93,4 +93,21 @@ Full prompts + branching: `./verify-procedure.md` §Step 3.
 
 Print the `=== Verify complete ===` summary (status, gap counts, agent paths, next-step suggestion) from `./verify-procedure.md` §After Completion.
 
+<HARD-GATE>
+Do NOT mark the cycle complete until the user has reviewed `.design/DESIGN-VERIFICATION.md`. If this project uses a custom `.design` location, read the artifact path from `.design/STATE.md` rather than assuming the default.
+</HARD-GATE>
+
+## Rationalizations — Thought to Reality
+
+The reasons an agent gives to skip or weaken verification, and what each one lets through:
+
+| Thought | Reality |
+|---------|---------|
+| "The implementation looks right, I can skip the verifier spawn." | Skipping verification ships unchecked must-haves; the 5-phase verifier exists to catch what "looks right" misses. |
+| "The integration-checker is redundant with the auditor." | The auditor scores quality; the integration-checker proves each D-XX is actually wired — an orphaned decision passes the audit but fails the product. |
+| "These gaps are minor, I'll accept-as-is without a blocker." | Accept-as-is without recording the unresolved gaps erases the trail; the next cycle re-discovers them from scratch. |
+| "The quality gate timed out, I'll treat that as a pass." | Timeout is a signal, not a pass — masking it lets a genuinely failing gate slip through to ship. |
+| "I'll loop the fixer a fourth time to clear the last gap." | The 3-iteration cap exists because a gap surviving three fixes is a design problem, not a code problem — save and escalate. |
+| "Post-handoff bundles don't need the faithfulness check." | Skipping the handoff-faithfulness section means a divergence from the source design ships unflagged. |
+
 ## VERIFY COMPLETE

package/scripts/aggregate-agent-metrics.ts

@@ -1,282 +0,0 @@
-#!/usr/bin/env node
-/**
- * aggregate-agent-metrics.ts — Incremental per-agent aggregator.
- *
- * Reads: .design/telemetry/costs.jsonl (append-only ledger from
- *        hooks/budget-enforcer.js)
- *        agents/{agent}.md (frontmatter source for default-tier, parallel-safe,
- *        reads-only, typical-duration-seconds)
- * Writes: .design/agent-metrics.json (atomic overwrite via tmp-file + rename)
- *         .design/telemetry/phase-totals.json (same, WR-02)
- *
- * Invoked:
- *   1. Detached child of hooks/budget-enforcer.js after every telemetry write.
- *   2. Directly by /gdd:optimize skill as an explicit refresh step.
- *   3. Manually: `node --experimental-strip-types scripts/aggregate-agent-metrics.ts`
- *   4. With `--help` to print usage (used by the Plan 20-00 smoke check).
- *
- * OPT-09 contract: fields must match Phase 11 reflector's expectations.
- *
- * Converted from scripts/aggregate-agent-metrics.js in Plan 20-00 (Tier-1).
- * Behavior preserved verbatim.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  renameSync,
-} from 'node:fs';
-import { join, dirname, basename } from 'node:path';
-
-// Generated-type import (unused at runtime, erased by strip-types) to satisfy
-// Plan 20-00's requirement that every Tier-1 TS file participates in the
-// codegen graph. We pick AuthoritySnapshotSchema as a stable anchor and
-// re-export for downstream callers.
-import type { AuthoritySnapshotSchema } from '../reference/schemas/generated.js';
-export type { AuthoritySnapshotSchema };
-
-const CWD: string = process.cwd();
-const TELEMETRY_PATH: string = join(CWD, '.design', 'telemetry', 'costs.jsonl');
-const METRICS_PATH: string = join(CWD, '.design', 'agent-metrics.json');
-const PHASE_TOTALS_PATH: string = join(CWD, '.design', 'telemetry', 'phase-totals.json');
-const AGENTS_DIR: string = join(CWD, 'agents');
-
-/**
- * Subset of the agent-markdown frontmatter we care about. `null` means the
- * field is absent or unparseable (aggregator is tolerant — degraded mode
- * preferred over hard-fail per OPT-09).
- */
-interface AgentFrontmatter {
-  default_tier: string | null;
-  parallel_safe: boolean | null;
-  reads_only: boolean | null;
-  typical_duration_seconds: number | null;
-}
-
-/** ---- frontmatter reader (no YAML dep) ---- */
-function readAgentFrontmatter(agentName: string): Partial<AgentFrontmatter> {
-  const p: string = join(AGENTS_DIR, `${agentName}.md`);
-  if (!existsSync(p)) return {};
-  try {
-    const content: string = readFileSync(p, 'utf8');
-    const fm = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!fm) return {};
-    const body: string = fm[1] ?? '';
-    const get = (key: string): string | null => {
-      const m = body.match(new RegExp(`^${key}:\\s*"?([^"\\n]+)"?`, 'm'));
-      return m && m[1] !== undefined ? m[1].trim() : null;
-    };
-    const defaultTier: string | null = get('default-tier');
-    const parallelSafe: string | null = get('parallel-safe');
-    const readsOnly: string | null = get('reads-only');
-    const typicalDuration: string | null = get('typical-duration-seconds');
-    return {
-      default_tier: defaultTier ?? null,
-      parallel_safe: parallelSafe === null ? null : /^(true|yes)$/i.test(parallelSafe),
-      reads_only: readsOnly === null ? null : /^(true|yes)$/i.test(readsOnly),
-      typical_duration_seconds:
-        typicalDuration === null ? null : Number(typicalDuration) || null,
-    };
-  } catch {
-    return {};
-  }
-}
-
-/**
- * Shape of a single row in .design/telemetry/costs.jsonl. Mirrors the OPT-09
- * schema: nine mandatory fields + four optional diagnostic fields. Unknown
- * keys are tolerated (Phase 11 reflector ignores them).
- */
-export interface CostRow {
-  ts?: string;
-  agent?: string;
-  tier?: string;
-  tokens_in?: number | string;
-  tokens_out?: number | string;
-  cache_hit?: boolean;
-  est_cost_usd?: number | string;
-  cycle?: string;
-  phase?: string;
-  // Optional / diagnostic
-  tier_downgraded?: boolean;
-  enforcement_mode?: string;
-  lazy_skipped?: boolean;
-  block_reason?: string;
-}
-
-/** ---- telemetry reader ---- */
-function readTelemetryRows(): CostRow[] {
-  if (!existsSync(TELEMETRY_PATH)) return [];
-  const raw: string = readFileSync(TELEMETRY_PATH, 'utf8');
-  const out: CostRow[] = [];
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    try {
-      out.push(JSON.parse(line) as CostRow);
-    } catch {
-      // tolerant: skip malformed lines (partial write, truncation)
-    }
-  }
-  return out;
-}
-
-/** Per-agent roll-up accumulator. */
-interface AgentAccumulator {
-  total_spawns: number;
-  total_cost_usd: number;
-  total_tokens_in: number;
-  total_tokens_out: number;
-  cache_hits: number;
-  lazy_skips: number;
-}
-
-/** Final per-agent shape written to .design/agent-metrics.json. */
-export interface AgentMetrics {
-  typical_duration_seconds: number | null | undefined;
-  default_tier: string | null | undefined;
-  parallel_safe: boolean | null | undefined;
-  reads_only: boolean | null | undefined;
-  total_spawns: number;
-  total_cost_usd: number;
-  total_tokens_in: number;
-  total_tokens_out: number;
-  cache_hit_rate: number;
-  lazy_skip_rate: number;
-}
-
-/** ---- aggregator ---- */
-function aggregate(rows: readonly CostRow[]): Record<string, AgentMetrics> {
-  const byAgent = new Map<string, AgentAccumulator>();
-  for (const r of rows) {
-    // Blocked rows represent a spawn that was denied at the hook — the agent
-    // never actually ran, so it must not contribute to spawn counts, cost, or
-    // token totals. Skip them here (mirror of the filter in aggregateByPhase).
-    if (r.block_reason) continue;
-    const agent: string = r.agent ?? 'unknown';
-    let a = byAgent.get(agent);
-    if (!a) {
-      a = {
-        total_spawns: 0,
-        total_cost_usd: 0,
-        total_tokens_in: 0,
-        total_tokens_out: 0,
-        cache_hits: 0,
-        lazy_skips: 0,
-      };
-      byAgent.set(agent, a);
-    }
-    a.total_spawns += 1;
-    a.total_cost_usd += Number(r.est_cost_usd ?? 0);
-    a.total_tokens_in += Number(r.tokens_in ?? 0);
-    a.total_tokens_out += Number(r.tokens_out ?? 0);
-    if (r.cache_hit === true) a.cache_hits += 1;
-    if (r.lazy_skipped === true) a.lazy_skips += 1;
-  }
-
-  const out: Record<string, AgentMetrics> = {};
-  for (const [agent, a] of byAgent.entries()) {
-    const fm = readAgentFrontmatter(agent);
-    const spawns: number = a.total_spawns || 1; // guard div-by-zero
-    out[agent] = {
-      typical_duration_seconds: fm.typical_duration_seconds,
-      default_tier: fm.default_tier,
-      parallel_safe: fm.parallel_safe,
-      reads_only: fm.reads_only,
-      total_spawns: a.total_spawns,
-      total_cost_usd: Number(a.total_cost_usd.toFixed(6)),
-      total_tokens_in: a.total_tokens_in,
-      total_tokens_out: a.total_tokens_out,
-      cache_hit_rate: Number((a.cache_hits / spawns).toFixed(4)),
-      lazy_skip_rate: Number((a.lazy_skips / spawns).toFixed(4)),
-    };
-  }
-  return out;
-}
-
-/** ---- atomic write ---- */
-function writeAtomic(filePath: string, content: string): void {
-  const dir: string = dirname(filePath);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  const tmp: string = join(
-    dir,
-    `.${basename(filePath)}.${process.pid}.${Date.now()}.tmp`,
-  );
-  writeFileSync(tmp, content, 'utf8');
-  renameSync(tmp, filePath);
-}
-
-/** ---- phase totals aggregator (WR-02: avoids full JSONL replay in budget enforcer) ---- */
-function aggregateByPhase(rows: readonly CostRow[]): Record<string, number> {
-  const byPhase: Record<string, number> = {};
-  for (const r of rows) {
-    // Blocked rows represent spawns that were denied by the hook — the agent
-    // never ran, so their est_cost_usd must not inflate cumulative phase spend.
-    // Counting them would make future hard-block and soft-threshold checks
-    // stricter than intended on every repeat cap hit.
-    if (r.block_reason) continue;
-    const phase: string = r.phase ?? 'unknown';
-    byPhase[phase] = (byPhase[phase] ?? 0) + Number(r.est_cost_usd ?? 0);
-  }
-  // Round to 6dp to match per-agent precision
-  for (const k of Object.keys(byPhase)) {
-    const v: number = byPhase[k] ?? 0;
-    byPhase[k] = Number(v.toFixed(6));
-  }
-  return byPhase;
-}
-
-/** ---- usage / --help ---- */
-function printHelp(): void {
-  console.log(
-    `aggregate-agent-metrics.ts — Aggregate per-agent telemetry from .design/telemetry/costs.jsonl.\n` +
-      `\n` +
-      `Usage:\n` +
-      `  node --experimental-strip-types scripts/aggregate-agent-metrics.ts\n` +
-      `  node --experimental-strip-types scripts/aggregate-agent-metrics.ts --help\n` +
-      `\n` +
-      `Reads:  .design/telemetry/costs.jsonl\n` +
-      `        agents/<agent>.md (frontmatter)\n` +
-      `Writes: .design/agent-metrics.json\n` +
-      `        .design/telemetry/phase-totals.json\n` +
-      `\n` +
-      `Invoked:\n` +
-      `  - Detached child of hooks/budget-enforcer.js after every telemetry row.\n` +
-      `  - Directly by /gdd:optimize as an explicit refresh step.\n` +
-      `  - Manually, on demand.\n`,
-  );
-}
-
-/** ---- main ---- */
-function main(): void {
-  if (process.argv.includes('--help') || process.argv.includes('-h')) {
-    printHelp();
-    process.exit(0);
-  }
-
-  const rows: CostRow[] = readTelemetryRows();
-  const agents = aggregate(rows);
-  const payload = {
-    generated_at: new Date().toISOString(),
-    agents,
-  };
-  writeAtomic(METRICS_PATH, JSON.stringify(payload, null, 2) + '\n');
-  // Write lightweight phase-totals.json so budget-enforcer can read phase
-  // spend in O(1) without replaying the full JSONL on every agent spawn
-  // (WR-02).
-  const phaseTotals = {
-    generated_at: new Date().toISOString(),
-    totals: aggregateByPhase(rows),
-  };
-  writeAtomic(PHASE_TOTALS_PATH, JSON.stringify(phaseTotals, null, 2) + '\n');
-}
-
-try {
-  main();
-} catch (err) {
-  // Fail open: aggregator must never block the hook or /gdd:optimize flow.
-  const msg: string = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`aggregate-agent-metrics: ${msg}\n`);
-  process.exit(0);
-}

package/scripts/bootstrap-manifest.txt

@@ -1,3 +0,0 @@
-get-design-done-bootstrap
-v1
-awesome-design-md@VoltAgent

package/scripts/bootstrap.sh

@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-# get-design-done bootstrap
-# Auto-provisions companion resources that get-design-done references but which
-# are not Claude Code plugins (so they cannot be listed in `dependencies`).
-#
-# Runs on SessionStart. Idempotent: uses a marker in ${CLAUDE_PLUGIN_DATA} so it
-# only performs network work on first install or when the bundled manifest changes.
-#
-# Resources provisioned:
-#   - ~/.claude/libs/awesome-design-md  (VoltAgent/awesome-design-md)
-#
-# Resources NOT provisioned (install separately, see README):
-#   - emil-design-eng skill — no canonical upstream
-#   - refero MCP — optional, add to your Claude config if you have access
-
-set -u
-
-PLUGIN_DATA="${CLAUDE_PLUGIN_DATA:-$HOME/.claude/plugins/data/get-design-done}"
-PLUGIN_DATA="${PLUGIN_DATA//\\//}"  # Normalize Windows backslashes to forward slashes
-PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}"
-PLUGIN_ROOT="${PLUGIN_ROOT//\\//}"  # Normalize Windows backslashes to forward slashes
-MANIFEST="${PLUGIN_ROOT}/scripts/bootstrap-manifest.txt"
-MARKER="${PLUGIN_DATA}/bootstrap-manifest.txt"
-
-mkdir -p "${PLUGIN_DATA}" "${HOME}/.claude/libs" "${HOME}/.claude/skills"
-
-# Skip if bundled manifest matches the last-run marker (no-op on every other session).
-if [[ -f "${MANIFEST}" && -f "${MARKER}" ]] && diff -q "${MANIFEST}" "${MARKER}" >/dev/null 2>&1; then
-  exit 0
-fi
-
-log() { printf '[get-design-done bootstrap] %s\n' "$*" >&2; }
-
-clone_or_update() {
-  local repo_url="$1"
-  local target="$2"
-  if [[ -d "${target}/.git" ]]; then
-    log "updating ${target}"
-    git -C "${target}" pull --quiet --ff-only 2>/dev/null || log "pull failed for ${target} (continuing)"
-  elif [[ -d "${target}" ]]; then
-    log "${target} exists and is not a git checkout — skipping"
-  else
-    log "cloning ${repo_url} -> ${target}"
-    git clone --quiet --depth 1 "${repo_url}" "${target}" || log "clone failed for ${repo_url}"
-  fi
-}
-
-# Required library: awesome-design-md
-clone_or_update "https://github.com/VoltAgent/awesome-design-md.git" "${HOME}/.claude/libs/awesome-design-md"
-
-# Soft notice for companion skills we cannot auto-install.
-if [[ ! -d "${HOME}/.claude/skills/emil-design-eng" ]]; then
-  log "optional: emil-design-eng skill not found in ~/.claude/skills. See get-design-done README for install options."
-fi
-
-# Phase 10.1: ensure .design/budget.json exists with defaults (D-12)
-DESIGN_DIR="$(pwd)/.design"
-mkdir -p "${DESIGN_DIR}"
-if [ ! -f "${DESIGN_DIR}/budget.json" ]; then
-  cat > "${DESIGN_DIR}/budget.json" <<'BUDGET_EOF'
-{
-  "per_task_cap_usd": 2.00,
-  "per_phase_cap_usd": 20.00,
-  "tier_overrides": {},
-  "auto_downgrade_on_cap": true,
-  "cache_ttl_seconds": 3600,
-  "enforcement_mode": "enforce"
-}
-BUDGET_EOF
-fi
-
-# Phase 10.1: ensure .design/telemetry/ directory is writable
-mkdir -p "${DESIGN_DIR}/telemetry"
-
-# Record success so we don't re-run until the bundled manifest changes.
-if [[ -f "${MANIFEST}" ]]; then
-  cp "${MANIFEST}" "${MARKER}"
-fi
-
-exit 0