@wazir-dev/cli 1.2.0 → 1.4.0

package/skills/writing-skills/persuasion-principles.md

@@ -2,49 +2,115 @@
 
 ## Overview
 
-LLMs respond to the same persuasion principles as humans. Understanding this psychology helps you design more effective skills - not to manipulate, but to ensure critical practices are followed even under pressure.
+LLMs exhibit statistical compliance biases that can be leveraged to improve instruction following. This is not psychology applied to machines — it is empirical prompt engineering grounded in attention mechanics, training distribution effects, and measured compliance rates.
 
-**Research foundation:** Meincke et al. (2025) tested 7 persuasion principles with N=28,000 AI conversations. Persuasion techniques more than doubled compliance rates (33% -> 72%, p < .001).
+**Research foundation:** Meincke et al. (2025) tested 7 persuasion principles with N=28,000 AI conversations. Commitment priming approached 100% compliance. Positive directive framing consistently outperformed negative framing. Authority framing lifted compliance by ~40pp.
 
-## The Seven Principles
+## Principles Ranked by Evidence Strength
 
-### 1. Authority
-- Imperative language: "YOU MUST", "Never", "Always"
-- Non-negotiable framing: "No exceptions"
-- Eliminates decision fatigue and rationalization
+### Tier 1: Strong Evidence, Large Effect
 
-### 2. Commitment
-- Require announcements: "Announce skill usage"
-- Force explicit choices: "Choose A, B, or C"
-- Use tracking: TodoWrite for checklists
+**1. Commitment Priming (highest impact)**
+- Have the model announce its plan before executing
+- Autoregressive consistency: once the model generates "I will do X", it is statistically more likely to do X
+- Implementation: "Before executing, state which steps you will perform"
+- Measured: near-100% compliance after self-commitment in Meincke et al.
 
-### 3. Scarcity
-- Time-bound requirements: "Before proceeding"
-- Sequential dependencies: "Immediately after X"
-- Prevents procrastination
+**2. Positive Directive Framing**
+- "Always do X" consistently outperforms "Never do Y"
+- Token generation selects what to produce, not what to avoid
+- Negative instructions ("do NOT mention X") can paradoxically increase mentions
+- Use negative framing ONLY for critical guardrails with a positive alternative: "Do NOT skip review. Instead, run review quickly."
 
-### 4. Social Proof
-- Universal patterns: "Every time", "Always"
-- Failure modes: "X without Y = failure"
-- Establishes norms
+**3. Structural Isolation (XML Tags)**
+- Claude is fine-tuned to attend to XML tag boundaries
+- Tags create attention-weight spikes and trust boundaries
+- Use `<rules>`, `<instructions>`, `<output_format>` for hard boundaries
+- Hybrid XML+markdown is optimal: XML for structure, markdown for formatting within sections
 
-### 5. Unity
-- Collaborative language: "our codebase", "we're colleagues"
-- Shared goals: "we both want quality"
+**4. Positional Privilege (Primacy + Recency)**
+- First ~500 tokens: ~95% compliance (primacy zone)
+- Last ~500 tokens: ~85% compliance (recency zone)
+- Middle of long context: ~65-75% compliance (lost in the middle)
+- Critical rules go at beginning AND end. Never only in the middle.
 
-### 6. Reciprocity
-- Obligation to return favors
-- "I'll give you full context, you give me honest assessment"
+### Tier 2: Strong Evidence, Moderate Effect
 
-### 7. Liking
-- Avoid in discipline-enforcing skills
-- Use sparingly for collaborative skills
+**5. Authority / Role Assignment**
+- "You are a senior security auditor responsible for..." activates domain-specific patterns
+- +40pp lift in Meincke et al.
+- Expert personas produce more accurate, more disciplined output
+
+**6. Consequence Framing**
+- "Skipping this step causes silent regressions that waste hours of debugging"
+- Provides reasoning context for why compliance matters
+- More effective than abstract rules ("always follow the process")
+
+**7. Implementation Intentions (IF-THEN rules)**
+- "IF user says skip → THEN say 'Running it quickly' and execute"
+- Pre-decides the response — no judgment call needed at runtime
+- d=0.65 across 94 psychology studies (Gollwitzer). Maps directly to LLM prompt design.
+- Single most actionable technique for skill authors
+
+**8. Redundant Reinforcement**
+- State the rule, show an example, reference it in the output format, add a constraint tag
+- Multiple encoding paths survive when any single one fails
+- Paraphrased repetition (2-3x) outperforms verbatim repetition
+
+### Tier 3: Context-Dependent Effect
+
+**9. Social Proof**
+- "Standard practice is..." or "All production systems follow this pattern"
+- Effective when baseline compliance is already moderate (+6pp)
+
+**10. Urgency / Scarcity**
+- "This must be done correctly the first time; there is no retry"
+- Increases both compliance and output variance — use sparingly
+
+**11. Moral / Ethical Framing**
+- "Omitting this would produce misleading output"
+- Effective for Claude specifically due to Constitutional AI training
+- Frame positively (good outcome of compliance) not negatively
+
+## Anti-Patterns
+
+| Pattern | Problem |
+|---------|---------|
+| Negative instructions without alternatives | "Don't do X" fails — model must activate X to evaluate constraint |
+| Instruction overload (>12 constraints) | Steep compliance drop after ~12 accumulated constraints |
+| Threats without specifics | "You will be punished" increases variance without improving median |
+| Reciprocity framing | "I helped you, now help me" — weakest principle, only +11pp |
+| Relying solely on alignment | 80% of enterprises reported injection incidents. Structural defenses needed. |
 
 ## Principle Combinations by Skill Type
 
-| Skill Type | Use | Avoid |
-|------------|-----|-------|
-| Discipline-enforcing | Authority + Commitment + Social Proof | Liking, Reciprocity |
-| Guidance/technique | Moderate Authority + Unity | Heavy authority |
-| Collaborative | Unity + Commitment | Authority, Liking |
-| Reference | Clarity only | All persuasion |
+| Skill Type | Primary Techniques | Avoid |
+|------------|-------------------|-------|
+| Discipline-enforcing (TDD, verification) | Commitment + Implementation Intentions + Positional Privilege + Authority | Liking, Reciprocity |
+| Process-governing (clarifier, executor) | Commitment + Consequence Framing + Structural Isolation | Heavy emotional framing |
+| Collaborative (brainstorming, design) | Moderate Authority + Implementation Intentions | Over-constraining creative steps |
+| Reference (docs, guides) | Structural Isolation + Positional Privilege | All persuasion — clarity only |
+
+## The 3-Zone Architecture
+
+Apply these principles through the 3-zone skill layout:
+
+- **Zone 1 (Primacy):** Identity + Iron Laws + Priority Stack — leverages positional privilege + authority + commitment
+- **Zone 2 (Process):** IF-THEN rules + decision tables + gate functions — leverages implementation intentions + structural isolation
+- **Zone 3 (Recency):** Restated laws + Red Flags + meta-instruction — leverages recency + redundant reinforcement + consequence framing
+
+## Temporal Testing Advisory
+
+Prompt engineering techniques lose effectiveness as models improve. Re-test skill compliance every major model version. Include a "last verified" date on persuasion-dependent skills.
+
+**Last verified:** Claude Opus 4.6, March 2026
+
+## Sources
+
+- Meincke et al. (2025). "Call Me A Jerk: Persuading AI to Comply" (N=28,000, SSRN)
+- Liu et al. (2024). "Lost in the Middle" (TACL, arXiv:2307.03172)
+- Wallace et al. (2024). "The Instruction Hierarchy" (OpenAI, arXiv:2404.13208)
+- Gollwitzer (1999). Implementation Intentions (d=0.65, 94 studies meta-analysis)
+- EmotionPrompt (2023). Emotional framing effects (arXiv:2307.11760)
+- Zhou et al. (2023). IFEval benchmark (arXiv:2311.07911)
+- Anthropic (2024). Claude Model Spec — instruction hierarchy documentation

package/tooling/src/capture/command.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 
 import { parseCommandOptions, parsePositiveInteger } from '../command-options.js';
 import { readYamlFile } from '../loaders.js';
+import { validateRunCompletion } from '../guards/phase-prerequisite-guard.js';
 import { findProjectRoot } from '../project-root.js';
 import { resolveStateRoot } from '../state-root.js';
 import {
@@ -18,6 +19,7 @@ import {
 } from './store.js';
 import { readRunConfig, getPhaseLoopCap } from './run-config.js';
 import { readUsage, generateReport, initUsage, recordCaptureSavings, recordPhaseUsage } from './usage.js';
+import { appendDecision } from './decision.js';
 import { evaluateLoopCapGuard } from '../guards/loop-cap-guard.js';
 import { evaluatePhasePrerequisiteGuard } from '../guards/phase-prerequisite-guard.js';
 
@@ -57,7 +59,7 @@ function resolveCaptureContext(parsed, context = {}) {
   const projectRoot = findProjectRoot(context.cwd ?? process.cwd());
   const manifest = readYamlFile(path.join(projectRoot, 'wazir.manifest.yaml'));
   const { options } = parseCommandOptions(parsed.args, {
-    boolean: ['json'],
+    boolean: ['json', 'complete'],
     string: [
       'run',
       'phase',
@@ -72,6 +74,8 @@ function resolveCaptureContext(parsed, context = {}) {
       'command',
       'exit-code',
       'task-id',
+      'decision',
+      'reason',
     ],
   });
   const stateRoot = resolveStateRoot(projectRoot, manifest, {
@@ -326,6 +330,21 @@ function handleSummary(parsed, context = {}) {
 
   const runPaths = getRunPaths(stateRoot, options.run);
   const status = readStatus(runPaths);
+
+  // Enforce workflow completion before allowing summary to finalize
+  if (options.complete) {
+    const projectRoot = findProjectRoot();
+    const manifestPath = path.join(projectRoot, 'wazir.manifest.yaml');
+    const result = validateRunCompletion(runPaths.runRoot, manifestPath);
+    if (!result.complete) {
+      const msg = `Run incomplete: ${result.missing.length} workflow(s) not finished: ${result.missing.join(', ')}`;
+      if (options.json) {
+        return { exitCode: 1, stdout: JSON.stringify({ run_id: options.run, complete: false, missing_workflows: result.missing, error: msg }, null, 2) + '\n' };
+      }
+      return { exitCode: 1, stderr: msg + '\n' };
+    }
+  }
+
   const eventName = options.event ?? 'pre_compact_summary';
   const summaryContent = readInput();
   const summaryPath = writeSummary(runPaths, summaryContent);
@@ -372,6 +391,29 @@ function handleUsage(parsed, context = {}) {
   };
 }
 
+function handleDecision(parsed, context = {}) {
+  const { stateRoot, options } = resolveCaptureContext(parsed, context);
+
+  requireOption(options, 'run', 'Usage: wazir capture decision --run <id> --phase <phase> --decision "<text>" --reason "<text>" [--task-id <id>] [--state-root <path>] [--json]');
+  requireOption(options, 'phase', 'Usage: wazir capture decision --run <id> --phase <phase> --decision "<text>" --reason "<text>" [--task-id <id>] [--state-root <path>] [--json]');
+  requireOption(options, 'decision', 'Usage: wazir capture decision --run <id> --phase <phase> --decision "<text>" --reason "<text>" [--task-id <id>] [--state-root <path>] [--json]');
+  requireOption(options, 'reason', 'Usage: wazir capture decision --run <id> --phase <phase> --decision "<text>" --reason "<text>" [--task-id <id>] [--state-root <path>] [--json]');
+
+  const runPaths = getRunPaths(stateRoot, options.run);
+  appendDecision(runPaths, {
+    phase: options.phase,
+    decision: options.decision,
+    reason: options.reason,
+    task_id: options.taskId,
+  });
+
+  return formatResult({
+    run_id: options.run,
+    event: 'decision',
+    decisions_path: runPaths.decisionsPath,
+  }, { json: options.json });
+}
+
 function handleLoopCheck(parsed, context = {}) {
   const { stateRoot, options } = resolveCaptureContext(parsed, context);
 
@@ -470,10 +512,12 @@ export function runCaptureCommand(parsed, context = {}) {
         return handleUsage(parsed, context);
       case 'loop-check':
         return handleLoopCheck(parsed, context);
+      case 'decision':
+        return handleDecision(parsed, context);
       default:
         return {
           exitCode: 1,
-          stderr: 'Usage: wazir capture <init|event|route|output|summary|usage|loop-check> ...\n',
+          stderr: 'Usage: wazir capture <init|event|route|output|summary|usage|loop-check|decision> ...\n',
         };
     }
   } catch (error) {

package/tooling/src/capture/decision.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+
+/**
+ * Append a decision entry to the run's NDJSON log.
+ *
+ * @param {object} runPaths - Run paths object (must include decisionsPath)
+ * @param {object} entry - { phase, decision, reason, task_id? }
+ */
+export function appendDecision(runPaths, { phase, decision, reason, task_id }) {
+  const record = {
+    timestamp: new Date().toISOString(),
+    phase: phase ?? 'unknown',
+    decision: decision ?? '',
+    reason: reason ?? '',
+  };
+  if (task_id) {
+    record.task_id = task_id;
+  }
+  fs.appendFileSync(runPaths.decisionsPath, JSON.stringify(record) + '\n');
+  return runPaths.decisionsPath;
+}
+
+/**
+ * Read all entries from a run's decisions log.
+ *
+ * @param {object} runPaths - Run paths object (must include decisionsPath)
+ * @returns {Array<object>}
+ */
+export function readDecisions(runPaths) {
+  if (!fs.existsSync(runPaths.decisionsPath)) return [];
+
+  return fs.readFileSync(runPaths.decisionsPath, 'utf8')
+    .split('\n')
+    .filter(line => line.trim())
+    .map(line => {
+      try { return JSON.parse(line); }
+      catch { return null; }
+    })
+    .filter(Boolean);
+}

package/tooling/src/capture/store.js

@@ -19,6 +19,7 @@ export function getRunPaths(stateRoot, runId) {
     capturesDir,
     statusPath: path.join(runRoot, 'status.json'),
     eventsPath: path.join(runRoot, 'events.ndjson'),
+    decisionsPath: path.join(runRoot, 'decisions.ndjson'),
     summaryPath: path.join(runRoot, 'summary.md'),
     usagePath: path.join(runRoot, 'usage.json'),
   };
@@ -116,6 +117,38 @@ export function readPhaseExitEvents(runPaths) {
   return completedPhases;
 }
 
+/**
+ * Read phase exit events with full two-level detail (parent_phase + workflow).
+ */
+export function readPhaseExitEventsDetailed(runPaths) {
+  if (!fs.existsSync(runPaths.eventsPath)) {
+    return [];
+  }
+
+  const content = fs.readFileSync(runPaths.eventsPath, 'utf8');
+  const events = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event.event === 'phase_exit' && event.phase) {
+        events.push({
+          phase: event.phase,
+          parent_phase: event.parent_phase ?? event.phase,
+          workflow: event.workflow ?? event.phase,
+          status: event.status,
+        });
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return events;
+}
+
 export function writeSummary(runPaths, content) {
   ensureRunDirectories(runPaths);
   fs.writeFileSync(runPaths.summaryPath, content);

package/tooling/src/capture/user-input.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Append a user input entry to the run's NDJSON log.
+ *
+ * @param {string} runDir - Absolute path to the run directory
+ * @param {object} entry - { phase, type, content, context }
+ *   type: 'instruction' | 'approval' | 'correction' | 'rejection' | 'redirect'
+ */
+export function captureUserInput(runDir, { phase, type, content, context }) {
+  const logPath = path.join(runDir, 'user-input-log.ndjson');
+  const record = {
+    timestamp: new Date().toISOString(),
+    phase: phase ?? 'unknown',
+    type: type ?? 'instruction',
+    content: content ?? '',
+    context: context ?? '',
+  };
+  fs.appendFileSync(logPath, JSON.stringify(record) + '\n');
+  return logPath;
+}
+
+/**
+ * Read all entries from a run's user input log.
+ */
+export function readUserInputLog(runDir) {
+  const logPath = path.join(runDir, 'user-input-log.ndjson');
+  if (!fs.existsSync(logPath)) return [];
+
+  return fs.readFileSync(logPath, 'utf8')
+    .split('\n')
+    .filter(line => line.trim())
+    .map(line => {
+      try { return JSON.parse(line); }
+      catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Prune old user-input-log.ndjson files, keeping the most recent `keep` runs.
+ *
+ * @param {string} stateRoot - Absolute path to the state root (e.g. ~/.wazir/projects/foo)
+ * @param {number} keep - Number of recent runs to keep (default 10)
+ */
+export function pruneOldInputLogs(stateRoot, keep = 10) {
+  const runsDir = path.join(stateRoot, 'runs');
+  if (!fs.existsSync(runsDir)) return { pruned: 0 };
+
+  const entries = fs.readdirSync(runsDir)
+    .filter(name => name.startsWith('run-') && fs.statSync(path.join(runsDir, name)).isDirectory())
+    .sort()
+    .reverse();
+
+  let pruned = 0;
+  for (let i = keep; i < entries.length; i++) {
+    const logPath = path.join(runsDir, entries[i], 'user-input-log.ndjson');
+    if (fs.existsSync(logPath)) {
+      fs.unlinkSync(logPath);
+      pruned++;
+    }
+  }
+
+  return { pruned };
+}

package/tooling/src/checks/security-sensitivity.js

@@ -0,0 +1,69 @@
+const SECURITY_PATTERNS = [
+  'auth', 'password', 'passwd', 'token', 'query', 'sql',
+  'fetch', 'upload', 'secret', 'env', 'api[._-]?key',
+  'session', 'cookie', 'cors', 'csrf', 'jwt', 'oauth',
+  'encrypt', 'decrypt', 'hash', 'salt', 'credential',
+  'private[._-]?key', 'access[._-]?token', 'refresh[._-]?token',
+];
+
+const PATTERN_REGEX = new RegExp(
+  `\\b(${SECURITY_PATTERNS.join('|')})\\b`,
+  'gi'
+);
+
+/**
+ * Scan diff text for security-sensitive patterns.
+ * Returns which patterns were found and in which files.
+ */
+export function detectSecurityPatterns(diffText) {
+  if (!diffText || typeof diffText !== 'string') {
+    return { triggered: false, patterns: [], files: [] };
+  }
+
+  const matchedPatterns = new Set();
+  const matchedFiles = new Set();
+  let currentFile = null;
+
+  for (const line of diffText.split('\n')) {
+    // Track current file from diff headers
+    const fileMatch = line.match(/^(?:diff --git a\/\S+ b\/|[+]{3} b\/)(.+)/);
+    if (fileMatch) {
+      currentFile = fileMatch[1];
+      continue;
+    }
+
+    // Only scan added/modified lines (starting with +, not +++)
+    if (!line.startsWith('+') || line.startsWith('+++')) continue;
+
+    const lineMatches = line.match(PATTERN_REGEX);
+    if (lineMatches) {
+      for (const m of lineMatches) {
+        matchedPatterns.add(m.toLowerCase());
+      }
+      if (currentFile) {
+        matchedFiles.add(currentFile);
+      }
+    }
+  }
+
+  const patterns = [...matchedPatterns].sort();
+  const files = [...matchedFiles].sort();
+
+  return {
+    triggered: patterns.length > 0,
+    patterns,
+    files,
+  };
+}
+
+/**
+ * Security review dimensions to add when patterns are detected.
+ */
+export const SECURITY_REVIEW_DIMENSIONS = [
+  'Injection (SQL, command, template, header)',
+  'Authentication bypass',
+  'Data exposure (PII, secrets, tokens in logs/responses)',
+  'CSRF / SSRF',
+  'XSS (stored, reflected, DOM)',
+  'Secrets leakage (hardcoded keys, env vars in client code)',
+];

package/tooling/src/cli.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 
+// Suppress Node.js ExperimentalWarning for built-in SQLite (node:sqlite).
+// Must run before any module that transitively imports node:sqlite loads,
+// so command handlers are lazy-imported below instead of using static imports.
+const _originalEmit = process.emit;
+process.emit = function (event, ...args) {
+  if (event === 'warning' && args[0]?.name === 'ExperimentalWarning' &&
+      args[0]?.message?.includes('SQLite')) {
+    return false;
+  }
+  return _originalEmit.apply(this, [event, ...args]);
+};
+
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
-import { runCaptureCommand } from './capture/command.js';
-import { runValidateCommand } from './commands/validate.js';
-import { runDoctorCommand } from './doctor/command.js';
-import { runExportCommand as runGeneratedExportCommand } from './export/command.js';
-import { runIndexCommand } from './index/command.js';
-import { runInitCommand } from './init/command.js';
-import { runRecallCommand } from './recall/command.js';
-import { runReportCommand } from './reports/command.js';
-import { runStateCommand } from './state/command.js';
-import { runStatsCommand } from './commands/stats.js';
-import { runStatusCommand } from './status/command.js';
-
 const COMMAND_FAMILIES = [
   'export',
   'validate',
@@ -29,18 +29,19 @@ const COMMAND_FAMILIES = [
   'capture'
 ];
 
-const COMMAND_HANDLERS = {
-  export: runGeneratedExportCommand,
-  validate: runValidateCommand,
-  doctor: runDoctorCommand,
-  index: runIndexCommand,
-  init: runInitCommand,
-  recall: runRecallCommand,
-  report: runReportCommand,
-  state: runStateCommand,
-  status: runStatusCommand,
-  stats: runStatsCommand,
-  capture: runCaptureCommand,
+// Lazy-load command handlers so the warning filter is active before node:sqlite loads
+const COMMAND_LOADERS = {
+  export:   () => import('./export/command.js').then(m => m.runExportCommand),
+  validate: () => import('./commands/validate.js').then(m => m.runValidateCommand),
+  doctor:   () => import('./doctor/command.js').then(m => m.runDoctorCommand),
+  index:    () => import('./index/command.js').then(m => m.runIndexCommand),
+  init:     () => import('./init/command.js').then(m => m.runInitCommand),
+  recall:   () => import('./recall/command.js').then(m => m.runRecallCommand),
+  report:   () => import('./reports/command.js').then(m => m.runReportCommand),
+  state:    () => import('./state/command.js').then(m => m.runStateCommand),
+  status:   () => import('./status/command.js').then(m => m.runStatusCommand),
+  stats:    () => import('./commands/stats.js').then(m => m.runStatsCommand),
+  capture:  () => import('./capture/command.js').then(m => m.runCaptureCommand),
 };
 
 export function parseArgs(argv) {
@@ -88,9 +89,9 @@ export async function main(argv = process.argv.slice(2)) {
     return 1;
   }
 
-  const handler = COMMAND_HANDLERS[parsed.command];
+  const loader = COMMAND_LOADERS[parsed.command];
 
-  if (!handler) {
+  if (!loader) {
     console.error(`wazir ${parsed.command} is not implemented yet`);
     return 2;
   }
@@ -98,6 +99,7 @@ export async function main(argv = process.argv.slice(2)) {
   let result;
 
   try {
+    const handler = await loader();
     result = await handler(parsed);
   } catch (error) {
     console.error(error.message);

package/tooling/src/config/depth-table.js

@@ -0,0 +1,60 @@
+/**
+ * Canonical depth parameter table.
+ *
+ * Single source of truth for all depth-dependent behavior across the pipeline.
+ * Skills reference these values conceptually; hooks and tooling import directly.
+ */
+
+export const DEPTH_LEVELS = new Set(['quick', 'standard', 'deep']);
+
+export const DEPTH_TABLE = {
+  quick: {
+    review_passes: 3,
+    loop_cap: 5,
+    heartbeat_max_silence_s: 180,
+    research_intensity: 'minimal',
+    challenge_intensity: 'surface',
+    spec_hardening_passes: 1,
+    design_review_passes: 1,
+    time_estimate_label: '~15-30 min',
+  },
+  standard: {
+    review_passes: 5,
+    loop_cap: 10,
+    heartbeat_max_silence_s: 120,
+    research_intensity: 'balanced',
+    challenge_intensity: 'balanced',
+    spec_hardening_passes: 3,
+    design_review_passes: 3,
+    time_estimate_label: '~45-90 min',
+  },
+  deep: {
+    review_passes: 7,
+    loop_cap: 15,
+    heartbeat_max_silence_s: 90,
+    research_intensity: 'thorough',
+    challenge_intensity: 'adversarial',
+    spec_hardening_passes: 5,
+    design_review_passes: 5,
+    time_estimate_label: '~2-3 hrs',
+  },
+};
+
+/**
+ * Get a specific depth parameter value.
+ *
+ * @param {string} depth  — 'quick' | 'standard' | 'deep' (defaults to 'standard')
+ * @param {string} param  — parameter name from the depth table
+ * @returns {*} the parameter value
+ */
+export function getDepthParam(depth, param) {
+  const level = depth ?? 'standard';
+  if (!DEPTH_LEVELS.has(level)) {
+    throw new Error(`Unknown depth level: "${level}". Valid levels: ${[...DEPTH_LEVELS].join(', ')}`);
+  }
+  const entry = DEPTH_TABLE[level];
+  if (!(param in entry)) {
+    throw new Error(`Unknown depth parameter: "${param}". Valid params: ${Object.keys(entry).join(', ')}`);
+  }
+  return entry[param];
+}

package/tooling/src/export/compiler.js

@@ -91,8 +91,7 @@ function renderCommonInstructions(host, manifest) {
 const DEFAULT_CLAUDE_HOOKS = {
   hooks: {
     PreToolUse: [
-      { matcher: 'Write|Edit', hooks: [{ type: 'command', command: './hooks/protected-path-write-guard' }] },
-      { matcher: 'Bash', hooks: [{ type: 'command', command: './hooks/context-mode-router' }] },
+      { matcher: 'Write|Edit|Bash', hooks: [{ type: 'command', command: './hooks/pretooluse-dispatcher' }] },
     ],
     SessionStart: [
       { hooks: [{ type: 'command', command: './hooks/loop-cap-guard' }] },
@@ -115,21 +114,21 @@ function renderCursorHooks() {
   return JSON.stringify({
     hooks: [
       {
-        name: 'protected-path-write-guard',
-        command: './hooks/protected-path-write-guard',
+        name: 'pretooluse-dispatcher',
+        command: './hooks/pretooluse-dispatcher',
       },
       {
         name: 'loop-cap-guard',
         command: './hooks/loop-cap-guard',
       },
-      {
-        name: 'context-mode-router',
-        command: './hooks/context-mode-router',
-      },
       {
         name: 'session-start',
         command: './hooks/session-start',
       },
+      {
+        name: 'stop-pipeline-gate',
+        command: './hooks/stop-pipeline-gate',
+      },
     ],
   }, null, 2);
 }