@ulpi/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2120 @@
+#!/usr/bin/env node
+import {
+  discoverUlpiServer,
+  registerWithServer,
+  waitForServerDecision
+} from "./chunk-2MZER6ND.js";
+import {
+  captureCommitDiff,
+  extractSections,
+  extractTitle,
+  getSectionFullText,
+  isGitCommitCommand,
+  parseMarkdownToBlocks
+} from "./chunk-3SBPZRB5.js";
+import {
+  detectStack
+} from "./chunk-2CLNOKPA.js";
+import {
+  getDefaultProject,
+  getProject,
+  registerProject
+} from "./chunk-SPOI23SB.js";
+import {
+  injectSkill,
+  loadSkillSync
+} from "./chunk-6OCEY7JY.js";
+import {
+  evaluateRules,
+  loadRulesSync,
+  matchesFilePattern
+} from "./chunk-SIAQVRKG.js";
+import {
+  buildPrePromptSnapshot,
+  buildSessionSummary,
+  entryExists,
+  findReviewPlansForCommit,
+  getCommitDiffStats,
+  getCommitMetadata,
+  getCommitRawDiff,
+  getCurrentHead,
+  historyBranchExists,
+  listCommitsBetween,
+  loadActiveGuards,
+  readBranchMeta,
+  readEntryTranscript,
+  readTranscript,
+  updateEntryTranscript,
+  writeHistoryEntry
+} from "./chunk-NNUWU6CV.js";
+import {
+  JsonSessionStore,
+  appendEvent,
+  createInitialState,
+  projectDirToSlug,
+  readEvents,
+  updateStateFromInput
+} from "./chunk-YM2HV4IA.js";
+import "./chunk-KIKPIH6N.js";
+import {
+  NOTIFICATIONS_LOG_FILE,
+  REVIEW_FLAGS_DIR,
+  SESSIONS_DIR,
+  ULPI_GLOBAL_DIR,
+  getApiHost,
+  getApiPort,
+  globalGuardsFile,
+  loadUlpiSettings,
+  projectGuardsFile,
+  projectGuardsFileAlt,
+  projectNoAutoGenFile
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/index.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/hooks/handler.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/hooks/session-start.ts
+import { existsSync } from "fs";
+import { join } from "path";
+async function handleSessionStart(ctx) {
+  const { input, state, store, projectDir: projectDir2 } = ctx;
+  try {
+    state.stack = detectStack(projectDir2);
+  } catch {
+  }
+  try {
+    const { execFileSync: execFileSync2 } = await import("child_process");
+    const branch = execFileSync2("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: projectDir2,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    if (branch && branch !== "HEAD") {
+      state.branch = branch;
+    }
+  } catch {
+  }
+  try {
+    const head = getCurrentHead(projectDir2);
+    if (head) state.headAtStart = head;
+  } catch {
+  }
+  state.phase = "active";
+  state.transcriptPath = input.transcript_path;
+  try {
+    const { execFileSync: execFileSync2 } = await import("child_process");
+    const untracked = execFileSync2("git", ["ls-files", "--others", "--exclude-standard"], {
+      cwd: projectDir2,
+      encoding: "utf-8",
+      timeout: 3e3
+    }).toString().trim();
+    state.untrackedFilesAtStart = untracked ? untracked.split("\n") : [];
+    try {
+      execFileSync2("git", ["diff", "--quiet"], { cwd: projectDir2, timeout: 3e3 });
+      state.workingTreeDirtyAtStart = false;
+    } catch {
+      state.workingTreeDirtyAtStart = true;
+    }
+  } catch {
+  }
+  if (!state.sessionName) {
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toLocaleDateString("en-US", { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+    state.sessionName = state.branch ? `${state.branch} - ${dateStr}` : dateStr;
+  }
+  store.save(state);
+  appendEvent(input.session_id, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "session_start",
+    hookEvent: input.hook_event_name,
+    message: `Session started in ${projectDir2}`
+  }, projectDir2);
+  if (shouldPromptForGeneration(projectDir2)) {
+    outputGenerationPrompt();
+  }
+  import("./version-checker-ANCS3IHR.js").then((m) => m.checkForUpdates()).catch(() => {
+  });
+  try {
+    const { isMemoryEnabled, loadMemoryConfig, getTopMemories, formatMemoriesForAgent } = await import("./dist-R5F4MX3I.js");
+    if (isMemoryEnabled(projectDir2)) {
+      const config = loadMemoryConfig(projectDir2);
+      if (config.surfaceOnStart) {
+        const memories = getTopMemories(projectDir2, config.surfaceLimit);
+        if (memories.length > 0) {
+          const formatted = formatMemoriesForAgent(memories);
+          process.stderr.write(formatted + "\n");
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const { loadCodemapConfig } = await import("./dist-LZKZFPVX.js");
+    const { getCodemapBranch, getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+    const { historyBranchExists: historyBranchExists2 } = await import("./dist-RJGCUS3L.js");
+    const codemapConfig = loadCodemapConfig(projectDir2);
+    if (codemapConfig.autoImport) {
+      const branch = state.branch ?? getCurrentBranch(projectDir2);
+      const shadowBranch = getCodemapBranch(branch);
+      if (historyBranchExists2(projectDir2, shadowBranch)) {
+        const { importIndex } = await import("./dist-LZKZFPVX.js");
+        await importIndex(projectDir2, branch);
+      }
+    }
+  } catch {
+  }
+}
+function shouldPromptForGeneration(projectDir2) {
+  const rulesYml = projectGuardsFile(projectDir2);
+  const rulesYaml = projectGuardsFileAlt(projectDir2);
+  if (existsSync(rulesYml) || existsSync(rulesYaml)) {
+    return false;
+  }
+  const hasPackageJson = existsSync(join(projectDir2, "package.json"));
+  const hasPyProject = existsSync(join(projectDir2, "pyproject.toml"));
+  const hasCargoToml = existsSync(join(projectDir2, "Cargo.toml"));
+  const hasComposerJson = existsSync(join(projectDir2, "composer.json"));
+  const hasGemfile = existsSync(join(projectDir2, "Gemfile"));
+  const hasGoMod = existsSync(join(projectDir2, "go.mod"));
+  if (!hasPackageJson && !hasPyProject && !hasCargoToml && !hasComposerJson && !hasGemfile && !hasGoMod) {
+    return false;
+  }
+  if (hasBeenDismissed(projectDir2)) {
+    return false;
+  }
+  return true;
+}
+function hasBeenDismissed(projectDir2) {
+  const dismissFile = projectNoAutoGenFile(projectDir2);
+  return existsSync(dismissFile);
+}
+function outputGenerationPrompt() {
+  const message = `
+\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E
+\u2502  ULPI Not Configured                                       \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502                                                         \u2502
+\u2502  Would you like to auto-generate hooks for this        \u2502
+\u2502  project? This will:                                    \u2502
+\u2502                                                         \u2502
+\u2502  \u2022 Detect your stack (language, framework, tools)       \u2502
+\u2502  \u2022 Generate optimized guards.yml                         \u2502
+\u2502  \u2022 Auto-approve safe operations                         \u2502
+\u2502  \u2022 Block dangerous commands                             \u2502
+\u2502                                                         \u2502
+\u2502  To generate: Type "/ulpi-generate-guardian" or say      \u2502
+\u2502               "yes, generate guardian"                   \u2502
+\u2502                                                         \u2502
+\u2502  After generating, manage hooks via web UI:             \u2502
+\u2502    ulpi ui                                              \u2502
+\u2502    \u2192 http://localhost:${getApiPort()}                              \u2502
+\u2502                                                         \u2502
+\u2502  To dismiss:  Create empty .ulpi/.no-auto-gen           \u2502
+\u2502               file                                      \u2502
+\u2502                                                         \u2502
+\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F
+`;
+  process.stderr.write(message);
+}
+
+// ../../packages/notifications-engine/dist/index.js
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function classifyNotification(input) {
+  if (input.notification_type) {
+    return input.notification_type;
+  }
+  const msg = (input.message ?? "").toLowerCase();
+  if (msg.includes("permission")) return "permission_prompt";
+  if (msg.includes("idle") || msg.includes("waiting")) return "idle_prompt";
+  if (msg.includes("auth")) return "auth_success";
+  if (msg.includes("elicitation") || msg.includes("input")) return "elicitation_dialog";
+  return "unknown";
+}
+var NotificationDeduplicator = class _NotificationDeduplicator {
+  seen = /* @__PURE__ */ new Map();
+  windowMs;
+  maxEntries;
+  checkCount = 0;
+  static CLEANUP_INTERVAL = 100;
+  constructor(windowMs = 5e3, maxEntries = 1e3) {
+    this.windowMs = windowMs;
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Check if this notification should be suppressed.
+   * Returns true if the notification is a duplicate (should be suppressed).
+   */
+  isDuplicate(key) {
+    const now = Date.now();
+    this.checkCount++;
+    if (this.checkCount >= _NotificationDeduplicator.CLEANUP_INTERVAL || this.seen.size > this.maxEntries) {
+      this.cleanup(now);
+      this.checkCount = 0;
+    }
+    const lastSeen = this.seen.get(key);
+    if (lastSeen !== void 0 && now - lastSeen < this.windowMs) {
+      return true;
+    }
+    this.seen.set(key, now);
+    if (this.seen.size > this.maxEntries) {
+      this.evictOldest();
+    }
+    return false;
+  }
+  /**
+   * Remove expired entries.
+   */
+  cleanup(now) {
+    for (const [key, ts] of this.seen) {
+      if (now - ts >= this.windowMs) {
+        this.seen.delete(key);
+      }
+    }
+  }
+  /**
+   * Evict the oldest half of entries when hard cap is exceeded.
+   */
+  evictOldest() {
+    const entries = Array.from(this.seen.entries()).sort((a, b) => a[1] - b[1]);
+    const toRemove = Math.floor(entries.length / 2);
+    for (let i = 0; i < toRemove; i++) {
+      this.seen.delete(entries[i][0]);
+    }
+  }
+  /** Update the deduplication time window. */
+  setWindowMs(ms) {
+    this.windowMs = ms;
+  }
+  /** Reset all state. */
+  clear() {
+    this.seen.clear();
+    this.checkCount = 0;
+  }
+};
+function sendDesktopNotification(title, message) {
+  const platform2 = os.platform();
+  try {
+    if (platform2 === "darwin") {
+      const escapedBody = message.replace(/["\\]/g, "\\$&");
+      const escapedTitle = title.replace(/["\\]/g, "\\$&");
+      const script = `display notification "${escapedBody}" with title "${escapedTitle}"`;
+      execFileSync("osascript", ["-e", script], {
+        timeout: 5e3,
+        stdio: "ignore"
+      });
+      return true;
+    }
+    if (platform2 === "linux") {
+      execFileSync("notify-send", [title, message], {
+        timeout: 5e3,
+        stdio: "ignore"
+      });
+      return true;
+    }
+    if (platform2 === "win32") {
+      const escapedTitle = title.replace(/'/g, "''");
+      const escapedBody = message.replace(/'/g, "''");
+      const ps = [
+        "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null",
+        "$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)",
+        "$textNodes = $template.GetElementsByTagName('text')",
+        `$textNodes.Item(0).AppendChild($template.CreateTextNode('${escapedTitle}')) | Out-Null`,
+        `$textNodes.Item(1).AppendChild($template.CreateTextNode('${escapedBody}')) | Out-Null`,
+        "$toast = [Windows.UI.Notifications.ToastNotification]::new($template)",
+        "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('ULPI').Show($toast)"
+      ].join("\n");
+      const tmpFile = join2(tmpdir(), `ulpi-notify-${Date.now()}.ps1`);
+      try {
+        writeFileSync(tmpFile, ps);
+        execFileSync(
+          "powershell",
+          ["-ExecutionPolicy", "Bypass", "-File", tmpFile],
+          { timeout: 5e3, stdio: "ignore" }
+        );
+      } finally {
+        try {
+          unlinkSync(tmpFile);
+        } catch {
+        }
+      }
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function validateWebhookUrl(url) {
+  const parsed = new URL(url);
+  const hostname = parsed.hostname.toLowerCase();
+  const blocked = [
+    "localhost",
+    "127.0.0.1",
+    "0.0.0.0",
+    "::1",
+    "[::1]",
+    "169.254.169.254"
+    // AWS/GCP metadata
+  ];
+  if (blocked.includes(hostname)) {
+    throw new Error(`Webhook URL targets blocked address: ${hostname}`);
+  }
+  if (hostname.startsWith("10.") || hostname.startsWith("192.168.") || hostname.startsWith("172.16.") || hostname.startsWith("172.17.") || hostname.startsWith("172.18.") || hostname.startsWith("172.19.") || hostname.startsWith("172.2") || hostname.startsWith("172.30.") || hostname.startsWith("172.31.")) {
+    throw new Error(`Webhook URL targets blocked address: ${hostname}`);
+  }
+  if (hostname.endsWith(".local") || hostname.endsWith(".internal")) {
+    throw new Error(`Webhook URL targets blocked address: ${hostname}`);
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new Error("Webhook URL must use http or https protocol");
+  }
+}
+async function sendWebhookNotification(url, payload, headers) {
+  try {
+    validateWebhookUrl(url);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "ULPI/1.0",
+        ...headers
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function validateLogPath(logPath) {
+  const resolvedPath = path.resolve(logPath);
+  const resolvedBase = path.resolve(ULPI_GLOBAL_DIR);
+  if (!resolvedPath.startsWith(resolvedBase + path.sep) && resolvedPath !== resolvedBase) {
+    throw new Error("Log path must be within ULPI config directory");
+  }
+}
+function logNotification(entry, logPath) {
+  const target = logPath ?? NOTIFICATIONS_LOG_FILE;
+  try {
+    if (logPath) {
+      validateLogPath(logPath);
+    }
+    const dir = path.dirname(target);
+    fs.mkdirSync(dir, { recursive: true });
+    const line = JSON.stringify(entry) + "\n";
+    fs.appendFileSync(target, line, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sendTerminalBell() {
+  process.stderr.write("\x07");
+}
+function writeTerminalNotification(title, message) {
+  process.stderr.write(`
+[ulpi] ${title}: ${message}
+`);
+}
+var deduplicator = new NotificationDeduplicator();
+function getEventConfig(classified, config) {
+  const key = classified;
+  const value = config[key];
+  if (value && typeof value === "object" && "notify" in value) {
+    return value;
+  }
+  return void 0;
+}
+function collectActions(eventConfig) {
+  const actions = [];
+  const act = eventConfig.act;
+  if (!act) return actions;
+  if (act.inject_skill) actions.push(`inject_skill:${act.inject_skill}`);
+  if (act.inject_skill_on_retry) actions.push("inject_skill_on_retry");
+  if (act.inject_skill_after_n_blocks != null) actions.push("inject_skill_after_n_blocks");
+  if (act.alert_after_n_blocks != null) actions.push("alert_after_n_blocks");
+  if (act.rate_limit) actions.push("rate_limit");
+  if (act.log_failure_details) actions.push("log_failure_details");
+  return actions;
+}
+async function dispatchNotification(eventType, title, message, config) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const windowMs = config?.dedup_window_seconds ? config.dedup_window_seconds * 1e3 : 5e3;
+  deduplicator.setWindowMs(windowMs);
+  const dedupeKey = `${eventType}:${message}`;
+  if (deduplicator.isDuplicate(dedupeKey)) {
+    return { classified: eventType, channels: [], actions: [], suppressed: true };
+  }
+  const channels = [];
+  const actions = [];
+  const eventConfig = config ? getEventConfig(eventType, config) : void 0;
+  if (eventConfig) {
+    for (const channel of eventConfig.notify) {
+      const sent = await routeToChannel(channel, title, message, timestamp, eventType);
+      if (sent) channels.push(channel.type);
+    }
+    actions.push(...collectActions(eventConfig));
+  } else {
+    logNotification({ event: eventType, title, message, timestamp });
+    channels.push("log");
+  }
+  return {
+    classified: eventType,
+    channels,
+    actions,
+    suppressed: false,
+    actConfig: eventConfig?.act
+  };
+}
+async function routeNotification(input, config) {
+  const classified = classifyNotification(input);
+  const title = input.title ?? "ULPI";
+  const message = input.message ?? classified;
+  return dispatchNotification(classified, title, message, config);
+}
+async function fireNotification(eventType, title, message, config) {
+  return dispatchNotification(eventType, title, message, config);
+}
+async function routeToChannel(channel, title, message, timestamp, event) {
+  const displayMessage = channel.message ?? message;
+  switch (channel.type) {
+    case "desktop":
+      return sendDesktopNotification(title, displayMessage);
+    case "terminal":
+      if (channel.sound !== false) {
+        sendTerminalBell();
+      }
+      writeTerminalNotification(title, displayMessage);
+      return true;
+    case "log": {
+      const logPath = channel.path ?? void 0;
+      return logNotification(
+        { event, title, message: displayMessage, timestamp },
+        logPath
+      );
+    }
+    case "webhook": {
+      if (!channel.url) return false;
+      return sendWebhookNotification(channel.url, {
+        event,
+        title,
+        message: displayMessage,
+        timestamp
+      });
+    }
+    default:
+      return false;
+  }
+}
+function evaluateNotificationTriggers(state, latestEvent, config, recentEvents) {
+  if (!config) return [];
+  const triggers = [];
+  const ruleBlockedTrigger = checkRuleBlocked(latestEvent, config);
+  if (ruleBlockedTrigger) triggers.push(ruleBlockedTrigger);
+  const repeatedTrigger = checkRepeatedFailures(state, config);
+  if (repeatedTrigger) triggers.push(repeatedTrigger);
+  const sensitiveTrigger = checkSensitivePathAccess(
+    latestEvent,
+    state,
+    config
+  );
+  if (sensitiveTrigger) triggers.push(sensitiveTrigger);
+  const rapidTrigger = checkRapidPermissionRequests(recentEvents, config);
+  if (rapidTrigger) triggers.push(rapidTrigger);
+  const taskFailedTrigger = checkTaskFailed(latestEvent, config);
+  if (taskFailedTrigger) triggers.push(taskFailedTrigger);
+  const taskCompleteTrigger = checkTaskComplete(latestEvent, state, config);
+  if (taskCompleteTrigger) triggers.push(taskCompleteTrigger);
+  return triggers;
+}
+function checkRuleBlocked(latestEvent, config) {
+  if (!config.rule_blocked) return null;
+  if (latestEvent.type !== "tool_blocked") return null;
+  const tool = latestEvent.toolName ?? "unknown tool";
+  const rule = latestEvent.ruleName ?? "unknown rule";
+  const detail = latestEvent.message ? `: ${latestEvent.message}` : "";
+  return {
+    eventType: "rule_blocked",
+    title: "ULPI",
+    message: `Blocked ${tool} by rule "${rule}"${detail}`,
+    urgency: config.rule_blocked.urgency
+  };
+}
+function checkRepeatedFailures(state, config) {
+  if (!config.repeated_failures) return null;
+  const threshold = config.repeated_failures.threshold ?? 3;
+  const blocks = state.consecutiveBlocks;
+  if (blocks < threshold) return null;
+  if (blocks % threshold !== 0) return null;
+  return {
+    eventType: "repeated_failures",
+    title: "ULPI",
+    message: `${blocks} consecutive blocks detected (threshold: ${threshold}). The agent may be stuck in a retry loop.`,
+    urgency: config.repeated_failures.urgency
+  };
+}
+function checkSensitivePathAccess(latestEvent, state, config) {
+  if (!config.sensitive_path_access) return null;
+  const patterns = config.sensitive_path_access.file_patterns;
+  if (!patterns || patterns.length === 0) return null;
+  const filePath = latestEvent.filePath;
+  if (!filePath) return null;
+  const projectDir2 = state.projectDir || ".";
+  const matched = patterns.some(
+    (pattern) => matchesFilePattern(pattern, filePath, projectDir2)
+  );
+  if (!matched) return null;
+  return {
+    eventType: "sensitive_path_access",
+    title: "ULPI",
+    message: `Sensitive file accessed: ${filePath}`,
+    urgency: config.sensitive_path_access.urgency
+  };
+}
+function checkRapidPermissionRequests(recentEvents, config) {
+  if (!config.rapid_permission_requests) return null;
+  if (!recentEvents || recentEvents.length === 0) return null;
+  const windowSeconds = config.rapid_permission_requests.window_seconds ?? 60;
+  const threshold = config.rapid_permission_requests.threshold ?? 5;
+  const now = Date.now();
+  const windowMs = windowSeconds * 1e3;
+  const permissionEvents = recentEvents.filter((evt) => {
+    if (evt.event !== "permission_allow" && evt.event !== "permission_deny") {
+      return false;
+    }
+    const evtTime = new Date(evt.ts).getTime();
+    return now - evtTime <= windowMs;
+  });
+  if (permissionEvents.length < threshold) return null;
+  return {
+    eventType: "rapid_permission_requests",
+    title: "ULPI",
+    message: `${permissionEvents.length} permission requests in the last ${windowSeconds}s (threshold: ${threshold}). The agent may be requesting excessive permissions.`,
+    urgency: config.rapid_permission_requests.urgency
+  };
+}
+function checkTaskFailed(latestEvent, config) {
+  if (!config.task_failed) return null;
+  if (latestEvent.type !== "postcondition_failed") return null;
+  const command2 = latestEvent.command ?? "unknown command";
+  const detail = latestEvent.message ? `: ${latestEvent.message}` : "";
+  return {
+    eventType: "task_failed",
+    title: "ULPI",
+    message: `Postcondition failed for "${command2}"${detail}`,
+    urgency: config.task_failed.urgency
+  };
+}
+function checkTaskComplete(latestEvent, state, config) {
+  if (!config.task_complete) return null;
+  if (latestEvent.type !== "session_end") return null;
+  if (state.filesWritten.length === 0) return null;
+  const filesWritten = state.filesWritten.length;
+  const blocked = state.actionsBlocked;
+  const blockNote = blocked > 0 ? ` (${blocked} action${blocked === 1 ? "" : "s"} blocked)` : "";
+  return {
+    eventType: "task_complete",
+    title: "ULPI",
+    message: `Session complete: ${filesWritten} file${filesWritten === 1 ? "" : "s"} written${blockNote}.`,
+    urgency: config.task_complete.urgency
+  };
+}
+var rateLimitCounters = /* @__PURE__ */ new Map();
+function isRateLimited(eventType, threshold, windowSeconds) {
+  const now = Date.now();
+  const windowMs = windowSeconds * 1e3;
+  const entry = rateLimitCounters.get(eventType);
+  if (!entry || now - entry.windowStart >= windowMs) {
+    rateLimitCounters.set(eventType, { count: 1, windowStart: now });
+    return false;
+  }
+  entry.count++;
+  if (entry.count > threshold) {
+    return true;
+  }
+  return false;
+}
+function executeActions(act, ctx) {
+  const result = {
+    stderrMessage: ctx.stderrMessage,
+    extraChannels: [],
+    rateLimitSuppressed: false,
+    failureDetailsLogged: false
+  };
+  if (!act) return result;
+  const blocks = ctx.state.consecutiveBlocks;
+  if (act.rate_limit) {
+    if (isRateLimited(ctx.eventType, act.rate_limit.threshold, act.rate_limit.window_seconds)) {
+      result.rateLimitSuppressed = true;
+      return result;
+    }
+  }
+  if (act.inject_skill) {
+    result.stderrMessage = appendSkill(result.stderrMessage, act.inject_skill, ctx.projectDir);
+  }
+  if (act.inject_skill_on_retry && blocks > 0) {
+    result.stderrMessage = appendSkill(result.stderrMessage, act.inject_skill_on_retry, ctx.projectDir);
+  }
+  if (act.inject_skill_after_n_blocks != null && blocks >= act.inject_skill_after_n_blocks && act.inject_skill) {
+    result.stderrMessage = appendSkill(result.stderrMessage, act.inject_skill, ctx.projectDir);
+  }
+  if (act.alert_after_n_blocks != null && blocks >= act.alert_after_n_blocks) {
+    if (act.alert_channels && act.alert_channels.length > 0) {
+      result.extraChannels = act.alert_channels;
+    }
+  }
+  if (act.log_failure_details && ctx.latestEvent) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    logNotification({
+      event: `${ctx.eventType}:failure_details`,
+      title: "Failure Details",
+      message: JSON.stringify({
+        toolName: ctx.latestEvent.toolName,
+        toolInput: ctx.latestEvent.toolInput,
+        ruleName: ctx.latestEvent.ruleName,
+        ruleMessage: ctx.latestEvent.message,
+        consecutiveBlocks: blocks,
+        filesWritten: ctx.state.filesWritten.length,
+        commandsRun: ctx.state.commandsRun.length
+      }),
+      timestamp
+    });
+    result.failureDetailsLogged = true;
+  }
+  return result;
+}
+function appendSkill(message, skillPath, projectDir2) {
+  const content = loadSkillSync(skillPath, projectDir2);
+  if (!content) return message;
+  if (!message) return content;
+  return `${message}
+
+---
+
+${content}`;
+}
+function auditNotification(entry, projectDir2, baseDir) {
+  try {
+    const slug = projectDirToSlug(projectDir2);
+    const dir = baseDir ? path2.join(baseDir, "sessions", slug) : path2.join(SESSIONS_DIR, slug);
+    fs2.mkdirSync(dir, { recursive: true });
+    const filePath = path2.join(dir, "notifications.jsonl");
+    const line = JSON.stringify(entry) + "\n";
+    fs2.appendFileSync(filePath, line, "utf-8");
+  } catch {
+  }
+}
+
+// src/hooks/notify-with-actions.ts
+async function fireWithActions(triggers, responses, ctx) {
+  let stderrMessage = ctx.stderrMessage;
+  for (const trigger of triggers) {
+    try {
+      const routeResult = await fireNotification(
+        trigger.eventType,
+        trigger.title,
+        trigger.message,
+        responses
+      );
+      const actionCtx = {
+        eventType: trigger.eventType,
+        state: ctx.state,
+        projectDir: ctx.projectDir,
+        stderrMessage,
+        latestEvent: ctx.latestEvent ? {
+          toolName: ctx.latestEvent.toolName,
+          toolInput: ctx.latestEvent.toolInput,
+          ruleName: ctx.latestEvent.ruleName,
+          message: ctx.latestEvent.message
+        } : void 0
+      };
+      const actionResult = executeActions(routeResult.actConfig, actionCtx);
+      if (actionResult.stderrMessage !== stderrMessage) {
+        stderrMessage = actionResult.stderrMessage;
+      }
+      if (actionResult.extraChannels.length > 0) {
+        for (const channel of actionResult.extraChannels) {
+          await dispatchToChannel(channel, trigger.title, trigger.message);
+        }
+      }
+      const auditEntry = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: ctx.sessionId,
+        eventType: trigger.eventType,
+        urgency: trigger.urgency,
+        title: trigger.title,
+        message: trigger.message,
+        channels: routeResult.channels,
+        actions: routeResult.actions,
+        suppressed: routeResult.suppressed || actionResult.rateLimitSuppressed,
+        suppressReason: routeResult.suppressed ? "dedup" : actionResult.rateLimitSuppressed ? "rate_limit" : void 0,
+        triggerContext: ctx.latestEvent ? {
+          toolName: ctx.latestEvent.toolName,
+          filePath: ctx.latestEvent.filePath,
+          command: ctx.latestEvent.command,
+          ruleName: ctx.latestEvent.ruleName,
+          consecutiveBlocks: ctx.state.consecutiveBlocks
+        } : void 0
+      };
+      auditNotification(auditEntry, ctx.projectDir);
+    } catch {
+    }
+  }
+  return { stderrMessage };
+}
+async function dispatchToChannel(channel, title, message) {
+  const displayMessage = channel.message ?? message;
+  switch (channel.type) {
+    case "desktop":
+      await sendDesktopNotification(title, displayMessage);
+      break;
+    case "terminal":
+      if (channel.sound !== false) sendTerminalBell();
+      writeTerminalNotification(title, displayMessage);
+      break;
+    case "log":
+      logNotification({
+        event: "alert_escalation",
+        title,
+        message: displayMessage,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }, channel.path ?? void 0);
+      break;
+    case "webhook":
+      if (channel.url) {
+        await sendWebhookNotification(channel.url, {
+          event: "alert_escalation",
+          title,
+          message: displayMessage,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      break;
+  }
+}
+
+// src/hooks/review-integration.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync, readdirSync, statSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join4 } from "path";
+var FLAGS_BASE = REVIEW_FLAGS_DIR;
+function flagsDir(sessionId) {
+  return sessionId ? join4(FLAGS_BASE, sessionId) : FLAGS_BASE;
+}
+function ensureFlagsDir(sessionId) {
+  const dir = flagsDir(sessionId);
+  if (!existsSync2(dir)) mkdirSync3(dir, { recursive: true });
+}
+function getReviewSettings() {
+  return loadUlpiSettings().review;
+}
+function isReviewEnabled(type) {
+  const review = getReviewSettings();
+  if (!review.enabled) return false;
+  if (type === "plan") return review.plan_review;
+  if (type === "code") return review.code_review;
+  return false;
+}
+async function extractPlanForReview(input) {
+  if (input.tool_input?.plan && typeof input.tool_input.plan === "string") {
+    return input.tool_input.plan;
+  }
+  if (input.tool_input?.planFilePath && typeof input.tool_input.planFilePath === "string") {
+    try {
+      return readFileSync(input.tool_input.planFilePath, "utf-8");
+    } catch {
+    }
+  }
+  if (input.transcript_path) {
+    const planFromTranscript = extractPlanFromTranscript(input.transcript_path);
+    if (planFromTranscript) return planFromTranscript;
+  }
+  const planDirs = [
+    input.cwd ? join4(input.cwd, ".claude", "plans") : null,
+    join4(homedir(), ".claude", "plans")
+  ].filter(Boolean);
+  for (const dir of planDirs) {
+    const planFromDir = extractPlanFromDirectory(dir);
+    if (planFromDir) return planFromDir;
+  }
+  return null;
+}
+function extractPlanFromDirectory(plansDir) {
+  try {
+    if (!existsSync2(plansDir)) return null;
+    const files = readdirSync(plansDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md"));
+    if (mdFiles.length === 0) return null;
+    let latest = { file: mdFiles[0], mtime: 0 };
+    for (const f of mdFiles) {
+      const stat = statSync(join4(plansDir, f));
+      if (stat.mtimeMs > latest.mtime) {
+        latest = { file: f, mtime: stat.mtimeMs };
+      }
+    }
+    const content = readFileSync(join4(plansDir, latest.file), "utf-8");
+    if (content.trim()) {
+      console.error(`[ulpi] Reading plan from ${plansDir}/${latest.file}`);
+      return content;
+    }
+  } catch {
+  }
+  return null;
+}
+function extractPlanFromTranscript(transcriptPath) {
+  try {
+    const transcriptText = readFileSync(transcriptPath, "utf-8");
+    const lines = transcriptText.trim().split("\n").reverse();
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.role === "assistant" && typeof entry.content === "string") {
+          if (looksLikePlan(entry.content)) return entry.content;
+        }
+        if (Array.isArray(entry.content)) {
+          for (const block of entry.content) {
+            if (block.type === "text" && typeof block.text === "string") {
+              if (looksLikePlan(block.text)) return block.text;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function looksLikePlan(content) {
+  return content.includes("#") && content.length > 100;
+}
+function buildRichFeedback(decision, sections) {
+  const sectionTitleMap = /* @__PURE__ */ new Map();
+  for (const s of sections) {
+    sectionTitleMap.set(s.id, s.title);
+  }
+  const resolveSectionTitle = (sectionId) => {
+    if (!sectionId || sectionId === "global" || sectionId === "__global__") return "Global";
+    const byId = sectionTitleMap.get(sectionId);
+    if (byId) return byId;
+    const slugMatch = sections.find(
+      (s) => s.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") === sectionId
+    );
+    if (slugMatch) return slugMatch.title;
+    return sectionId;
+  };
+  const header = decision.behavior === "deny" ? "PLAN REVIEW FEEDBACK \u2014 Changes Requested" : "PLAN REVIEW FEEDBACK \u2014 Approved with Notes";
+  const parts = [header, ""];
+  const annotations = decision.annotations || [];
+  if (annotations.length > 0) {
+    parts.push("## Annotations");
+    const grouped = /* @__PURE__ */ new Map();
+    for (const ann of annotations) {
+      const key = ann.sectionId || "__global__";
+      const group = grouped.get(key);
+      if (group) {
+        group.push(ann);
+      } else {
+        grouped.set(key, [ann]);
+      }
+    }
+    for (const [key, anns] of grouped) {
+      for (const ann of anns) {
+        const sectionLabel = key === "__global__" ? "Global" : `Section: "${resolveSectionTitle(ann.sectionId)}"`;
+        const typeLabel = ann.type.toUpperCase().replace("_", " ");
+        parts.push(`### ${sectionLabel} (${typeLabel})`);
+        parts.push(ann.text);
+        if (ann.imagePaths && ann.imagePaths.length > 0) {
+          for (const imgPath of ann.imagePaths) {
+            parts.push(`  - Attached image: ${imgPath}`);
+          }
+        }
+        parts.push("");
+      }
+    }
+  }
+  const priorities = decision.priorities || [];
+  if (priorities.length > 0) {
+    parts.push("## Priorities");
+    for (const p of priorities) {
+      const title = resolveSectionTitle(p.sectionId);
+      const note = p.note ? ` (${p.note})` : "";
+      parts.push(`- "${title}" \u2192 ${p.priority.toUpperCase()}${note}`);
+    }
+    parts.push("");
+  }
+  const risks = decision.risks || [];
+  if (risks.length > 0) {
+    parts.push("## Risks");
+    for (const r of risks) {
+      const title = resolveSectionTitle(r.sectionId);
+      parts.push(`- "${title}" \u2192 ${r.level.toUpperCase()}: ${r.description}`);
+    }
+    parts.push("");
+  }
+  const instructions = decision.instructions || [];
+  if (instructions.length > 0) {
+    parts.push("## Instructions");
+    for (const inst of instructions) {
+      const title = resolveSectionTitle(inst.sectionId);
+      const priorityTag = inst.priority ? ` [${inst.priority.toUpperCase()}]` : "";
+      parts.push(`- "${title}": ${inst.instruction}${priorityTag}`);
+    }
+    parts.push("");
+  }
+  const inlineEdits = decision.inlineEdits || [];
+  if (inlineEdits.length > 0) {
+    parts.push("## Inline Edits");
+    for (const edit of inlineEdits) {
+      const title = resolveSectionTitle(edit.sectionId);
+      parts.push(`- Section "${title}": Reviewer edited the implementation approach`);
+      parts.push(`  Original: "${truncate(edit.originalContent, 120)}"`);
+      parts.push(`  Changed to: "${truncate(edit.editedContent, 120)}"`);
+    }
+    parts.push("");
+  }
+  const message = decision.message || decision.feedback;
+  if (message) {
+    parts.push("## Reviewer Message");
+    parts.push(message);
+    parts.push("");
+  }
+  if (decision.behavior === "deny") {
+    parts.push("ADDRESS ALL FEEDBACK BEFORE RE-SUBMITTING THE PLAN.");
+  }
+  return parts.join("\n");
+}
+function truncate(text, maxLen) {
+  const singleLine = text.replace(/\n/g, " ").trim();
+  if (singleLine.length <= maxLen) return singleLine;
+  return singleLine.slice(0, maxLen - 3) + "...";
+}
+async function runPlanReviewSession(plan, projectDir2, sessionId) {
+  try {
+    const discovered = await discoverUlpiServer();
+    if (!discovered) {
+      const settings2 = getReviewSettings();
+      if (settings2.require_server) {
+        console.error("[ulpi] No ULPI server running \u2014 blocking plan exit (require_server=true). Start the server with: ulpi ui");
+        return { behavior: "deny", message: "Review server is required but not running. Start it with: ulpi ui" };
+      }
+      console.error("[ulpi] No ULPI server running \u2014 skipping plan review");
+      return { behavior: "allow" };
+    }
+    const { port, secret: apiSecret } = discovered;
+    appendEvent(sessionId, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "review_plan_started",
+      hookEvent: "PermissionRequest",
+      toolName: "ExitPlanMode",
+      message: "Plan review session started"
+    }, projectDir2);
+    const registration = await registerWithServer(port, {
+      type: "plan",
+      plan,
+      projectPath: projectDir2
+    }, apiSecret);
+    if (!registration) {
+      console.error("[ulpi] Failed to register plan review session");
+      return { behavior: "allow" };
+    }
+    console.error(`[ulpi] Plan review session: ${registration.sessionId}`);
+    const apiHost = getApiHost();
+    const planTokenParam = registration.token ? `&token=${encodeURIComponent(registration.token)}` : "";
+    console.error(`[ulpi] Waiting for review decision at http://${apiHost}:${port}/review/plan?session=${registration.sessionId}${planTokenParam}`);
+    const settings = getReviewSettings();
+    const maxWaitMs = settings.review_timeout_seconds > 0 ? settings.review_timeout_seconds * 1e3 : void 0;
+    const decision = await waitForServerDecision(port, registration.sessionId, 3e4, maxWaitMs, registration.token, apiSecret);
+    if (!decision) {
+      const behavior = settings.timeout_behavior ?? "allow";
+      console.error(`[ulpi] Plan review timed out \u2014 ${behavior}`);
+      return { behavior };
+    }
+    const planDecision = decision;
+    appendEvent(sessionId, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "review_plan_decided",
+      hookEvent: "PermissionRequest",
+      toolName: "ExitPlanMode",
+      message: `Plan review: ${planDecision.behavior}`
+    }, projectDir2);
+    const hasReviewData = (planDecision.annotations?.length ?? 0) > 0 || (planDecision.priorities?.length ?? 0) > 0 || (planDecision.risks?.length ?? 0) > 0 || (planDecision.instructions?.length ?? 0) > 0 || (planDecision.inlineEdits?.length ?? 0) > 0;
+    let feedback;
+    if (hasReviewData) {
+      const blocks = parseMarkdownToBlocks(plan);
+      const planSections = extractSections(blocks);
+      feedback = buildRichFeedback(planDecision, planSections);
+    } else {
+      feedback = planDecision.feedback || planDecision.message || "";
+    }
+    return {
+      behavior: planDecision.behavior,
+      message: planDecision.message,
+      feedback,
+      clearContext: planDecision.clearContext
+    };
+  } catch (err) {
+    console.error(`[ulpi] Plan review error: ${err instanceof Error ? err.message : err}`);
+    return { behavior: "allow" };
+  }
+}
+async function runCodeReviewSession(diff, commitMessage, projectDir2, sessionId) {
+  try {
+    const discovered = await discoverUlpiServer();
+    if (!discovered) {
+      const settings2 = getReviewSettings();
+      if (settings2.require_server) {
+        console.error("[ulpi] No ULPI server running \u2014 blocking commit (require_server=true). Start the server with: ulpi ui");
+        return { approved: false, message: "Review server is required but not running. Start it with: ulpi ui" };
+      }
+      console.error("[ulpi] No ULPI server running \u2014 skipping code review");
+      return { approved: true };
+    }
+    const { port, secret: apiSecret } = discovered;
+    appendEvent(sessionId, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "review_code_started",
+      hookEvent: "PreToolUse",
+      toolName: "Bash",
+      command: "git commit",
+      message: "Code review session started"
+    }, projectDir2);
+    const registration = await registerWithServer(port, {
+      type: "code",
+      diff,
+      commitMessage,
+      projectPath: projectDir2
+    }, apiSecret);
+    if (!registration) {
+      console.error("[ulpi] Failed to register code review session");
+      return { approved: true };
+    }
+    console.error(`[ulpi] Code review session: ${registration.sessionId}`);
+    const codeApiHost = getApiHost();
+    const codeTokenParam = registration.token ? `&token=${encodeURIComponent(registration.token)}` : "";
+    console.error(`[ulpi] Waiting for review decision at http://${codeApiHost}:${port}/review/code?session=${registration.sessionId}${codeTokenParam}`);
+    const settings = getReviewSettings();
+    const maxWaitMs = settings.review_timeout_seconds > 0 ? settings.review_timeout_seconds * 1e3 : void 0;
+    const decision = await waitForServerDecision(port, registration.sessionId, 3e4, maxWaitMs, registration.token, apiSecret);
+    if (!decision) {
+      const behavior = settings.timeout_behavior ?? "allow";
+      console.error(`[ulpi] Code review timed out \u2014 ${behavior}`);
+      return { approved: behavior === "allow" };
+    }
+    const codeDecision = decision;
+    appendEvent(sessionId, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "review_code_decided",
+      hookEvent: "PreToolUse",
+      toolName: "Bash",
+      command: "git commit",
+      message: `Code review: ${codeDecision.approved ? "approved" : "changes requested"}`
+    }, projectDir2);
+    return {
+      approved: codeDecision.approved,
+      feedback: codeDecision.feedback,
+      message: codeDecision.message
+    };
+  } catch (err) {
+    console.error(`[ulpi] Code review error: ${err instanceof Error ? err.message : err}`);
+    return { approved: true };
+  }
+}
+function writeClearContextFlag(sessionId) {
+  ensureFlagsDir(sessionId);
+  writeFileSync2(join4(flagsDir(sessionId), "clear-context.flag"), JSON.stringify({ timestamp: Date.now() }));
+}
+function readClearContextFlag(sessionId) {
+  try {
+    const path5 = join4(flagsDir(sessionId), "clear-context.flag");
+    if (!existsSync2(path5)) return false;
+    const data = JSON.parse(readFileSync(path5, "utf8"));
+    unlinkSync2(path5);
+    const age = Date.now() - (data.timestamp || 0);
+    return age < 5 * 60 * 1e3;
+  } catch {
+    return false;
+  }
+}
+function writeReviewFeedbackFlag(feedback, sessionId) {
+  ensureFlagsDir(sessionId);
+  writeFileSync2(join4(flagsDir(sessionId), "review-feedback.flag"), JSON.stringify({ timestamp: Date.now(), feedback }));
+}
+function readReviewFeedbackFlag(sessionId) {
+  try {
+    const path5 = join4(flagsDir(sessionId), "review-feedback.flag");
+    if (!existsSync2(path5)) return null;
+    const data = JSON.parse(readFileSync(path5, "utf8"));
+    unlinkSync2(path5);
+    const age = Date.now() - (data.timestamp || 0);
+    if (age >= 5 * 60 * 1e3) return null;
+    return data.feedback || null;
+  } catch {
+    return null;
+  }
+}
+function writeTeamDelegationFlag(planTitle, sections, sessionId) {
+  ensureFlagsDir(sessionId);
+  const flag = { timestamp: Date.now(), planTitle, sections };
+  writeFileSync2(join4(flagsDir(sessionId), "team-delegation.flag"), JSON.stringify(flag));
+}
+function readTeamDelegationFlag(sessionId) {
+  try {
+    const path5 = join4(flagsDir(sessionId), "team-delegation.flag");
+    if (!existsSync2(path5)) return null;
+    const data = JSON.parse(readFileSync(path5, "utf8"));
+    unlinkSync2(path5);
+    const age = Date.now() - (data.timestamp || 0);
+    if (age >= 5 * 60 * 1e3) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+var AGENT_TYPE_KEYWORDS = [
+  { keywords: ["express", "node", "api", "endpoint", "middleware", "route", "server", "rest", "graphql"], agentType: "express-senior-engineer" },
+  { keywords: ["react", "component", "tailwind", "css", "ui", "frontend", "vite", "styled", "jsx", "tsx"], agentType: "react-vite-tailwind-engineer" },
+  { keywords: ["next.js", "nextjs", "app router", "rsc", "server component", "next"], agentType: "nextjs-senior-engineer" },
+  { keywords: ["laravel", "php", "eloquent", "artisan", "blade", "migration"], agentType: "laravel-senior-engineer" },
+  { keywords: ["docker", "container", "compose", "dockerfile", "kubernetes", "k8s"], agentType: "devops-docker-senior-engineer" },
+  { keywords: ["aws", "cdk", "cloudformation", "terraform", "lambda", "s3", "ec2", "iam"], agentType: "devops-aws-senior-engineer" },
+  { keywords: ["cli", "command", "terminal", "script", "commander", "inquirer", "chalk"], agentType: "nodejs-cli-senior-engineer" }
+];
+function inferAgentType(title, content) {
+  const text = `${title} ${content}`.toLowerCase();
+  let bestMatch = "general-purpose";
+  let bestScore = 0;
+  for (const entry of AGENT_TYPE_KEYWORDS) {
+    let score = 0;
+    for (const keyword of entry.keywords) {
+      if (text.includes(keyword)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = entry.agentType;
+    }
+  }
+  return bestMatch;
+}
+function buildDelegationSections(sections, blocks) {
+  return sections.filter((s) => s.level >= 2 && s.title !== "Overview").map((section) => {
+    const content = getSectionFullText(section, blocks);
+    return {
+      title: section.title,
+      agentType: inferAgentType(section.title, content)
+    };
+  });
+}
+function buildDelegationContext(delegation) {
+  const sectionLines = delegation.sections.map((s) => `- "${s.title}" \u2192 ${s.agentType}`).join("\n");
+  return `TEAM DELEGATION INSTRUCTIONS:
+
+The plan "${delegation.planTitle}" has been approved. You MUST now create a team of specialized agents to execute this plan in parallel using the Task tool.
+
+As the team lead, you should:
+1. Analyze each plan section and confirm the recommended agent type (or adjust based on your understanding)
+2. Launch parallel Task agents for independent sections in a SINGLE message with multiple Task tool calls
+3. Use sequential execution only where sections have explicit dependencies
+4. Coordinate results after agents complete and verify integration
+
+Recommended agent allocation:
+${sectionLines}
+
+IMPORTANT: Launch independent agents in PARALLEL (single message, multiple Task tool calls) for maximum efficiency.`;
+}
+function collectPostReviewContexts(sessionId) {
+  const contexts = [];
+  if (readClearContextFlag(sessionId)) {
+    contexts.push(
+      "IMPORTANT: The plan reviewer approved this plan with a request to clear context before implementation. You MUST immediately run /compact before implementing. Do not ask the user \u2014 just do it now. After compaction completes, proceed with the approved plan."
+    );
+  }
+  const reviewFeedback = readReviewFeedbackFlag(sessionId);
+  if (reviewFeedback) {
+    contexts.push(reviewFeedback);
+  }
+  const delegation = readTeamDelegationFlag(sessionId);
+  if (delegation) {
+    contexts.push(buildDelegationContext(delegation));
+  }
+  return contexts;
+}
+
+// src/hooks/pre-tool.ts
+async function handlePreTool(ctx) {
+  const { input, state, rules, projectDir: projectDir2, store } = ctx;
+  const result = evaluateRules(input, rules, state, projectDir2);
+  for (const { rule, outcome } of result.matchedRules) {
+    appendEvent(input.session_id, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: outcome === "fail" ? "tool_blocked" : "tool_allowed",
+      hookEvent: input.hook_event_name,
+      toolName: input.tool_name,
+      filePath: input.tool_input?.file_path,
+      command: input.tool_input?.command,
+      ruleName: rule.id,
+      message: outcome === "fail" ? result.stderrMessage : void 0
+    }, projectDir2);
+  }
+  if (result.matchedRules.length > 0) {
+    state.rulesEnforced += result.matchedRules.length;
+  }
+  const isBlock = result.action === "block" || result.action === "feedback";
+  const failedRule = result.matchedRules.find((m) => m.outcome === "fail");
+  try {
+    const triggers = evaluateNotificationTriggers(state, {
+      type: isBlock ? "tool_blocked" : "tool_allowed",
+      toolName: input.tool_name,
+      filePath: input.tool_input?.file_path,
+      ruleName: failedRule?.rule?.id,
+      message: result.stderrMessage
+    }, rules.responses);
+    const notifyResult = await fireWithActions(triggers, rules.responses, {
+      sessionId: input.session_id,
+      state,
+      projectDir: projectDir2,
+      stderrMessage: result.stderrMessage,
+      latestEvent: {
+        toolName: input.tool_name,
+        toolInput: input.tool_input,
+        filePath: input.tool_input?.file_path,
+        ruleName: failedRule?.rule?.id,
+        message: result.stderrMessage
+      }
+    });
+    if (notifyResult.stderrMessage && notifyResult.stderrMessage !== result.stderrMessage) {
+      result.stderrMessage = notifyResult.stderrMessage;
+    }
+    for (const trigger of triggers) {
+      appendEvent(input.session_id, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        event: "notification_routed",
+        hookEvent: input.hook_event_name,
+        message: `Notification: ${trigger.eventType} -- ${trigger.message}`
+      }, projectDir2);
+    }
+  } catch {
+  }
+  if (isBlock) {
+    state.actionsBlocked++;
+    state.consecutiveBlocks++;
+    let message = result.stderrMessage ?? "Action blocked by rule";
+    if (failedRule?.rule.skill) {
+      message = injectSkill(message, failedRule.rule.skill, projectDir2);
+    }
+    store.save(state);
+    if (result.stdoutJson) {
+      process.stdout.write(JSON.stringify(result.stdoutJson));
+    }
+    process.stderr.write(message);
+    return 2;
+  }
+  if (input.tool_name === "Bash" && isGitCommitCommand(input.tool_input?.command) && isReviewEnabled("code")) {
+    try {
+      const command2 = input.tool_input?.command;
+      const { diff, commitMessage, allowEmpty } = captureCommitDiff({ command: command2, cwd: projectDir2 });
+      if (allowEmpty && !diff.trim()) {
+        console.error("[ulpi] Skipping code review: --allow-empty commit with no changes.");
+      } else if (diff.trim()) {
+        const reviewResult = await runCodeReviewSession(
+          diff,
+          commitMessage,
+          projectDir2,
+          input.session_id
+        );
+        if (!reviewResult.approved) {
+          state.actionsBlocked++;
+          state.consecutiveBlocks++;
+          const message = reviewResult.feedback || reviewResult.message || "Code review: changes requested.";
+          store.save(state);
+          process.stderr.write(message);
+          return 2;
+        }
+      }
+    } catch (err) {
+      console.error(`[ulpi] Code review error: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  state.consecutiveBlocks = 0;
+  if (result.stdoutJson) {
+    process.stdout.write(JSON.stringify(result.stdoutJson));
+  }
+  store.save(state);
+  return 0;
+}
+
+// src/hooks/post-tool.ts
+import * as child_process from "child_process";
+async function handlePostTool(ctx) {
+  const { input, state, rules, projectDir: projectDir2, store } = ctx;
+  const nextState = updateStateFromInput(state, input);
+  Object.assign(state, nextState);
+  if ((state.phase === "active" || state.phase === "active_committed") && state.headAtStart && historyBranchExists(projectDir2)) {
+    const meta = readBranchMeta(projectDir2);
+    if (meta?.config?.captureStrategy === "on-commit") {
+      const currentHead = getCurrentHead(projectDir2);
+      if (currentHead && currentHead !== state.headAtStart) {
+        state.phase = "active_committed";
+        captureOnCommit(projectDir2, state, input, currentHead).catch(() => {
+        });
+        state.headAtStart = currentHead;
+      }
+    }
+  }
+  try {
+    const contexts = collectPostReviewContexts(input.session_id);
+    if (contexts.length > 0) {
+      const contextJson = {
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: contexts.join("\n\n---\n\n")
+        }
+      };
+      process.stdout.write(JSON.stringify(contextJson));
+    }
+  } catch {
+  }
+  const result = evaluateRules(input, rules, state, projectDir2);
+  const postconditions = result.postconditionResults ?? [];
+  let hadFailure = false;
+  let blockingFailure = false;
+  let failedCommand = "";
+  let failedMessage = "";
+  if (postconditions.length > 0) {
+    const failureFeedback = [];
+    for (const { rule, command: cmd } of postconditions) {
+      try {
+        child_process.execSync(cmd, {
+          cwd: projectDir2,
+          encoding: "utf-8",
+          timeout: rule.timeout ?? 3e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        state.autoActionsRun++;
+        appendEvent(input.session_id, {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          event: "postcondition_run",
+          hookEvent: input.hook_event_name,
+          toolName: input.tool_name,
+          command: cmd,
+          message: "Postcondition succeeded"
+        }, projectDir2);
+      } catch (err) {
+        const error = err;
+        const errMsg = error.stderr || error.message || "Unknown error";
+        hadFailure = true;
+        failedCommand = cmd;
+        failedMessage = errMsg;
+        appendEvent(input.session_id, {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          event: "postcondition_failed",
+          hookEvent: input.hook_event_name,
+          toolName: input.tool_name,
+          command: cmd,
+          message: errMsg
+        }, projectDir2);
+        failureFeedback.push(`\u2717 ${cmd}
+${errMsg}`);
+        if (rule.block_on_failure) {
+          blockingFailure = true;
+          break;
+        }
+      }
+    }
+    try {
+      const triggers = evaluateNotificationTriggers(state, {
+        type: hadFailure ? "postcondition_failed" : "postcondition_run",
+        toolName: input.tool_name,
+        command: failedCommand || void 0,
+        message: failedMessage || void 0
+      }, rules.responses);
+      await fireWithActions(triggers, rules.responses, {
+        sessionId: input.session_id,
+        state,
+        projectDir: projectDir2,
+        latestEvent: {
+          toolName: input.tool_name,
+          command: failedCommand || void 0,
+          message: failedMessage || void 0
+        }
+      });
+      for (const trigger of triggers) {
+        appendEvent(input.session_id, {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          event: "notification_routed",
+          hookEvent: input.hook_event_name,
+          message: `Notification: ${trigger.eventType} -- ${trigger.message}`
+        }, projectDir2);
+      }
+    } catch {
+    }
+    if (blockingFailure && failureFeedback.length > 0) {
+      store.save(state);
+      process.stderr.write(
+        `[ulpi] Postconditions:
+${failureFeedback.join("\n\n")}`
+      );
+      return 2;
+    }
+  }
+  try {
+    const { isMemoryEnabled, loadMemoryConfig, appendMemoryEvent, toClassificationEvent } = await import("./dist-R5F4MX3I.js");
+    if (isMemoryEnabled(projectDir2)) {
+      const memConfig = loadMemoryConfig(projectDir2);
+      if (memConfig.captureMode === "continuous") {
+        const classEvent = toClassificationEvent({
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          event: hadFailure ? "postcondition_failed" : "tool_used",
+          hookEvent: input.hook_event_name,
+          toolName: input.tool_name,
+          filePath: input.tool_input?.file_path,
+          command: input.tool_input?.command,
+          message: void 0
+        });
+        appendMemoryEvent(input.session_id, classEvent, projectDir2);
+      }
+    }
+  } catch {
+  }
+  if (input.tool_name === "Bash" && /\bgit\s+push\b/.test(String(input.tool_input?.command ?? ""))) {
+    try {
+      const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-LZKZFPVX.js");
+      const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+      const codemapConfig = loadCodemapConfig(projectDir2);
+      if (codemapConfig.autoExport) {
+        const branch = state.branch ?? getCurrentBranch(projectDir2);
+        const codemapStatus = getCodemapStatus(projectDir2, branch);
+        if (codemapStatus.initialized) {
+          exportIndex(projectDir2, branch).catch(() => {
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  store.save(state);
+  return 0;
+}
+async function captureOnCommit(projectDir2, state, input, sha) {
+  if (entryExists(projectDir2, sha)) return;
+  const commit = getCommitMetadata(projectDir2, sha);
+  const diff = getCommitDiffStats(projectDir2, sha);
+  const { diff: rawDiff, truncated } = getCommitRawDiff(projectDir2, sha);
+  const events = readEvents(input.session_id, projectDir2);
+  const sessionSummary = buildSessionSummary(state, events);
+  const guardsYaml = loadActiveGuards(projectDir2);
+  const entry = {
+    version: 1,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    commit,
+    diff,
+    rawDiff: rawDiff || void 0,
+    diffTruncated: truncated || void 0,
+    session: sessionSummary,
+    enrichment: null,
+    reviewPlans: null,
+    prePromptSnapshot: buildPrePromptSnapshot(state)
+  };
+  await writeHistoryEntry(projectDir2, entry, {
+    state,
+    events,
+    guardsYaml
+  });
+}
+
+// src/hooks/permission.ts
+async function handlePermission(ctx) {
+  const { input, state, rules, projectDir: projectDir2, store } = ctx;
+  const result = evaluateRules(input, rules, state, projectDir2);
+  const hookDecision = result.stdoutJson?.hookSpecificOutput?.decision?.behavior ?? result.stdoutJson?.hookSpecificOutput?.permissionDecision;
+  if (hookDecision) {
+    const decision = hookDecision;
+    const reason = result.stdoutJson?.hookSpecificOutput?.decision?.message ?? result.stdoutJson?.hookSpecificOutput?.permissionDecisionReason;
+    appendEvent(input.session_id, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: decision === "allow" ? "permission_allow" : "permission_deny",
+      hookEvent: input.hook_event_name,
+      toolName: input.tool_name,
+      filePath: input.tool_input?.file_path,
+      command: input.tool_input?.command,
+      message: reason
+    }, projectDir2);
+    if (decision === "deny") {
+      state.actionsBlocked++;
+    }
+    try {
+      const recentEvents = readEvents(input.session_id, projectDir2);
+      const triggers = evaluateNotificationTriggers(state, {
+        type: decision === "allow" ? "permission_allow" : "permission_deny",
+        toolName: input.tool_name
+      }, rules.responses, recentEvents);
+      const notifyResult = await fireWithActions(triggers, rules.responses, {
+        sessionId: input.session_id,
+        state,
+        projectDir: projectDir2,
+        stderrMessage: reason,
+        latestEvent: {
+          toolName: input.tool_name,
+          toolInput: input.tool_input,
+          filePath: input.tool_input?.file_path,
+          command: input.tool_input?.command
+        }
+      });
+      if (decision === "deny" && notifyResult.stderrMessage && notifyResult.stderrMessage !== reason) {
+        if (result.stderrMessage) {
+          result.stderrMessage = notifyResult.stderrMessage;
+        }
+      }
+      for (const trigger of triggers) {
+        appendEvent(input.session_id, {
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          event: "notification_routed",
+          hookEvent: input.hook_event_name,
+          message: `Notification: ${trigger.eventType} -- ${trigger.message}`
+        }, projectDir2);
+      }
+    } catch {
+    }
+    store.save(state);
+    process.stdout.write(JSON.stringify(result.stdoutJson));
+    if (result.stderrMessage) {
+      process.stderr.write(result.stderrMessage);
+    }
+    return 2;
+  }
+  if (input.tool_name === "ExitPlanMode" && isReviewEnabled("plan")) {
+    console.error(`[ulpi] ExitPlanMode intercepted \u2014 extracting plan (cwd: ${input.cwd})`);
+    try {
+      const plan = await extractPlanForReview(input);
+      console.error(`[ulpi] Plan extraction result: ${plan ? `${plan.length} chars` : "null"}`);
+      if (plan) {
+        const result2 = await runPlanReviewSession(plan, projectDir2, input.session_id);
+        if (result2.behavior === "allow") {
+          state.planApproved = true;
+          if (result2.clearContext) {
+            writeClearContextFlag(input.session_id);
+          }
+          if (result2.feedback) {
+            writeReviewFeedbackFlag(result2.feedback, input.session_id);
+          }
+          try {
+            const blocks = parseMarkdownToBlocks(plan);
+            const sections = extractSections(blocks);
+            const title = extractTitle(blocks);
+            const delegationSections = buildDelegationSections(sections, blocks);
+            if (delegationSections.length > 0) {
+              writeTeamDelegationFlag(title, delegationSections, input.session_id);
+            }
+          } catch {
+          }
+          const allowJson = {
+            hookSpecificOutput: {
+              hookEventName: "PermissionRequest",
+              decision: { behavior: "allow" }
+            }
+          };
+          store.save(state);
+          process.stdout.write(JSON.stringify(allowJson));
+          return 2;
+        } else {
+          const feedbackText = result2.feedback || result2.message || "Plan review: changes requested";
+          writeReviewFeedbackFlag(feedbackText, input.session_id);
+          const denyJson = {
+            hookSpecificOutput: {
+              hookEventName: "PermissionRequest",
+              decision: { behavior: "deny", message: feedbackText }
+            }
+          };
+          state.actionsBlocked++;
+          store.save(state);
+          process.stdout.write(JSON.stringify(denyJson));
+          process.stderr.write(feedbackText);
+          return 2;
+        }
+      }
+    } catch (err) {
+      console.error(`[ulpi] Plan review error: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  return 0;
+}
+
+// src/hooks/notification.ts
+async function handleNotification(ctx) {
+  const { input, state, rules, store, projectDir: projectDir2 } = ctx;
+  try {
+    const result = await routeNotification(input, rules.responses);
+    const actionCtx = {
+      eventType: result.classified,
+      state,
+      projectDir: projectDir2
+    };
+    const actionResult = executeActions(result.actConfig, actionCtx);
+    if (actionResult.stderrMessage) {
+      process.stderr.write(actionResult.stderrMessage);
+    }
+    const channelsInfo = result.channels.length > 0 ? ` via ${result.channels.join(", ")}` : "";
+    const suppressedInfo = result.suppressed ? " (suppressed by dedup)" : "";
+    const actionsInfo = result.actions.length > 0 ? ` | actions: ${result.actions.join(", ")}` : "";
+    appendEvent(input.session_id, {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: "notification_routed",
+      hookEvent: input.hook_event_name,
+      message: `Notification "${result.classified}"${channelsInfo}${suppressedInfo}${actionsInfo}`
+    }, projectDir2);
+    const auditEntry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: input.session_id,
+      eventType: result.classified,
+      title: input.title ?? "ULPI",
+      message: input.message ?? result.classified,
+      channels: result.channels,
+      actions: result.actions,
+      suppressed: result.suppressed || actionResult.rateLimitSuppressed,
+      suppressReason: result.suppressed ? "dedup" : actionResult.rateLimitSuppressed ? "rate_limit" : void 0
+    };
+    auditNotification(auditEntry, projectDir2);
+    state.lastNotifications[result.classified] = Date.now();
+  } catch {
+  }
+  store.save(state);
+}
+
+// src/hooks/stop.ts
+async function handleStop(ctx) {
+  const { input, state, rules, store, projectDir: projectDir2 } = ctx;
+  const warnings = [];
+  if (state.filesWritten.length > 0 && !state.testsRun) {
+    warnings.push("Tests were not run during this session.");
+  }
+  if (state.filesWritten.length > 0 && !state.lintRun) {
+    warnings.push("Linting was not run during this session.");
+  }
+  try {
+    const triggers = evaluateNotificationTriggers(state, {
+      type: "stop_requested",
+      message: `Stop requested. Files written: ${state.filesWritten.length}`
+    }, rules.responses);
+    const notifyResult = await fireWithActions(triggers, rules.responses, {
+      sessionId: input.session_id,
+      state,
+      projectDir: projectDir2,
+      stderrMessage: warnings.length > 0 ? warnings.join("\n") : void 0
+    });
+    if (notifyResult.stderrMessage && warnings.length > 0) {
+      warnings.push(notifyResult.stderrMessage);
+    }
+    for (const trigger of triggers) {
+      appendEvent(input.session_id, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        event: "notification_routed",
+        hookEvent: input.hook_event_name,
+        message: `Notification: ${trigger.eventType} -- ${trigger.message}`
+      }, projectDir2);
+    }
+  } catch {
+  }
+  appendEvent(input.session_id, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "stop_requested",
+    hookEvent: input.hook_event_name,
+    message: `Stop requested. Files written: ${state.filesWritten.length}, Commands run: ${state.commandsRun.length}`
+  }, projectDir2);
+  store.save(state);
+  if (warnings.length > 0 && input.stop_hook_active) {
+    process.stderr.write(
+      `[ulpi] Session warnings:
+${warnings.map((w) => `  - ${w}`).join("\n")}`
+    );
+    return 2;
+  }
+  return 0;
+}
+
+// src/hooks/session-end.ts
+async function captureSessionCommits(ctx) {
+  const { input, state, projectDir: projectDir2 } = ctx;
+  if (!state.headAtStart) return;
+  if (!historyBranchExists(projectDir2)) return;
+  const currentHead = getCurrentHead(projectDir2);
+  if (!currentHead || currentHead === state.headAtStart) return;
+  const newShas = listCommitsBetween(projectDir2, state.headAtStart, currentHead);
+  if (newShas.length === 0) return;
+  const events = readEvents(input.session_id, projectDir2);
+  const sessionSummary = buildSessionSummary(state, events);
+  const guardsYaml = loadActiveGuards(projectDir2);
+  let transcriptContent = null;
+  const meta = readBranchMeta(projectDir2);
+  if (meta?.config?.captureTranscript !== false && input.transcript_path) {
+    const maxSize = meta?.config?.maxTranscriptSize ?? 5242880;
+    const result = readTranscript(input.transcript_path, maxSize);
+    if (result) {
+      transcriptContent = result.content;
+    }
+  }
+  const collectReviewPlans = meta?.config?.collectReviewPlans ?? false;
+  for (const sha of newShas) {
+    try {
+      if (entryExists(projectDir2, sha)) {
+        if (transcriptContent && !readEntryTranscript(projectDir2, sha)) {
+          await updateEntryTranscript(projectDir2, sha, transcriptContent);
+        }
+        continue;
+      }
+      const commit = getCommitMetadata(projectDir2, sha);
+      const diff = getCommitDiffStats(projectDir2, sha);
+      const { diff: rawDiff, truncated } = getCommitRawDiff(projectDir2, sha);
+      let reviewPlanData = null;
+      if (collectReviewPlans) {
+        reviewPlanData = findReviewPlansForCommit(
+          commit.authorDate,
+          state.startedAt,
+          projectDir2
+        );
+      }
+      const entry = {
+        version: 1,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        commit,
+        diff,
+        rawDiff: rawDiff || void 0,
+        diffTruncated: truncated || void 0,
+        session: sessionSummary,
+        enrichment: null,
+        reviewPlans: reviewPlanData?.snapshots ?? null,
+        prePromptSnapshot: buildPrePromptSnapshot(state)
+      };
+      await writeHistoryEntry(projectDir2, entry, {
+        state,
+        events,
+        guardsYaml,
+        reviewPlans: reviewPlanData?.rawData,
+        transcript: transcriptContent
+      });
+    } catch {
+      continue;
+    }
+  }
+}
+async function handleSessionEnd(ctx) {
+  const { input, state, store, projectDir: projectDir2 } = ctx;
+  state.phase = "ended";
+  appendEvent(input.session_id, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    event: "session_end",
+    hookEvent: input.hook_event_name,
+    message: [
+      `Session ended.`,
+      `Files read: ${state.filesRead.length}`,
+      `Files written: ${state.filesWritten.length}`,
+      `Commands run: ${state.commandsRun.length}`,
+      `Rules enforced: ${state.rulesEnforced}`,
+      `Actions blocked: ${state.actionsBlocked}`,
+      `Auto-actions run: ${state.autoActionsRun}`
+    ].join(", ")
+  }, projectDir2);
+  store.save(state);
+  try {
+    await captureSessionCommits(ctx);
+  } catch {
+  }
+  try {
+    const memEngine = await import("./dist-R5F4MX3I.js");
+    if (memEngine.isMemoryEnabled(projectDir2)) {
+      const config = memEngine.loadMemoryConfig(projectDir2);
+      memEngine.finalizeCapture(input.session_id, state, projectDir2);
+      if (config.classifier.enabled) {
+        await memEngine.classifySession(projectDir2, input.session_id);
+      }
+      if (config.autoExport) {
+        try {
+          memEngine.exportMemories(projectDir2);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-LZKZFPVX.js");
+    const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+    const codemapConfig = loadCodemapConfig(projectDir2);
+    if (codemapConfig.autoExport) {
+      const branch = state.branch ?? getCurrentBranch(projectDir2);
+      const codemapStatus = getCodemapStatus(projectDir2, branch);
+      if (codemapStatus.initialized && state.filesWritten.length > 0) {
+        await exportIndex(projectDir2, branch);
+      }
+    }
+  } catch {
+  }
+}
+
+// src/hooks/handler.ts
+function readStdinSync() {
+  const raw = fs3.readFileSync(0, "utf-8");
+  return JSON.parse(raw);
+}
+function findRulesPath(projectDir2) {
+  const projectRules = projectGuardsFile(projectDir2);
+  if (fs3.existsSync(projectRules)) return projectRules;
+  const projectRulesYaml = projectGuardsFileAlt(projectDir2);
+  if (fs3.existsSync(projectRulesYaml)) return projectRulesYaml;
+  const userRules = globalGuardsFile();
+  if (fs3.existsSync(userRules)) return userRules;
+  return null;
+}
+function loadRules(projectDir2) {
+  const rulesPath = findRulesPath(projectDir2);
+  if (rulesPath) {
+    const result = loadRulesSync(rulesPath);
+    if (result) return result;
+  }
+  return {
+    project: {
+      name: path3.basename(projectDir2),
+      runtime: "unknown",
+      package_manager: "npm"
+    },
+    preconditions: {},
+    postconditions: {},
+    permissions: {},
+    pipelines: {}
+  };
+}
+function validateInput(input) {
+  if (!input || typeof input !== "object") {
+    throw new Error("Invalid hook input");
+  }
+  if (!input.session_id || typeof input.session_id !== "string") {
+    throw new Error("Missing or invalid session_id");
+  }
+  if (input.session_id.length > 200) {
+    throw new Error("session_id too long");
+  }
+  if (input.session_id.includes("..") || input.session_id.includes("/") || input.session_id.includes("\\")) {
+    throw new Error("Invalid session_id characters");
+  }
+  if (!input.cwd || typeof input.cwd !== "string") {
+    throw new Error("Missing or invalid cwd");
+  }
+  if (!input.hook_event_name || typeof input.hook_event_name !== "string") {
+    throw new Error("Missing or invalid hook_event_name");
+  }
+}
+async function handleHook(hookName) {
+  const input = readStdinSync();
+  validateInput(input);
+  const projectDir2 = input.cwd;
+  const store = new JsonSessionStore(void 0, projectDir2);
+  let state = store.load(input.session_id);
+  if (!state) {
+    state = createInitialState(input.session_id, projectDir2);
+  }
+  if (input.title && input.title !== state.sessionName) {
+    state.sessionName = input.title;
+  }
+  const rules = loadRules(projectDir2);
+  const ctx = {
+    input,
+    state,
+    rules,
+    projectDir: projectDir2,
+    store
+  };
+  if (hookName === "session-start") {
+    try {
+      registerProject(projectDir2, {
+        sessionId: input.session_id
+      });
+    } catch {
+    }
+  }
+  let exitCode = 0;
+  switch (hookName) {
+    case "session-start":
+      await handleSessionStart(ctx);
+      break;
+    case "pre-tool":
+      exitCode = await handlePreTool(ctx);
+      break;
+    case "post-tool":
+      exitCode = await handlePostTool(ctx);
+      break;
+    case "permission":
+      exitCode = await handlePermission(ctx);
+      break;
+    case "notification":
+      await handleNotification(ctx);
+      break;
+    case "stop":
+      exitCode = await handleStop(ctx);
+      break;
+    case "session-end":
+      await handleSessionEnd(ctx);
+      break;
+  }
+  process.exit(exitCode);
+}
+
+// src/index.ts
+var rawArgs = process.argv.slice(2);
+var hookCommands = [
+  "session-start",
+  "pre-tool",
+  "post-tool",
+  "permission",
+  "notification",
+  "stop",
+  "session-end"
+];
+function parseGlobalFlags(args2) {
+  const projectIdx = args2.findIndex((arg) => arg === "--project" || arg === "-p");
+  if (projectIdx !== -1 && args2[projectIdx + 1]) {
+    const projectRef = args2[projectIdx + 1];
+    const entry = getProject(projectRef);
+    if (!entry) {
+      console.error(`Error: Unknown project: ${projectRef}`);
+      console.error("Run 'ulpi projects list' to see registered projects.");
+      process.exit(1);
+    }
+    const remaining = [...args2.slice(0, projectIdx), ...args2.slice(projectIdx + 2)];
+    return { projectDir: entry.path, remainingArgs: remaining };
+  }
+  const cwd = process.cwd();
+  const isProjectDir = fs4.existsSync(path4.join(cwd, ".ulpi"));
+  if (isProjectDir) {
+    return { projectDir: cwd, remainingArgs: args2 };
+  }
+  const defaultProject = getDefaultProject();
+  if (defaultProject) {
+    return { projectDir: defaultProject.path, remainingArgs: args2 };
+  }
+  return { projectDir: cwd, remainingArgs: args2 };
+}
+var { projectDir, remainingArgs } = parseGlobalFlags(rawArgs);
+var args = remainingArgs;
+var command = args[0];
+async function main() {
+  if (!command) {
+    printUsage();
+    process.exit(0);
+  }
+  if (hookCommands.includes(command)) {
+    await handleHook(command);
+    return;
+  }
+  switch (command) {
+    case "init": {
+      const initDir = rawArgs.some((a) => a === "--project" || a === "-p") ? projectDir : process.cwd();
+      return (await import("./init-AY5C2ZAS.js")).runInit([initDir, ...args.slice(1)]);
+    }
+    case "rules":
+      return (await import("./rules-E427DKYJ.js")).runRules(args.slice(1), projectDir);
+    case "templates":
+      return (await import("./templates-U7T6MARD.js")).runTemplates(args.slice(1), projectDir);
+    case "skills":
+      return (await import("./skills-CX73O3IV.js")).runSkills(args.slice(1), projectDir);
+    case "status":
+      return (await import("./status-4DFHDJMN.js")).runStatus(args.slice(1), projectDir);
+    case "log":
+      return (await import("./log-TVTUXAYD.js")).runLog(args.slice(1), projectDir);
+    case "export":
+      return (await import("./export-import-4A5MWLIA.js")).runExport(args.slice(1), projectDir);
+    case "import":
+      return (await import("./export-import-4A5MWLIA.js")).runImport(args.slice(1), projectDir);
+    case "uninstall":
+      return (await import("./uninstall-6SW35IK4.js")).runUninstall(args.slice(1), projectDir);
+    case "ui":
+      return (await import("./ui-L7UAWXDY.js")).runUI(args.slice(1), projectDir);
+    case "update":
+      return (await import("./update-M2B4RLGH.js")).runUpdate(args.slice(1));
+    case "history":
+      return (await import("./history-ATTUKOHO.js")).runHistory(args.slice(1), projectDir);
+    case "review":
+      return (await import("./review-ADUPV3PN.js")).runReview(args.slice(1), projectDir);
+    case "config":
+      return (await import("./config-EGAXXCGL.js")).runConfig(args.slice(1));
+    case "codemap":
+      return (await import("./codemap-RRJIDBQ5.js")).runCodemap(args.slice(1), projectDir);
+    case "memory":
+      return (await import("./memory-J3G24QHS.js")).runMemory(args.slice(1), projectDir);
+    case "projects":
+      return (await import("./projects-ATHDD3D6.js")).runProjects(args.slice(1));
+    case "--version":
+    case "-v":
+      console.log("0.1.0");
+      return;
+    case "--help":
+    case "-h":
+      printUsage();
+      return;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`
+ULPI \u2014 Rules engine for AI coding agents
+
+Usage: ulpi <command> [options]
+
+Hook Handlers (invoked by Claude Code):
+  session-start     Initialize session state
+  pre-tool          Evaluate rules before tool execution
+  post-tool         Track state and run postconditions
+  permission        Auto-approve or deny permissions
+  notification      Route notifications
+  stop              Final checks before stopping
+  session-end       Cleanup and persist summary
+
+CLI Commands:
+  init [--no-ai] [--model=<id>]  Detect stack, generate guards, install hooks
+  projects          Manage registered projects (list/add/remove/default)
+  rules             Manage rules (list/add/enable/disable/validate)
+  templates         Manage templates (list/save/apply/delete)
+  skills            Manage skills (list/add/get/attach)
+  status            Show current session state
+  log               View activity log
+  export            Export rules configuration
+  import            Import rules configuration
+  uninstall         Remove hooks
+  ui                Start web UI
+  history           Shadow branch history (init/capture/list/show/enrich/backfill)
+  review            Plan and code review management (list/show/config/migrate)
+  config            Manage settings and API keys
+  codemap           Semantic code indexing (init/search/status/reindex/watch)
+  memory            Agent memory (init/search/remember/status/export/import/serve)
+  update            Check for and install updates
+
+Global Options:
+  -p, --project <id|path>  Target a specific registered project
+  -v, --version            Show version
+  -h, --help               Show this help
+`.trim());
+}
+main().catch((err) => {
+  if (hookCommands.includes(command)) {
+    console.error(`[ulpi] Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(0);
+  }
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});