intentdna 1.2.2 → 1.2.3

package/dist/evolution/types.d.ts

@@ -70,4 +70,3 @@ export interface EvolutionConfig {
     max_markers: number;
 }
 export declare const DEFAULT_EVOLUTION_CONFIG: EvolutionConfig;
-//# sourceMappingURL=types.d.ts.map

package/dist/evolution/types.js

@@ -11,4 +11,3 @@ export const DEFAULT_EVOLUTION_CONFIG = {
     prune_threshold: 0.01,
     max_markers: 50,
 };
-//# sourceMappingURL=types.js.map

package/dist/hooks/cli.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — Hook CLI (`dna-hook`)
+ *
+ * Claude Code invokes this binary for each hook event:
+ *   dna-hook <event> [--ir <path>] [--state-dir <path>]
+ *
+ * Runtime flow:
+ *   1. Read JSON from stdin (Claude Code hook protocol)
+ *   2. Load compiled IR from .dna/compiled/ir.json
+ *   3. Read state from .dna/state/
+ *   4. Call enforcement engine
+ *   5. Write JSON result to stdout
+ *
+ * Fail-open: all errors → { continue: true, suppressOutput: true }
+ */
+export {};

package/dist/hooks/cli.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — Hook CLI (`dna-hook`)
+ *
+ * Claude Code invokes this binary for each hook event:
+ *   dna-hook <event> [--ir <path>] [--state-dir <path>]
+ *
+ * Runtime flow:
+ *   1. Read JSON from stdin (Claude Code hook protocol)
+ *   2. Load compiled IR from .dna/compiled/ir.json
+ *   3. Read state from .dna/state/
+ *   4. Call enforcement engine
+ *   5. Write JSON result to stdout
+ *
+ * Fail-open: all errors → { continue: true, suppressOutput: true }
+ */
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { readStdin, writeOutput, silentOutput } from "./protocol.js";
+import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, } from "./enforce.js";
+import { appendAudit } from "./state.js";
+// ── Constants ──────────────────────────────────────────────
+const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
+const VALID_EVENTS = new Set([
+    "PreToolUse", "PostToolUse", "UserPromptSubmit",
+    "SubagentStop", "PreCompact", "Notification", "Stop", "SessionStart",
+]);
+// ── Main ───────────────────────────────────────────────────
+async function main() {
+    // Parse args
+    const args = process.argv.slice(2);
+    const event = args[0];
+    if (!event || !VALID_EVENTS.has(event)) {
+        writeOutput(silentOutput());
+        return;
+    }
+    let irPath = DEFAULT_IR_PATH;
+    const irFlagIdx = args.indexOf("--ir");
+    if (irFlagIdx !== -1 && args[irFlagIdx + 1]) {
+        irPath = args[irFlagIdx + 1];
+    }
+    // Read stdin
+    const rawInput = await readStdin(5000);
+    // Resolve project directory from input or cwd
+    const projectDir = typeof rawInput.cwd === "string" ? rawInput.cwd : process.cwd();
+    const sessionId = typeof rawInput.sessionId === "string" ? rawInput.sessionId : undefined;
+    // Load compiled IR
+    const resolvedIRPath = resolve(projectDir, irPath);
+    const ir = await loadIR(resolvedIRPath);
+    if (!ir) {
+        writeOutput(silentOutput());
+        return;
+    }
+    const state = {};
+    // Dispatch to enforcement engine
+    const output = dispatch(event, ir, rawInput, state);
+    writeOutput(output);
+    // Side effect: audit log for notifications
+    if (event === "Notification" && output.hookSpecificOutput?.additionalContext?.includes("violation")) {
+        const message = typeof rawInput.message === "string" ? rawInput.message : "";
+        await appendAudit(projectDir, {
+            timestamp: new Date().toISOString(),
+            event: "violation",
+            message,
+            session_id: sessionId,
+        }).catch(() => { }); // Fail-open
+    }
+}
+// ── Dispatch ───────────────────────────────────────────────
+function dispatch(event, ir, input, state) {
+    switch (event) {
+        case "PreToolUse":
+            return enforcePreToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+                sessionId: typeof input.sessionId === "string" ? input.sessionId : undefined,
+            }, state);
+        case "PostToolUse":
+            return enforcePostToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                tool_output: typeof input.tool_output === "string" ? input.tool_output : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "UserPromptSubmit":
+            return enforceUserPromptSubmit(ir, {
+                prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+            });
+        case "SubagentStop":
+            return enforceSubagentStop(ir, {
+                agent_name: typeof input.agent_name === "string" ? input.agent_name : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "PreCompact":
+            return enforcePreCompact(ir);
+        case "Notification":
+            return enforceNotification(ir, {
+                title: typeof input.title === "string" ? input.title : undefined,
+                message: typeof input.message === "string" ? input.message : undefined,
+            });
+        case "Stop":
+            return silentOutput(); // DNA doesn't block stops
+        case "SessionStart":
+            return silentOutput(); // Placeholder — will initialize DNA state in future
+        default:
+            return silentOutput();
+    }
+}
+// ── IR Loading ─────────────────────────────────────────────
+async function loadIR(irPath) {
+    try {
+        const raw = await readFile(irPath, "utf-8");
+        const data = JSON.parse(raw);
+        // Support both raw IR and wrapped CompiledIRFile format
+        if (data.ir_version && data.ir) {
+            return data.ir;
+        }
+        // Direct ConstraintIR
+        if (data.compiled_at && data.source_dna_ids) {
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Entry Point ────────────────────────────────────────────
+main().catch(() => {
+    // Fail-open: never block Claude Code on unexpected errors
+    writeOutput(silentOutput());
+});

package/dist/hooks/enforce.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Intent DNA — Enforcement Engine
+ *
+ * Pure functions that evaluate ConstraintIR against hook inputs.
+ * No I/O — reads no files, runs no commands, writes no state.
+ * The hook CLI handles stdin/stdout, IR loading, state, and checkpoint execution.
+ *
+ * Enforcement order for PreToolUse:
+ *   1. Role scope (agent_type → write glob patterns)
+ *   2. Tool filters (block/warn/deprioritize by tool name)
+ *   3. Pre-execution gates (condition-based block/escalate)
+ *   4. Output schema (required sections for Write tool)
+ *
+ * Step checkpoints are handled by the CLI, not here.
+ */
+import type { ConstraintIR, RoleDef } from "../schema/types.js";
+import type { PreToolUseInput, PostToolUseInput, UserPromptSubmitInput, SubagentStopInput, NotificationInput, HookOutput } from "./protocol.js";
+export interface EnforceState {
+}
+/**
+ * Enforce PreToolUse constraints.
+ * Returns the first blocking/escalating result, or allow if all pass.
+ *
+ * Optional `roles` parameter provides output_schema enforcement.
+ */
+export declare function enforcePreToolUse(ir: ConstraintIR, input: PreToolUseInput, state?: EnforceState, roles?: Record<string, RoleDef>): HookOutput;
+/**
+ * Enforce PostToolUse validators.
+ * Currently logs validators for audit. Returns allow with context.
+ */
+export declare function enforcePostToolUse(ir: ConstraintIR, input: PostToolUseInput): HookOutput;
+/**
+ * Inject DNA policy reminders on each user prompt.
+ * Only injects when there are high-priority directives.
+ */
+export declare function enforceUserPromptSubmit(ir: ConstraintIR, _input: UserPromptSubmitInput): HookOutput;
+/**
+ * Audit role scope compliance when a subagent finishes.
+ */
+export declare function enforceSubagentStop(ir: ConstraintIR, input: SubagentStopInput): HookOutput;
+/**
+ * Preserve DNA directive summary before context compaction.
+ */
+export declare function enforcePreCompact(ir: ConstraintIR): HookOutput;
+/**
+ * Check if a notification is a DNA violation and return audit info.
+ * The CLI handles actual audit file writes.
+ */
+export declare function enforceNotification(ir: ConstraintIR, input: NotificationInput): HookOutput;
+/** Check if a file path is allowed by a list of write globs (prefix matching). */
+export declare function checkWriteAllowed(filePath: string, allowedGlobs: string[]): boolean;
+/**
+ * Extract directory prefix from a glob pattern.
+ * "src/**\/*.ts" → "src/"
+ * "test/**" → "test/"
+ * "*.md" → "" (root)
+ * "package.json" → "package.json" (exact path)
+ */
+export declare function globToPrefix(glob: string): string;
+/**
+ * Evaluate a gate condition against a PreToolUse input.
+ * Returns true if the condition triggers, false if not, null if too complex.
+ */
+export declare function evaluateGateCondition(condition: string, input: PreToolUseInput): boolean | null;
+/**
+ * Resolve a tool filter target to concrete Claude Code tool names.
+ */
+export declare function resolveToolTarget(target?: string): string[] | null;

package/dist/hooks/enforce.js

@@ -0,0 +1,332 @@
+/**
+ * Intent DNA — Enforcement Engine
+ *
+ * Pure functions that evaluate ConstraintIR against hook inputs.
+ * No I/O — reads no files, runs no commands, writes no state.
+ * The hook CLI handles stdin/stdout, IR loading, state, and checkpoint execution.
+ *
+ * Enforcement order for PreToolUse:
+ *   1. Role scope (agent_type → write glob patterns)
+ *   2. Tool filters (block/warn/deprioritize by tool name)
+ *   3. Pre-execution gates (condition-based block/escalate)
+ *   4. Output schema (required sections for Write tool)
+ *
+ * Step checkpoints are handled by the CLI, not here.
+ */
+import { allowOutput, blockOutput, escalateOutput, silentOutput } from "./protocol.js";
+// ── PreToolUse Enforcement ─────────────────────────────────
+/**
+ * Enforce PreToolUse constraints.
+ * Returns the first blocking/escalating result, or allow if all pass.
+ *
+ * Optional `roles` parameter provides output_schema enforcement.
+ */
+export function enforcePreToolUse(ir, input, state, roles) {
+    // Layer 2: Role scope
+    if (input.agent_type && ir.roles_scope_map && ir.roles_scope_map.length > 0) {
+        const result = enforceRoleScope(ir.roles_scope_map, input);
+        if (result)
+            return result;
+    }
+    // Layer 3: Tool filters
+    if (ir.tool_filters.length > 0) {
+        const result = enforceToolFilters(ir.tool_filters, input);
+        if (result)
+            return result;
+    }
+    // Layer 4: Pre-execution gates
+    if (ir.pre_execution_gates.length > 0) {
+        const result = enforceGates(ir.pre_execution_gates, input);
+        if (result)
+            return result;
+    }
+    // Layer 5: Output schema
+    if (roles && input.tool_name === "Write") {
+        const result = enforceOutputSchema(roles, input);
+        if (result)
+            return result;
+    }
+    return silentOutput();
+}
+// ── PostToolUse Enforcement ────────────────────────────────
+/**
+ * Enforce PostToolUse validators.
+ * Currently logs validators for audit. Returns allow with context.
+ */
+export function enforcePostToolUse(ir, input) {
+    const validators = ir.post_execution_validators;
+    if (validators.length === 0)
+        return silentOutput();
+    const lines = [];
+    for (const v of validators) {
+        lines.push(`[Intent DNA] PostToolUse validator: ${v.check} (gene: ${v.source_gene})`);
+    }
+    return allowOutput(lines.join("\n"));
+}
+// ── UserPromptSubmit Enforcement ───────────────────────────
+/**
+ * Inject DNA policy reminders on each user prompt.
+ * Only injects when there are high-priority directives.
+ */
+export function enforceUserPromptSubmit(ir, _input) {
+    const highPriority = ir.prompt_directives.filter(d => d.priority === "high");
+    if (highPriority.length === 0)
+        return silentOutput();
+    const lines = [
+        "<system-reminder>[Intent DNA] Active high-priority policies:",
+    ];
+    for (const d of highPriority) {
+        lines.push(`  - [${d.source_gene}] ${d.text}`);
+    }
+    lines.push("</system-reminder>");
+    return allowOutput(lines.join("\n"));
+}
+// ── SubagentStop Enforcement ───────────────────────────────
+/**
+ * Audit role scope compliance when a subagent finishes.
+ */
+export function enforceSubagentStop(ir, input) {
+    const rolesScopeMap = ir.roles_scope_map;
+    if (!rolesScopeMap || rolesScopeMap.length === 0)
+        return silentOutput();
+    if (!input.agent_type)
+        return silentOutput();
+    for (const entry of rolesScopeMap) {
+        const agentTypeName = `dna-${toKebabCase(entry.role_name)}`;
+        if (input.agent_type === agentTypeName) {
+            const writeGlobs = entry.scope.write ?? [];
+            const scopeDesc = writeGlobs.length > 0
+                ? `write:[${writeGlobs.join(",")}]`
+                : "write:[]";
+            return allowOutput(`[Intent DNA] SubagentStop audit: role=${entry.role_name} agent=${input.agent_name ?? "unknown"} scope=${scopeDesc}`);
+        }
+    }
+    return allowOutput(`[Intent DNA] SubagentStop: unknown role for agent_type=${input.agent_type}`);
+}
+// ── PreCompact Enforcement ─────────────────────────────────
+/**
+ * Preserve DNA directive summary before context compaction.
+ */
+export function enforcePreCompact(ir) {
+    if (ir.prompt_directives.length === 0)
+        return silentOutput();
+    const critical = ir.prompt_directives.filter(d => d.priority === "high");
+    const standard = ir.prompt_directives.filter(d => d.priority === "medium");
+    const lines = [
+        "[Intent DNA] PreCompact: Preserving directive summary for compact",
+    ];
+    if (critical.length > 0) {
+        lines.push("  Critical directives:");
+        for (const d of critical) {
+            lines.push(`    - [${d.source_gene}] ${d.text}`);
+        }
+    }
+    if (standard.length > 0) {
+        lines.push(`  Standard directives (${standard.length}):`);
+        for (const d of standard) {
+            lines.push(`    - [${d.source_gene}] ${d.text}`);
+        }
+    }
+    return allowOutput(lines.join("\n"));
+}
+// ── Notification Enforcement ───────────────────────────────
+/**
+ * Check if a notification is a DNA violation and return audit info.
+ * The CLI handles actual audit file writes.
+ */
+export function enforceNotification(ir, input) {
+    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 silentOutput();
+    const message = input.message ?? "";
+    if (message.includes("Intent DNA")) {
+        return allowOutput(`[Intent DNA] Notification: violation detected — ${input.title ?? "untitled"}: ${message}`);
+    }
+    return silentOutput();
+}
+// ── Internal: Layer Enforcement ────────────────────────────
+function enforceRoleScope(rolesScopeMap, input) {
+    if (!input.agent_type)
+        return null;
+    if (!isWriteTool(input.tool_name))
+        return null;
+    const filePath = extractFilePath(input);
+    if (!filePath)
+        return null;
+    for (const entry of rolesScopeMap) {
+        const agentTypeName = `dna-${toKebabCase(entry.role_name)}`;
+        if (input.agent_type !== agentTypeName)
+            continue;
+        const writeGlobs = entry.scope.write ?? [];
+        if (writeGlobs.length === 0) {
+            return blockOutput(`[Intent DNA]: Role '${entry.role_name}' has no write permission (path: ${filePath})`);
+        }
+        if (!checkWriteAllowed(filePath, writeGlobs)) {
+            return blockOutput(`[Intent DNA]: Role '${entry.role_name}' cannot write to '${filePath}' (allowed: ${writeGlobs.join(", ")})`);
+        }
+        return null; // Role matched, write allowed
+    }
+    return null; // No matching role — allow
+}
+function enforceToolFilters(filters, input) {
+    for (const filter of filters) {
+        const matchedTools = resolveToolTarget(filter.target);
+        if (!matchedTools)
+            continue;
+        if (!matchedTools.includes(input.tool_name))
+            continue;
+        if (filter.action === "remove") {
+            return blockOutput(`[Intent DNA]: ${filter.reason} (gene: ${filter.source_gene})`);
+        }
+        if (filter.action === "warn") {
+            // Warn but don't block — inject context
+            return allowOutput(`WARN [Intent DNA]: ${filter.reason} (gene: ${filter.source_gene})`);
+        }
+        // deprioritize — log only
+        // Don't return, continue checking other filters
+    }
+    return null;
+}
+function enforceGates(gates, input) {
+    for (const gate of gates) {
+        const matches = evaluateGateCondition(gate.condition, input);
+        if (matches === null)
+            continue; // Condition too complex — skip
+        if (!matches)
+            continue; // Condition not triggered
+        if (gate.action === "block") {
+            return blockOutput(`[Intent DNA]: ${gate.message}`);
+        }
+        if (gate.action === "escalate") {
+            return escalateOutput(`[Intent DNA] ${gate.message}`);
+        }
+        // warn
+        return allowOutput(`WARN [Intent DNA]: ${gate.message}`);
+    }
+    return null;
+}
+function enforceOutputSchema(roles, input) {
+    if (!input.agent_type)
+        return null;
+    const content = input.tool_input.content;
+    if (typeof content !== "string" || !content)
+        return null;
+    for (const [roleName, role] of Object.entries(roles)) {
+        if (!role.output_schema || typeof role.output_schema === "string")
+            continue;
+        const schema = role.output_schema;
+        if (!schema.required_sections || schema.required_sections.length === 0)
+            continue;
+        const agentName = `dna-${toKebabCase(roleName)}`;
+        if (input.agent_type !== agentName)
+            continue;
+        for (const section of schema.required_sections) {
+            if (!content.includes(`## ${section}`)) {
+                return blockOutput(`[Intent DNA]: Output missing required section '${section}' (role: ${roleName})`);
+            }
+        }
+    }
+    return null;
+}
+// ── Public Helpers ──────────────────────────────────────────
+/** Check if a file path is allowed by a list of write globs (prefix matching). */
+export function checkWriteAllowed(filePath, allowedGlobs) {
+    for (const glob of allowedGlobs) {
+        const prefix = globToPrefix(glob);
+        if (prefix.length === 0)
+            return true; // Root glob like "*.md" — allow all
+        if (filePath.startsWith(prefix))
+            return true;
+        // Also check exact match for non-glob patterns
+        if (!glob.includes("*") && filePath === glob)
+            return true;
+    }
+    return false;
+}
+/**
+ * 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);
+}
+/**
+ * Evaluate a gate condition against a PreToolUse input.
+ * Returns true if the condition triggers, false if not, null if too complex.
+ */
+export function evaluateGateCondition(condition, input) {
+    // Pattern: "personal_data_exposure == false"
+    // → check if tool input contains sensitive patterns
+    const boolFalseMatch = condition.match(/^(\w+)\s*==\s*false$/);
+    if (boolFalseMatch) {
+        const metric = boolFalseMatch[1];
+        if (metric === "personal_data_exposure") {
+            const inputStr = JSON.stringify(input.tool_input).toLowerCase();
+            const sensitivePatterns = ["password", "secret", "token", "api_key", "ssn", "credit_card"];
+            return sensitivePatterns.some(p => inputStr.includes(p));
+        }
+        return null; // Unknown boolean metric
+    }
+    // Pattern: "tool_name in ['X', 'Y']"
+    const toolInMatch = condition.match(/^tool_name\s+in\s+\[([^\]]+)\]/);
+    if (toolInMatch) {
+        const tools = toolInMatch[1]
+            .split(",")
+            .map(t => t.trim().replace(/['"]/g, ""));
+        return tools.includes(input.tool_name);
+    }
+    return null; // Too complex
+}
+/**
+ * Resolve a tool filter target to concrete Claude Code tool names.
+ */
+export function resolveToolTarget(target) {
+    if (!target)
+        return null;
+    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[target];
+    if (tools)
+        return tools;
+    // PascalCase target → direct tool name
+    if (/^[A-Z][a-zA-Z]+$/.test(target))
+        return [target];
+    return null;
+}
+// ── Internal Helpers ───────────────────────────────────────
+const WRITE_TOOLS = new Set(["Edit", "Write", "NotebookEdit"]);
+function isWriteTool(toolName) {
+    return WRITE_TOOLS.has(toolName);
+}
+function extractFilePath(input) {
+    const fp = input.tool_input.file_path;
+    if (typeof fp === "string" && fp)
+        return fp;
+    // Bash tool — try to extract from command
+    const cmd = input.tool_input.command;
+    if (typeof cmd === "string")
+        return null; // Can't reliably extract
+    return null;
+}
+/** Convert string to kebab-case (matches agent-md.ts toKebabCase). */
+function toKebabCase(s) {
+    return s
+        .replace(/([a-z])([A-Z])/g, "$1-$2")
+        .replace(/[_\s]+/g, "-")
+        .toLowerCase();
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Intent DNA — Node.js Hook Runtime
+ *
+ * Public exports for the hook enforcement engine.
+ * Used by the `dna-hook` CLI and importable for programmatic use.
+ */
+export { type HookEvent, type HookInput, type HookOutput, type HookInputBase, type PreToolUseInput, type PostToolUseInput, type UserPromptSubmitInput, type SubagentStopInput, type PreCompactInput, type NotificationInput, type StopInput, readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
+export { type EnforceState, enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
+export { type DNAWorkflowState, type AuditEntry, resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";

package/dist/hooks/index.js

@@ -0,0 +1,12 @@
+/**
+ * Intent DNA — Node.js Hook Runtime
+ *
+ * Public exports for the hook enforcement engine.
+ * Used by the `dna-hook` CLI and importable for programmatic use.
+ */
+// Protocol types and I/O
+export { readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
+// Enforcement engine
+export { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
+// State management
+export { resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";

package/dist/hooks/protocol.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Intent DNA — Hook Protocol Types
+ *
+ * TypeScript types for Claude Code hook I/O and stdin/stdout utilities.
+ * All hooks read JSON from stdin and write JSON to stdout.
+ *
+ * Protocol reference: docs/references/cc-source-analysis.md §2
+ */
+export type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "SubagentStop" | "PreCompact" | "Notification" | "Stop" | "SessionStart";
+/** Base fields present in all hook inputs */
+export interface HookInputBase {
+    cwd?: string;
+    sessionId?: string;
+}
+export interface PreToolUseInput extends HookInputBase {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    agent_type?: string;
+}
+export interface PostToolUseInput extends HookInputBase {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_output?: string;
+    agent_type?: string;
+}
+export interface UserPromptSubmitInput extends HookInputBase {
+    prompt?: string;
+}
+export interface SubagentStopInput extends HookInputBase {
+    agent_name?: string;
+    agent_type?: string;
+}
+export interface PreCompactInput extends HookInputBase {
+}
+export interface NotificationInput extends HookInputBase {
+    title?: string;
+    message?: string;
+}
+export interface StopInput extends HookInputBase {
+    stop_reason?: string;
+}
+export type HookInput = PreToolUseInput | PostToolUseInput | UserPromptSubmitInput | SubagentStopInput | PreCompactInput | NotificationInput | StopInput;
+export interface HookOutput {
+    continue: boolean;
+    decision?: "block" | "allow";
+    reason?: string;
+    suppressOutput?: boolean;
+    hookSpecificOutput?: {
+        hookEventName?: string;
+        additionalContext?: string;
+        permissionDecision?: "ask" | "allow" | "deny";
+    };
+}
+/** Create an allow output, optionally injecting text into the conversation. */
+export declare function allowOutput(additionalContext?: string): HookOutput;
+/** Create a block output with reason. */
+export declare function blockOutput(reason: string): HookOutput;
+/** Create an escalate output (ask user for permission). */
+export declare function escalateOutput(reason: string): HookOutput;
+/** Create a silent allow output (no visible output to user). */
+export declare function silentOutput(): HookOutput;
+/**
+ * Read JSON from stdin with timeout protection.
+ * Returns parsed object on success, empty object on failure (fail-open).
+ */
+export declare function readStdin(timeoutMs?: number): Promise<Record<string, unknown>>;
+/**
+ * Write hook output to stdout as JSON.
+ */
+export declare function writeOutput(output: HookOutput): void;