intentdna 1.0.0

package/dist/runtime/hooks.js

@@ -0,0 +1,645 @@
+/**
+ * Intent DNA — Hook Adapter
+ *
+ * Compiles Constraint IR into shell scripts for Claude Code hooks.
+ * These scripts enforce DNA constraints at the harness level (deterministic),
+ * not the prompt level (probabilistic).
+ *
+ * Output:
+ *   - PreToolUse hook: blocks/escalates tool calls based on pre_execution_gates + tool_filters
+ *   - PostToolUse hook: validates tool outputs based on post_execution_validators
+ *   - UserPromptSubmit hook: injects DNA policy reminders on each user prompt
+ *   - SubagentStop hook: audits role scope compliance when subagents finish
+ *   - PreCompact hook: preserves critical DNA directives before context compaction
+ *   - Notification hook: fires on DNA policy violations
+ *
+ * See docs/references/cc-source-analysis.md for the full Claude Code hook event catalog (27 events).
+ *
+ * Hook scripts read JSON from stdin (tool_name, tool_input, agent_type)
+ * and exit with code 2 to block, or 0 to allow.
+ */
+import { mkdir, writeFile, readFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { toKebabCase } from "./agent-md.js";
+const SENTINEL_COMMENT = "# intentdna:managed — do not edit manually";
+/**
+ * Compile Constraint IR into hook shell scripts.
+ * Returns null for a hook type if there are no relevant constraints.
+ */
+export function compileToHooks(ir, options) {
+    const agentPrefix = options?.agentPrefix ?? "dna-";
+    const preToolUse = compilePreToolUseHook(ir, agentPrefix, options?.roles);
+    const postToolUse = compilePostToolUseHook(ir, options?.roles);
+    const userPromptSubmit = compileUserPromptSubmitHook(ir);
+    const subagentStop = compileSubagentStopHook(ir);
+    const preCompact = compilePreCompactHook(ir);
+    const notification = compileNotificationHook(ir);
+    return { preToolUse, postToolUse, userPromptSubmit, subagentStop, preCompact, notification };
+}
+/**
+ * Write hook scripts to the .claude/hooks/ directory.
+ * Creates the directory if it doesn't exist.
+ * Returns list of files written.
+ */
+export async function writeHookScripts(hooksDir, scripts) {
+    await mkdir(hooksDir, { recursive: true });
+    const written = [];
+    const entries = [
+        ["preToolUse", "dna-pre-tool-use.sh"],
+        ["postToolUse", "dna-post-tool-use.sh"],
+        ["userPromptSubmit", "dna-user-prompt-submit.sh"],
+        ["subagentStop", "dna-subagent-stop.sh"],
+        ["preCompact", "dna-pre-compact.sh"],
+        ["notification", "dna-notification.sh"],
+    ];
+    for (const [key, filename] of entries) {
+        if (scripts[key]) {
+            const path = join(hooksDir, filename);
+            await writeFile(path, scripts[key], { mode: 0o755 });
+            written.push(path);
+        }
+    }
+    return written;
+}
+/**
+ * Remove hook scripts previously written by Intent DNA.
+ * Only removes files that contain the sentinel comment.
+ * Returns number of files removed.
+ */
+export async function removeHookScripts(hooksDir) {
+    const files = [
+        "dna-pre-tool-use.sh",
+        "dna-post-tool-use.sh",
+        "dna-user-prompt-submit.sh",
+        "dna-subagent-stop.sh",
+        "dna-pre-compact.sh",
+        "dna-notification.sh",
+    ];
+    let removed = 0;
+    for (const file of files) {
+        const path = join(hooksDir, file);
+        try {
+            const content = await readFile(path, "utf-8");
+            if (content.includes(SENTINEL_COMMENT)) {
+                await rm(path);
+                removed++;
+            }
+        }
+        catch {
+            // File doesn't exist, skip
+        }
+    }
+    return removed;
+}
+/**
+ * Generate settings.json hook configuration snippet.
+ * This can be merged into the project's .claude/settings.json.
+ */
+export function generateSettingsSnippet(hooksDir) {
+    return {
+        hooks: {
+            PreToolUse: [
+                {
+                    command: `bash ${join(hooksDir, "dna-pre-tool-use.sh")}`,
+                },
+            ],
+            PostToolUse: [
+                {
+                    command: `bash ${join(hooksDir, "dna-post-tool-use.sh")}`,
+                },
+            ],
+            UserPromptSubmit: [
+                {
+                    command: `bash ${join(hooksDir, "dna-user-prompt-submit.sh")}`,
+                },
+            ],
+            SubagentStop: [
+                {
+                    command: `bash ${join(hooksDir, "dna-subagent-stop.sh")}`,
+                },
+            ],
+            PreCompact: [
+                {
+                    command: `bash ${join(hooksDir, "dna-pre-compact.sh")}`,
+                },
+            ],
+            Notification: [
+                {
+                    command: `bash ${join(hooksDir, "dna-notification.sh")}`,
+                },
+            ],
+        },
+    };
+}
+// ── Internal: Script generators ──────────────────────────────
+function compilePreToolUseHook(ir, agentPrefix, roles) {
+    const gates = ir.pre_execution_gates;
+    const filters = ir.tool_filters;
+    const rolesScopeMap = ir.roles_scope_map;
+    const hasRoleScope = rolesScopeMap && rolesScopeMap.length > 0;
+    // Check if any role has structured output_schema
+    const outputSchemaRoles = roles
+        ? Object.entries(roles).filter(([, r]) => r.output_schema && typeof r.output_schema !== "string")
+        : [];
+    const hasOutputSchema = outputSchemaRoles.length > 0;
+    if (gates.length === 0 && filters.length === 0 && !hasRoleScope && !hasOutputSchema)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("set -euo pipefail");
+    lines.push("");
+    lines.push("# Read hook input from stdin");
+    lines.push('INPUT=$(cat)');
+    lines.push('TOOL_NAME=$(echo "$INPUT" | jq -r \'.tool_name // empty\')');
+    lines.push('AGENT_TYPE=$(echo "$INPUT" | jq -r \'.agent_type // empty\')');
+    lines.push('TOOL_INPUT_JSON=$(echo "$INPUT" | jq -c \'.tool_input // {}\')');
+    lines.push("");
+    // Role scope enforcement — inserted before tool filters (hard constraint, checked first)
+    if (hasRoleScope) {
+        lines.push(...generateCheckWriteAllowedFn());
+        lines.push("");
+        lines.push(...generateRoleScopeBlocks(rolesScopeMap, agentPrefix));
+        lines.push("");
+    }
+    // Tool filters — block/warn tools based on conditions
+    if (filters.length > 0) {
+        lines.push("# ── Tool Filters ──");
+        for (const filter of filters) {
+            const toolMatch = extractToolMatch(filter);
+            if (toolMatch) {
+                lines.push(...generateToolFilterBlock(filter, toolMatch));
+                lines.push("");
+            }
+        }
+    }
+    // Pre-execution gates — block/escalate based on conditions
+    if (gates.length > 0) {
+        lines.push("# ── Pre-Execution Gates ──");
+        for (const gate of gates) {
+            lines.push(...generateGateBlock(gate));
+            lines.push("");
+        }
+    }
+    // Output schema enforcement — validate required sections on Write
+    if (hasOutputSchema) {
+        lines.push("# ── Output Schema Enforcement ──");
+        lines.push('if [ "$TOOL_NAME" = "Write" ]; then');
+        lines.push('  CONTENT=$(echo "$TOOL_INPUT_JSON" | jq -r \'.content // empty\')');
+        lines.push('  if [ -n "$CONTENT" ] && [ -n "$AGENT_TYPE" ]; then');
+        lines.push('    case "$AGENT_TYPE" in');
+        for (const [roleName, role] of outputSchemaRoles) {
+            const schema = role.output_schema;
+            if (!schema.required_sections || schema.required_sections.length === 0)
+                continue;
+            const agentName = `${agentPrefix}${roleName.replace(/_/g, "-")}`;
+            lines.push(`      ${agentName})`);
+            for (const section of schema.required_sections) {
+                const escaped = section.replace(/'/g, "'\\''");
+                lines.push(`        if ! echo "$CONTENT" | grep -q "## ${escaped}"; then`);
+                lines.push(`          echo "BLOCK [Intent DNA]: Output missing required section '${escaped}' (role: ${roleName})" >&2`);
+                lines.push(`          exit 2`);
+                lines.push(`        fi`);
+            }
+            lines.push(`        ;;`);
+        }
+        lines.push('    esac');
+        lines.push('  fi');
+        lines.push('fi');
+        lines.push("");
+    }
+    lines.push("# All checks passed");
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+function compilePostToolUseHook(ir, roles) {
+    const validators = ir.post_execution_validators;
+    // Check for converter roles
+    const converterRoles = roles
+        ? Object.entries(roles).filter(([, r]) => {
+            const os = r.output_schema;
+            return os && typeof os !== "string" && os.converter && os.format && os.format !== "markdown";
+        })
+        : [];
+    if (validators.length === 0 && converterRoles.length === 0)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("set -euo pipefail");
+    lines.push("");
+    lines.push("# Read hook input from stdin");
+    lines.push('INPUT=$(cat)');
+    lines.push('TOOL_NAME=$(echo "$INPUT" | jq -r \'.tool_name // empty\')');
+    lines.push('AGENT_TYPE=$(echo "$INPUT" | jq -r \'.agent_type // empty\')');
+    lines.push('TOOL_OUTPUT=$(echo "$INPUT" | jq -r \'.tool_output // empty\')');
+    lines.push("");
+    lines.push("# ── Post-Execution Validators ──");
+    for (const v of validators) {
+        lines.push(`# [${v.source_gene}] ${v.check}`);
+        lines.push(`# Validator: "${v.check}" (threshold: ${v.threshold ?? "none"})`);
+        lines.push(`# Note: Complex validation requires application-level logic.`);
+        lines.push(`# This hook logs the check for audit purposes.`);
+        lines.push(`echo "[Intent DNA] PostToolUse validator: ${escapeShell(v.check)} (gene: ${v.source_gene})" >&2`);
+        lines.push("");
+    }
+    // Output format conversion
+    if (converterRoles.length > 0) {
+        lines.push("# ── Output Format Conversion ──");
+        lines.push('if [ "$TOOL_NAME" = "Write" ]; then');
+        lines.push('  FILE_PATH=$(echo "$INPUT" | jq -r \'.tool_input.file_path // empty\')');
+        lines.push('  if [ -n "$FILE_PATH" ] && [ -n "$AGENT_TYPE" ]; then');
+        lines.push('    case "$AGENT_TYPE" in');
+        for (const [roleName, role] of converterRoles) {
+            const schema = role.output_schema;
+            const agentName = `dna-${roleName.replace(/_/g, "-")}`;
+            const converter = schema.converter
+                .replace(/\{\{output_path\}\}/g, '"${FILE_PATH%.*}.' + (schema.format ?? "pdf") + '"');
+            lines.push(`      ${agentName})`);
+            lines.push(`        OUTPUT_PATH="\${FILE_PATH%.*}.${schema.format}"`);
+            lines.push(`        ${converter} "$FILE_PATH" 2>/dev/null && \\`);
+            lines.push(`          echo "[Intent DNA] Converted: $FILE_PATH → $OUTPUT_PATH" >&2 || \\`);
+            lines.push(`          echo "[Intent DNA] Conversion failed: $FILE_PATH (${schema.converter})" >&2`);
+            lines.push(`        ;;`);
+        }
+        lines.push('    esac');
+        lines.push('  fi');
+        lines.push('fi');
+        lines.push("");
+    }
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+/**
+ * Extract tool name patterns from a ToolFilter.
+ * The filter's target field may contain tool names or categories.
+ */
+function extractToolMatch(filter) {
+    if (!filter.target)
+        return null;
+    // Map known DNA targets to Claude Code tool names
+    const toolMappings = {
+        file_modification: ["Edit", "Write", "NotebookEdit"],
+        file_write: ["Write"],
+        file_edit: ["Edit"],
+        code_execution: ["Bash"],
+        shell: ["Bash"],
+        harmful_actions: ["Bash"],
+        unsafe_operations: ["Bash"],
+        data_sharing_external: ["WebFetch", "Bash"],
+    };
+    const tools = toolMappings[filter.target];
+    if (tools)
+        return tools.join("|");
+    // If target looks like a tool name already (PascalCase), use it directly
+    if (/^[A-Z][a-zA-Z]+$/.test(filter.target))
+        return filter.target;
+    return null;
+}
+/**
+ * Generate bash code block for a tool filter.
+ */
+function generateToolFilterBlock(filter, toolPattern) {
+    const lines = [];
+    const action = filter.action;
+    const reason = escapeShell(filter.reason);
+    lines.push(`# [${filter.source_gene}] ${filter.action}: ${filter.target}`);
+    if (action === "remove") {
+        // Hard block — exit 2
+        lines.push(`if echo "$TOOL_NAME" | grep -qE '^(${toolPattern})$'; then`);
+        lines.push(`  echo "BLOCK [Intent DNA]: ${reason} (gene: ${filter.source_gene})" >&2`);
+        lines.push("  exit 2");
+        lines.push("fi");
+    }
+    else if (action === "warn") {
+        // Warn but allow — write to stderr, exit 0
+        lines.push(`if echo "$TOOL_NAME" | grep -qE '^(${toolPattern})$'; then`);
+        lines.push(`  echo "WARN [Intent DNA]: ${reason} (gene: ${filter.source_gene})" >&2`);
+        lines.push("fi");
+    }
+    else {
+        // deprioritize — just log, can't actually deprioritize at hook level
+        lines.push(`if echo "$TOOL_NAME" | grep -qE '^(${toolPattern})$'; then`);
+        lines.push(`  echo "DEPRIORITIZE [Intent DNA]: ${reason} (gene: ${filter.source_gene})" >&2`);
+        lines.push("fi");
+    }
+    return lines;
+}
+/**
+ * Generate bash code block for a pre-execution gate.
+ */
+function generateGateBlock(gate) {
+    const lines = [];
+    const message = escapeShell(gate.message);
+    const condition = gate.condition;
+    lines.push(`# [${gate.source_gene}] ${gate.action}: ${condition}`);
+    // Parse condition to generate bash logic
+    const toolCheck = parseConditionToToolCheck(condition);
+    if (toolCheck) {
+        if (gate.action === "block") {
+            lines.push(`if ${toolCheck}; then`);
+            lines.push(`  echo "BLOCK [Intent DNA]: ${message}" >&2`);
+            lines.push("  exit 2");
+            lines.push("fi");
+        }
+        else if (gate.action === "escalate") {
+            // Escalate = ask user (Claude Code supports this via permissionDecision)
+            lines.push(`if ${toolCheck}; then`);
+            lines.push(`  echo '{"hookSpecificOutput":{"permissionDecision":"ask","permissionDecisionReason":"[Intent DNA] ${message}"}}' >&2`);
+            lines.push("  exit 2");
+            lines.push("fi");
+        }
+        else {
+            // warn
+            lines.push(`if ${toolCheck}; then`);
+            lines.push(`  echo "WARN [Intent DNA]: ${message}" >&2`);
+            lines.push("fi");
+        }
+    }
+    else {
+        // Condition is too complex for shell — log it as a comment
+        lines.push(`# Complex condition cannot be enforced at hook level: ${condition}`);
+        lines.push(`# Action would be: ${gate.action} — "${gate.message}"`);
+        lines.push(`# Enforce via SDK adapter or application logic.`);
+    }
+    return lines;
+}
+/**
+ * Try to parse a DNA condition string into a bash conditional expression.
+ * Returns null if the condition is too complex for shell logic.
+ */
+function parseConditionToToolCheck(condition) {
+    // Pattern: "X == false" → check for tool usage (threshold violation)
+    // These are boolean thresholds — they translate to tool-level blocks
+    const boolFalseMatch = condition.match(/^(\w+)\s*==\s*false$/);
+    if (boolFalseMatch) {
+        const metric = boolFalseMatch[1];
+        // Map metrics to tool checks
+        const metricToolMap = {
+            personal_data_exposure: 'echo "$TOOL_INPUT_JSON" | jq -e \'.. | strings | test("password|secret|token|api_key|ssn|credit_card"; "i")\' >/dev/null 2>&1',
+        };
+        if (metricToolMap[metric]) {
+            return metricToolMap[metric];
+        }
+        // Generic boolean thresholds can't be checked at hook level
+        return null;
+    }
+    // Pattern: "metric <= N" or "metric >= N"
+    // These are numeric thresholds — generally can't be checked per-call
+    const numericMatch = condition.match(/^(\w+)\s*(<=|>=|<|>|==)\s*(\d+)$/);
+    if (numericMatch) {
+        // Numeric conditions need aggregation — can't enforce per-call at hook level
+        return null;
+    }
+    // Pattern: "tool_name in ['X', 'Y']" or similar
+    const toolInMatch = condition.match(/^tool_name\s+in\s+\[([^\]]+)\]/);
+    if (toolInMatch) {
+        const tools = toolInMatch[1]
+            .split(",")
+            .map(t => t.trim().replace(/['"]/g, ""))
+            .join("|");
+        return `echo "$TOOL_NAME" | grep -qE '^(${tools})$'`;
+    }
+    return null;
+}
+/**
+ * Extract directory prefix from a glob pattern.
+ * "src/**\/*.ts" → "src/"
+ * "test/**" → "test/"
+ * "*.md" → "" (root)
+ * "package.json" → "package.json" (exact path)
+ */
+export function globToPrefix(glob) {
+    const starIdx = glob.indexOf("*");
+    if (starIdx === -1)
+        return glob; // exact path
+    return glob.substring(0, starIdx);
+}
+/**
+ * Generate the check_write_allowed shell helper function.
+ */
+function generateCheckWriteAllowedFn() {
+    return [
+        "# ── Path Allowlist Helper ──",
+        "check_write_allowed() {",
+        '  local file_path="$1"',
+        "  shift",
+        '  for prefix in "$@"; do',
+        '    case "$file_path" in',
+        "      ${prefix}*) return 0 ;;",
+        "    esac",
+        "  done",
+        "  return 1",
+        "}",
+    ];
+}
+/**
+ * Generate role scope enforcement blocks for PreToolUse hook.
+ * Creates a case/esac structure branching on AGENT_TYPE.
+ * Uses agentPrefix + toKebabCase(role_name) for case matching,
+ * so that "planner" with prefix "dna-" matches agent_type "dna-planner".
+ */
+function generateRoleScopeBlocks(rolesScopeMap, agentPrefix) {
+    if (rolesScopeMap.length === 0)
+        return [];
+    const lines = [];
+    lines.push("# ── Role Scope Enforcement ──");
+    lines.push('if [ -n "$AGENT_TYPE" ]; then');
+    lines.push("  FILE_PATH=$(echo \"$TOOL_INPUT_JSON\" | jq -r '.file_path // empty')");
+    lines.push("");
+    lines.push("  # Check write operations against role scope");
+    lines.push("  if echo \"$TOOL_NAME\" | grep -qE '^(Edit|Write|NotebookEdit)$'; then");
+    lines.push('    if [ -n "$FILE_PATH" ]; then');
+    lines.push('      case "$AGENT_TYPE" in');
+    for (const entry of rolesScopeMap) {
+        const writeGlobs = entry.scope.write ?? [];
+        const agentTypeName = `${agentPrefix}${toKebabCase(entry.role_name)}`;
+        lines.push(`        ${agentTypeName})`);
+        if (writeGlobs.length === 0) {
+            // No write permission at all
+            lines.push(`          echo "BLOCK [Intent DNA]: Role '${entry.role_name}' has no write permission (path: $FILE_PATH)" >&2`);
+            lines.push("          exit 2");
+        }
+        else {
+            // Check against prefixes
+            const prefixes = writeGlobs.map(globToPrefix).filter(p => p.length > 0);
+            const prefixArgs = prefixes.map(p => `"${p}"`).join(" ");
+            lines.push(`          # Write scope: ${writeGlobs.join(", ")}`);
+            lines.push(`          if ! check_write_allowed "$FILE_PATH" ${prefixArgs}; then`);
+            lines.push(`            echo "BLOCK [Intent DNA]: Role '${entry.role_name}' cannot write to '$FILE_PATH' (allowed: ${writeGlobs.join(", ")})" >&2`);
+            lines.push("            exit 2");
+            lines.push("          fi");
+        }
+        lines.push("          ;;");
+    }
+    lines.push("      esac");
+    lines.push("    fi");
+    lines.push("  fi");
+    lines.push("fi");
+    return lines;
+}
+/**
+ * Escape a string for safe use in shell single-quoted context.
+ */
+function escapeShell(s) {
+    return s.replace(/'/g, "'\\''").replace(/"/g, '\\"');
+}
+// ── New hook events (Phase 5.9) ─────────────────────────────
+// Reference: docs/references/cc-source-analysis.md §2
+/**
+ * Compile UserPromptSubmit hook.
+ * Injects DNA policy reminders each time the user submits a prompt.
+ * Only generated when there are high-priority prompt directives.
+ */
+function compileUserPromptSubmitHook(ir) {
+    const highPriority = ir.prompt_directives.filter(d => d.priority === "high");
+    if (highPriority.length === 0)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("# UserPromptSubmit: Inject DNA policy reminders on each user prompt");
+    lines.push("# This hook fires before the model processes the user's message.");
+    lines.push("");
+    lines.push("REMINDERS=()");
+    for (const d of highPriority) {
+        const text = escapeShell(d.text);
+        lines.push(`REMINDERS+=("[${d.source_gene}] ${text}")`);
+    }
+    lines.push("");
+    lines.push("if [ ${#REMINDERS[@]} -gt 0 ]; then");
+    lines.push('  echo "<system-reminder>[Intent DNA] Active high-priority policies:" >&2');
+    lines.push('  for r in "${REMINDERS[@]}"; do');
+    lines.push('    echo "  - $r" >&2');
+    lines.push("  done");
+    lines.push('  echo "</system-reminder>" >&2');
+    lines.push("fi");
+    lines.push("");
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+/**
+ * Compile SubagentStop hook.
+ * Audits whether the subagent stayed within its role scope.
+ * Only generated when roles_scope_map is defined.
+ */
+function compileSubagentStopHook(ir) {
+    const rolesScopeMap = ir.roles_scope_map;
+    if (!rolesScopeMap || rolesScopeMap.length === 0)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("# SubagentStop: Audit role scope compliance when a subagent finishes");
+    lines.push("");
+    lines.push('INPUT=$(cat)');
+    lines.push('AGENT_NAME=$(echo "$INPUT" | jq -r \'.agent_name // empty\')');
+    lines.push('AGENT_TYPE=$(echo "$INPUT" | jq -r \'.agent_type // empty\')');
+    lines.push("");
+    lines.push("# Log scope audit for each known role");
+    lines.push('if [ -n "$AGENT_TYPE" ]; then');
+    lines.push('  case "$AGENT_TYPE" in');
+    for (const entry of rolesScopeMap) {
+        const agentTypeName = `dna-${toKebabCase(entry.role_name)}`;
+        const writeGlobs = entry.scope.write ?? [];
+        const readGlobs = entry.scope.read ?? [];
+        const scopeDesc = writeGlobs.length > 0
+            ? `write:[${writeGlobs.join(",")}]`
+            : "write:[]";
+        lines.push(`    ${agentTypeName})`);
+        lines.push(`      echo "[Intent DNA] SubagentStop audit: role=${entry.role_name} agent=$AGENT_NAME scope=${scopeDesc}" >&2`);
+        lines.push(`      ;;`);
+    }
+    lines.push('    *)');
+    lines.push('      echo "[Intent DNA] SubagentStop: unknown role for agent_type=$AGENT_TYPE" >&2');
+    lines.push('      ;;');
+    lines.push("  esac");
+    lines.push("fi");
+    lines.push("");
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+/**
+ * Compile PreCompact hook.
+ * Emits DNA directive summary before context compaction, so the compact
+ * process can incorporate critical constraints into the summary.
+ * Only generated when there are prompt directives.
+ */
+function compilePreCompactHook(ir) {
+    if (ir.prompt_directives.length === 0)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("# PreCompact: Preserve critical DNA directives before context compaction");
+    lines.push("# The compact process should incorporate these into the conversation summary.");
+    lines.push("");
+    const critical = ir.prompt_directives.filter(d => d.priority === "high");
+    const standard = ir.prompt_directives.filter(d => d.priority === "medium");
+    lines.push('echo "[Intent DNA] PreCompact: Preserving directive summary for compact" >&2');
+    if (critical.length > 0) {
+        lines.push('echo "  Critical directives:" >&2');
+        for (const d of critical) {
+            lines.push(`echo "    - [${d.source_gene}] ${escapeShell(d.text)}" >&2`);
+        }
+    }
+    if (standard.length > 0) {
+        lines.push('echo "  Standard directives (${' + standard.length + '}):" >&2');
+        for (const d of standard) {
+            lines.push(`echo "    - [${d.source_gene}] ${escapeShell(d.text)}" >&2`);
+        }
+    }
+    lines.push("");
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+/**
+ * Compile Notification hook.
+ * Logs DNA policy violation events for audit trail.
+ * Only generated when there are pre_execution_gates with block/escalate actions.
+ */
+function compileNotificationHook(ir) {
+    const blockGates = ir.pre_execution_gates.filter(g => g.action === "block" || g.action === "escalate");
+    const blockFilters = ir.tool_filters.filter(f => f.action === "remove");
+    if (blockGates.length === 0 && blockFilters.length === 0)
+        return null;
+    const lines = [];
+    lines.push("#!/bin/bash");
+    lines.push(SENTINEL_COMMENT);
+    lines.push(`# Compiled: ${ir.compiled_at}`);
+    lines.push(`# Sources: ${ir.source_dna_ids.join(", ")}`);
+    lines.push("");
+    lines.push("# Notification: Log DNA policy violation events for audit");
+    lines.push("");
+    lines.push('INPUT=$(cat)');
+    lines.push('MESSAGE=$(echo "$INPUT" | jq -r \'.message // empty\')');
+    lines.push('TITLE=$(echo "$INPUT" | jq -r \'.title // empty\')');
+    lines.push("");
+    // Write to audit log if it looks like a DNA violation
+    lines.push('if echo "$MESSAGE" | grep -q "Intent DNA"; then');
+    lines.push('  AUDIT_DIR="${HOME}/.intentdna/audit"');
+    lines.push('  mkdir -p "$AUDIT_DIR"');
+    lines.push('  AUDIT_FILE="$AUDIT_DIR/violations-$(date +%Y-%m-%d).log"');
+    lines.push('  echo "[$(date -Iseconds)] title=$TITLE message=$MESSAGE" >> "$AUDIT_FILE"');
+    lines.push('  echo "[Intent DNA] Notification: violation logged to $AUDIT_FILE" >&2');
+    lines.push("fi");
+    lines.push("");
+    lines.push("exit 0");
+    return lines.join("\n") + "\n";
+}
+//# sourceMappingURL=hooks.js.map