nova-terminal-assistant 0.1.0

package/src/core/model/types.ts

@@ -0,0 +1,77 @@
+// ============================================================================
+// Model Types - Shared types for model providers
+// ============================================================================
+
+import type { Message, ContentBlock, ToolUseContent, TextContent, SessionId, ToolCallId } from '../types/session.js';
+import type { ToolDefinition } from '../types/tools.js';
+
+/** Options for a model completion request */
+export interface ModelRequestOptions {
+  model: string;
+  maxTokens: number;
+  temperature: number;
+  tools: ToolDefinition[];
+  sessionId: SessionId;
+  stopSequences?: string[];
+  systemPrompt?: string;
+  /** Control thinking mode: enabled|disabled|auto */
+  thinking?: string;
+}
+
+/** Response from a model completion request */
+export interface ModelResponse {
+  /** The assistant's message content blocks */
+  content: ContentBlock[];
+  /** The model that generated the response */
+  model: string;
+  /** Stop reason */
+  stopReason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
+  /** Token usage */
+  usage: TokenUsage;
+  /** The full session ID */
+  sessionId: SessionId;
+}
+
+/** Token usage information */
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+}
+
+/** Streaming event types */
+export type StreamEvent =
+  | { type: 'text_delta'; delta: string }
+  | { type: 'thinking_delta'; delta: string }
+  | { type: 'tool_call_start'; toolCallId: string; toolName: string }
+  | { type: 'tool_call_delta'; toolCallId: string; delta: string }
+  | { type: 'tool_call_complete'; toolCallId: string; toolName: string; input: Record<string, unknown> }
+  | { type: 'message_start'; model: string }
+  | { type: 'message_complete'; stopReason: ModelResponse['stopReason']; usage: TokenUsage }
+  | { type: 'error'; error: unknown };
+
+/** Interface that all model providers must implement */
+export interface ModelProvider {
+  /** Provider display name */
+  readonly name: string;
+
+  /** Non-streaming completion */
+  complete(messages: Message[], options: ModelRequestOptions): Promise<ModelResponse>;
+
+  /** Streaming completion */
+  stream(messages: Message[], options: ModelRequestOptions): AsyncGenerator<StreamEvent>;
+
+  /** Token counting (approximate) */
+  countTokens(messages: Message[]): Promise<number>;
+}
+
+/** Helper to create a text content block */
+export function textContent(text: string): TextContent {
+  return { type: 'text', text };
+}
+
+/** Helper to create a tool use content block */
+export function toolUseContent(id: string, name: string, input: Record<string, unknown>): ToolUseContent {
+  return { type: 'tool_use', id: id as ToolCallId, name, input };
+}

package/src/core/security/ApprovalManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApprovalManager.d.ts","sourceRoot":"","sources":["ApprovalManager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,WAAW,sBAAsB;IACrC,4BAA4B;IAC5B,WAAW,EAAE,YAAY,CAAC;IAC1B,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,mDAAmD;IACnD,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,kDAAkD;IAClD,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,4BAA4B;IAC5B,KAAK,CAAC,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC;IACzD,oCAAoC;IACpC,eAAe,EAAE,OAAO,CAAC;IACzB,0BAA0B;IAC1B,YAAY,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;CACvD;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACvD;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,kBAAkB,CAAU;IACpC,OAAO,CAAC,qBAAqB,CAAc;IAC3C,OAAO,CAAC,oBAAoB,CAAc;IAC1C,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,eAAe,CAAsC;IAC7D,OAAO,CAAC,OAAO,CAAgC;gBAEnC,OAAO,EAAE,sBAAsB;IAQ3C,6CAA6C;IAC7C,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAI1C,+BAA+B;IAC/B,OAAO,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI;IAIjC,oCAAoC;IACpC,OAAO,IAAI,YAAY;IAIvB,6CAA6C;IAC7C,gBAAgB,CACd,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO;IA2CV,mDAAmD;IACnD,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,cAAc,CAAC,EAAE,cAAc,GAC9B,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU;IAWzC,4CAA4C;IACtC,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAsB1E,oCAAoC;IACpC,kBAAkB,IAAI,eAAe,EAAE;IAIvC,+BAA+B;IAC/B,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAItC,mCAAmC;IACnC,OAAO,CAAC,YAAY;CAOrB"}

package/src/core/security/ApprovalManager.ts

@@ -0,0 +1,174 @@
+// ============================================================================
+// ApprovalManager - Manages tool approval workflow
+// ============================================================================
+
+import type { ApprovalRequest, ApprovalResponse, ApprovalMode } from '../types/session.js';
+import type { ToolDefinition } from '../types/tools.js';
+import { ApprovalError } from '../types/errors.js';
+
+export interface ApprovalManagerOptions {
+  /** Default approval mode */
+  defaultMode: ApprovalMode;
+  /** Auto-approve tools with 'low' risk */
+  autoApproveLowRisk?: boolean;
+  /** Always require approval for these tool names */
+  alwaysRequireApproval?: string[];
+  /** Never require approval for these tool names */
+  neverRequireApproval?: string[];
+  /** Custom approval rules */
+  rules?: ApprovalRule[];
+}
+
+export interface ApprovalRule {
+  /** Tool name pattern (glob) */
+  toolPattern: string;
+  /** Input field conditions */
+  conditions?: Record<string, (value: unknown) => boolean>;
+  /** Override approval requirement */
+  requireApproval: boolean;
+  /** Override risk level */
+  riskOverride?: 'low' | 'medium' | 'high' | 'critical';
+}
+
+export interface ApprovalHandler {
+  (request: ApprovalRequest): Promise<ApprovalResponse>;
+}
+
+export class ApprovalManager {
+  private mode: ApprovalMode;
+  private autoApproveLowRisk: boolean;
+  private alwaysRequireApproval: Set<string>;
+  private neverRequireApproval: Set<string>;
+  private rules: ApprovalRule[];
+  private pendingRequests = new Map<string, ApprovalRequest>();
+  private handler: ApprovalHandler | null = null;
+
+  constructor(options: ApprovalManagerOptions) {
+    this.mode = options.defaultMode;
+    this.autoApproveLowRisk = options.autoApproveLowRisk ?? false;
+    this.alwaysRequireApproval = new Set(options.alwaysRequireApproval || []);
+    this.neverRequireApproval = new Set(options.neverRequireApproval || []);
+    this.rules = options.rules || [];
+  }
+
+  /** Set the approval handler (UI callback) */
+  setHandler(handler: ApprovalHandler): void {
+    this.handler = handler;
+  }
+
+  /** Update the approval mode */
+  setMode(mode: ApprovalMode): void {
+    this.mode = mode;
+  }
+
+  /** Get the current approval mode */
+  getMode(): ApprovalMode {
+    return this.mode;
+  }
+
+  /** Check if a tool call requires approval */
+  requiresApproval(
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    toolDefinition?: ToolDefinition
+  ): boolean {
+    // YOLO mode: never require approval
+    if (this.mode === 'yolo') return false;
+
+    // Never-approve list
+    if (this.neverRequireApproval.has(toolName)) return false;
+
+    // Always-approve list
+    if (this.alwaysRequireApproval.has(toolName)) return true;
+
+    // Check custom rules
+    for (const rule of this.rules) {
+      if (this.matchPattern(toolName, rule.toolPattern)) {
+        if (rule.conditions) {
+          const matchesAll = Object.entries(rule.conditions).every(
+            ([field, check]) => check(toolInput[field])
+          );
+          if (matchesAll) {
+            return rule.requireApproval;
+          }
+        } else {
+          return rule.requireApproval;
+        }
+      }
+    }
+
+    // Tool definition check
+    if (toolDefinition) {
+      if (typeof toolDefinition.requiresApproval === 'boolean') {
+        return toolDefinition.requiresApproval;
+      }
+      return toolDefinition.requiresApproval(toolInput, this.mode);
+    }
+
+    // Default: require approval in plan mode, skip for low risk in accepting_edits
+    if (this.mode === 'plan') return true;
+    if (this.mode === 'accepting_edits') return false;
+    if (this.mode === 'smart') return true; // Smart mode asks for important ops
+
+    // Default mode: require approval for high/critical risk tools
+    return true;
+  }
+
+  /** Get the effective risk level for a tool call */
+  getRiskLevel(
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    toolDefinition?: ToolDefinition
+  ): 'low' | 'medium' | 'high' | 'critical' {
+    // Check custom rules for risk override
+    for (const rule of this.rules) {
+      if (rule.riskOverride && this.matchPattern(toolName, rule.toolPattern)) {
+        return rule.riskOverride;
+      }
+    }
+
+    return toolDefinition?.riskLevel || 'medium';
+  }
+
+  /** Request user approval for a tool call */
+  async requestApproval(request: ApprovalRequest): Promise<ApprovalResponse> {
+    if (!this.handler) {
+      // No handler set, auto-approve based on mode
+      if (this.mode === 'yolo' || (this.autoApproveLowRisk && request.risk === 'low')) {
+        return { requestId: request.id, approved: true };
+      }
+      throw new ApprovalError('No approval handler configured and approval is required');
+    }
+
+    this.pendingRequests.set(request.id, request);
+
+    try {
+      const response = await this.handler(request);
+      if (!response.requestId) {
+        response.requestId = request.id;
+      }
+      return response;
+    } finally {
+      this.pendingRequests.delete(request.id);
+    }
+  }
+
+  /** Get pending approval requests */
+  getPendingRequests(): ApprovalRequest[] {
+    return Array.from(this.pendingRequests.values());
+  }
+
+  /** Cancel a pending request */
+  cancelRequest(requestId: string): void {
+    this.pendingRequests.delete(requestId);
+  }
+
+  /** Simple glob pattern matching */
+  private matchPattern(name: string, pattern: string): boolean {
+    const regexStr = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*/g, '.*')
+      .replace(/\?/g, '.');
+    return new RegExp(`^${regexStr}$`).test(name);
+  }
+}

package/src/core/security/FileFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileFilter.d.ts","sourceRoot":"","sources":["FileFilter.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,8BAA8B;IAC9B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,+BAA+B;IAC/B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,iCAAiC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iCAAiC;IACjC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,uDAAuD;IACvD,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,cAAc,CAAW;IACjC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,gBAAgB,CAAS;gBAErB,MAAM,EAAE,gBAAgB;IAWpC,sCAAsC;IACtC,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAkBlE,mDAAmD;IACnD,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAiCpC,4CAA4C;IACtC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAgB/F,gCAAgC;IAChC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAW/F,wEAAwE;IACxE,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAQ1C,2BAA2B;IAC3B,OAAO,CAAC,SAAS;CAOlB"}

package/src/core/security/FileFilter.ts

@@ -0,0 +1,141 @@
+// ============================================================================
+// FileFilter - Controls which files can be accessed by tools
+// ============================================================================
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+export interface FileFilterConfig {
+  /** Glob patterns to ignore */
+  ignorePatterns: string[];
+  /** Patterns to always allow */
+  allowPatterns?: string[];
+  /** Maximum file size in bytes */
+  maxFileSize?: number;
+  /** Maximum batch size for operations */
+  maxBatchSize?: number;
+  /** Forbidden paths (absolute) */
+  forbiddenPaths?: string[];
+  /** Working directory (for relative path resolution) */
+  workingDirectory: string;
+}
+
+export class FileFilter {
+  private ignorePatterns: string[];
+  private allowPatterns: string[];
+  private maxFileSize: number;
+  private maxBatchSize: number;
+  private forbiddenPaths: Set<string>;
+  private workingDirectory: string;
+
+  constructor(config: FileFilterConfig) {
+    this.ignorePatterns = config.ignorePatterns;
+    this.allowPatterns = config.allowPatterns || [];
+    this.maxFileSize = config.maxFileSize || 10 * 1024 * 1024; // 10MB
+    this.maxBatchSize = config.maxBatchSize || 100;
+    this.forbiddenPaths = new Set(
+      (config.forbiddenPaths || []).map((p) => path.resolve(p))
+    );
+    this.workingDirectory = config.workingDirectory;
+  }
+
+  /** Check if a file path is allowed */
+  isAllowed(filePath: string): { allowed: boolean; reason?: string } {
+    const resolved = path.resolve(filePath);
+
+    // Check forbidden paths
+    for (const forbidden of this.forbiddenPaths) {
+      if (resolved.startsWith(forbidden) || resolved === forbidden) {
+        return { allowed: false, reason: `Path is in forbidden directory: ${forbidden}` };
+      }
+    }
+
+    // Check if it's within the working directory
+    if (!resolved.startsWith(this.workingDirectory) && !path.isAbsolute(resolved)) {
+      return { allowed: false, reason: `Path is outside the working directory` };
+    }
+
+    return { allowed: true };
+  }
+
+  /** Check if a file path matches ignore patterns */
+  isIgnored(filePath: string): boolean {
+    const normalized = filePath.replace(/\\/g, '/');
+
+    for (const pattern of this.ignorePatterns) {
+      if (this.matchGlob(normalized, pattern)) {
+        return true;
+      }
+    }
+
+    // Standard ignores
+    const alwaysIgnore = [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      '.next',
+      '.nuxt',
+      '__pycache__',
+      '.venv',
+      'venv',
+      '.env',
+      '.env.local',
+    ];
+
+    for (const dir of alwaysIgnore) {
+      if (normalized.includes(`/${dir}/`) || normalized.includes(`\\${dir}\\`)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Check if a file is within size limits */
+  async checkFileSize(filePath: string): Promise<{ ok: boolean; size?: number; reason?: string }> {
+    try {
+      const stat = await fs.stat(filePath);
+      if (stat.size > this.maxFileSize) {
+        return {
+          ok: false,
+          size: stat.size,
+          reason: `File size (${stat.size} bytes) exceeds maximum (${this.maxFileSize} bytes)`,
+        };
+      }
+      return { ok: true, size: stat.size };
+    } catch {
+      return { ok: false, reason: 'Cannot stat file' };
+    }
+  }
+
+  /** Validate a batch of files */
+  validateBatch(filePaths: string[]): { valid: boolean; invalidFiles: string[]; reason?: string } {
+    if (filePaths.length > this.maxBatchSize) {
+      return {
+        valid: false,
+        invalidFiles: filePaths.slice(this.maxBatchSize),
+        reason: `Batch size (${filePaths.length}) exceeds maximum (${this.maxBatchSize})`,
+      };
+    }
+    return { valid: false, invalidFiles: [] };
+  }
+
+  /** Filter a list of file paths, removing ignored and disallowed ones */
+  filterPaths(filePaths: string[]): string[] {
+    return filePaths.filter((p) => {
+      const allowed = this.isAllowed(p);
+      if (!allowed.allowed) return false;
+      return !this.isIgnored(p);
+    });
+  }
+
+  /** Simple glob matching */
+  private matchGlob(str: string, pattern: string): boolean {
+    const regexStr = pattern
+      .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+      .replace(/\*/g, '.*')
+      .replace(/\?/g, '.');
+    return new RegExp(`^${regexStr}$`).test(str);
+  }
+}

package/src/core/security/HookExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HookExecutor.d.ts","sourceRoot":"","sources":["HookExecutor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAG7E,MAAM,WAAW,mBAAmB;IAClC,8CAA8C;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wBAAwB;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,4BAA4B;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,OAAO,CAAU;gBAEb,OAAO,EAAE,mBAAmB;IAQxC,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAQlC,8BAA8B;IAC9B,WAAW,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI;IAMxC,0CAA0C;IACpC,OAAO,CACX,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,UAAU,EAAE,CAAC;IAgCxB,4BAA4B;YACd,WAAW;IA2DzB,6CAA6C;IAC7C,OAAO,CAAC,iBAAiB;IAUzB,0DAA0D;IAC1D,OAAO,CAAC,cAAc;IAStB,2BAA2B;IAC3B,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC,+BAA+B;IAC/B,QAAQ,IAAI,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC;CAGtC"}

package/src/core/security/HookExecutor.ts

@@ -0,0 +1,178 @@
+// ============================================================================
+// HookExecutor - Executes lifecycle hooks
+// ============================================================================
+
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import type { HookConfig, HookResult, HookEvent } from '../types/session.js';
+import { HookError, TimeoutError } from '../types/errors.js';
+
+export interface HookExecutorOptions {
+  /** Default timeout for hook execution (ms) */
+  defaultTimeout?: number;
+  /** Working directory */
+  workingDirectory: string;
+  /** Environment variables */
+  environment?: Record<string, string>;
+  /** Whether hooks are enabled */
+  enabled?: boolean;
+}
+
+export class HookExecutor extends EventEmitter {
+  private hooks = new Map<string, HookConfig[]>();
+  private defaultTimeout: number;
+  private workingDirectory: string;
+  private environment: Record<string, string>;
+  private enabled: boolean;
+
+  constructor(options: HookExecutorOptions) {
+    super();
+    this.defaultTimeout = options.defaultTimeout || 30000;
+    this.workingDirectory = options.workingDirectory;
+    this.environment = options.environment || {};
+    this.enabled = options.enabled ?? true;
+  }
+
+  /** Register a hook configuration */
+  register(config: HookConfig): void {
+    const event = config.event;
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event)!.push(config);
+  }
+
+  /** Register multiple hooks */
+  registerAll(configs: HookConfig[]): void {
+    for (const config of configs) {
+      this.register(config);
+    }
+  }
+
+  /** Execute all hooks for a given event */
+  async execute(
+    event: HookEvent,
+    context?: Record<string, unknown>
+  ): Promise<HookResult[]> {
+    if (!this.enabled) return [];
+
+    const hooks = this.hooks.get(event) || [];
+    const results: HookResult[] = [];
+
+    for (const hook of hooks) {
+      // Check condition
+      if (hook.condition) {
+        try {
+          const meets = this.evaluateCondition(hook.condition, context || {});
+          if (!meets) continue;
+        } catch {
+          continue;
+        }
+      }
+
+      const result = await this.executeHook(hook, context);
+      results.push(result);
+
+      this.emit('hook_executed', { event, hook, result });
+
+      // If hook failed, stop chain
+      if (result.exitCode !== 0) {
+        this.emit('hook_failed', { event, hook, result });
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  /** Execute a single hook */
+  private async executeHook(hook: HookConfig, context?: Record<string, unknown>): Promise<HookResult> {
+    const timeout = hook.timeout || this.defaultTimeout;
+    const startTime = Date.now();
+
+    return new Promise<HookResult>((resolve) => {
+      // Build environment with context variables
+      const env: Record<string, string> = {
+        ...this.environment,
+        NOVA_HOOK_EVENT: hook.event,
+        NOVA_WORKING_DIR: this.workingDirectory,
+        ...(context ? this.flattenContext(context) : {}),
+      };
+
+      const proc = spawn('sh', ['-c', hook.command], {
+        cwd: this.workingDirectory,
+        env: { ...process.env, ...env },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (data: Buffer) => { stdout += data.toString(); });
+      proc.stderr.on('data', (data: Buffer) => { stderr += data.toString(); });
+      proc.stdin.end();
+
+      const timer = setTimeout(() => {
+        proc.kill('SIGKILL');
+        resolve({
+          exitCode: -1,
+          stdout,
+          stderr: stderr || `Hook timed out after ${timeout}ms`,
+          duration: Date.now() - startTime,
+        });
+      }, timeout);
+
+      proc.on('close', (code) => {
+        clearTimeout(timer);
+        resolve({
+          exitCode: code ?? -1,
+          stdout,
+          stderr,
+          duration: Date.now() - startTime,
+        });
+      });
+
+      proc.on('error', (err) => {
+        clearTimeout(timer);
+        resolve({
+          exitCode: -1,
+          stdout: '',
+          stderr: err.message,
+          duration: Date.now() - startTime,
+        });
+      });
+    });
+  }
+
+  /** Evaluate a simple condition expression */
+  private evaluateCondition(condition: string, context: Record<string, unknown>): boolean {
+    // Support simple conditions like "tool == write_file" or "risk == critical"
+    const match = condition.match(/^(\w+)\s*==\s*(\w+)$/);
+    if (match) {
+      const [, key, value] = match;
+      return String(context[key]) === value;
+    }
+    return false;
+  }
+
+  /** Flatten context object into NOVA_ prefixed env vars */
+  private flattenContext(context: Record<string, unknown>): Record<string, string> {
+    const result: Record<string, string> = {};
+    for (const [key, value] of Object.entries(context)) {
+      const envKey = `NOVA_${key.toUpperCase().replace(/[^A-Z0-9_]/g, '_')}`;
+      result[envKey] = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    return result;
+  }
+
+  /** Enable/disable hooks */
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled;
+  }
+
+  /** Get all registered hooks */
+  getHooks(): Map<string, HookConfig[]> {
+    return new Map(this.hooks);
+  }
+}