@ulpi/cli 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,34 +1,26 @@
 #!/usr/bin/env node
 import {
-  discoverUlpiServer,
-  registerWithServer,
-  waitForServerDecision
-} from "./chunk-2MZER6ND.js";
+  getDefaultRepo,
+  getRepo,
+  registerRepo
+} from "./chunk-UXHCHOWQ.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";
+  extractPlanForReview,
+  isReviewEnabled,
+  runPlanReviewSession
+} from "./chunk-V2H5D6Y3.js";
 import {
   injectSkill,
   loadSkillSync
-} from "./chunk-6OCEY7JY.js";
+} from "./chunk-4ZPOZULQ.js";
 import {
   evaluateRules,
   loadRulesSync,
   matchesFilePattern
-} from "./chunk-SIAQVRKG.js";
+} from "./chunk-5MI5GIXM.js";
+import {
+  detectStack
+} from "./chunk-RSFJ6QSR.js";
 import {
   buildPrePromptSnapshot,
   buildSessionSummary,
@@ -46,7 +38,7 @@ import {
   readTranscript,
   updateEntryTranscript,
   writeHistoryEntry
-} from "./chunk-JGBXM5NC.js";
+} from "./chunk-3WB5CXH4.js";
 import {
   JsonSessionStore,
   appendEvent,
@@ -54,29 +46,30 @@ import {
   projectDirToSlug,
   readEvents,
   updateStateFromInput
-} from "./chunk-YM2HV4IA.js";
-import "./chunk-KIKPIH6N.js";
+} from "./chunk-SEU7WWNQ.js";
 import {
+  API_LOCK_FILE,
   NOTIFICATIONS_LOG_FILE,
-  REVIEW_FLAGS_DIR,
   SESSIONS_DIR,
   ULPI_GLOBAL_DIR,
-  getApiHost,
   getApiPort,
   globalGuardsFile,
-  loadUlpiSettings,
   projectGuardsFile,
   projectGuardsFileAlt,
   projectNoAutoGenFile
-} from "./chunk-7LXY5UVC.js";
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
+import "./chunk-KIKPIH6N.js";
 import "./chunk-4VNS5WPM.js";
 
 // src/index.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
+import chalk from "chalk";
 
 // src/hooks/handler.ts
 import * as fs3 from "fs";
+import * as http from "http";
 import * as path3 from "path";
 
 // src/hooks/session-start.ts
@@ -138,10 +131,10 @@ async function handleSessionStart(ctx) {
   if (shouldPromptForGeneration(projectDir2)) {
     outputGenerationPrompt();
   }
-  import("./version-checker-Q6YTYAGP.js").then((m) => m.checkForUpdates()).catch(() => {
+  import("./version-checker-4ZFMZA7Y.js").then((m) => m.checkForUpdates()).catch(() => {
   });
   try {
-    const { isMemoryEnabled, loadMemoryConfig, getTopMemories, formatMemoriesForAgent } = await import("./dist-GJYT2OQV.js");
+    const { isMemoryEnabled, loadMemoryConfig, getTopMemories, formatMemoriesForAgent } = await import("./dist-JLU26AB6.js");
     if (isMemoryEnabled(projectDir2)) {
       const config = loadMemoryConfig(projectDir2);
       if (config.surfaceOnStart) {
@@ -155,15 +148,15 @@ async function handleSessionStart(ctx) {
   } catch {
   }
   try {
-    const { loadCodemapConfig } = await import("./dist-CB5D5LMO.js");
-    const { getCodemapBranch, getCurrentBranch } = await import("./dist-RKOGLK7R.js");
-    const { historyBranchExists: historyBranchExists2 } = await import("./dist-QAU3LGJN.js");
+    const { loadCodemapConfig } = await import("./dist-YFFG2ZD6.js");
+    const { getCodemapBranch, getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
+    const { historyBranchExists: historyBranchExists2 } = await import("./dist-YCNWHSLN.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-CB5D5LMO.js");
+        const { importIndex } = await import("./dist-YFFG2ZD6.js");
         await importIndex(projectDir2, branch);
       }
     }
@@ -231,6 +224,8 @@ import { join as join2 } from "path";
 import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
+import { spawn } from "child_process";
+import { platform as platform2 } from "os";
 import * as fs2 from "fs";
 import * as path2 from "path";
 function classifyNotification(input) {
@@ -306,9 +301,9 @@ var NotificationDeduplicator = class _NotificationDeduplicator {
   }
 };
 function sendDesktopNotification(title, message) {
-  const platform2 = os.platform();
+  const platform3 = os.platform();
   try {
-    if (platform2 === "darwin") {
+    if (platform3 === "darwin") {
       const escapedBody = message.replace(/["\\]/g, "\\$&");
       const escapedTitle = title.replace(/["\\]/g, "\\$&");
       const script = `display notification "${escapedBody}" with title "${escapedTitle}"`;
@@ -318,14 +313,14 @@ function sendDesktopNotification(title, message) {
       });
       return true;
     }
-    if (platform2 === "linux") {
+    if (platform3 === "linux") {
       execFileSync("notify-send", [title, message], {
         timeout: 5e3,
         stdio: "ignore"
       });
       return true;
     }
-    if (platform2 === "win32") {
+    if (platform3 === "win32") {
       const escapedTitle = title.replace(/'/g, "''");
       const escapedBody = message.replace(/'/g, "''");
       const ps = [
@@ -431,6 +426,78 @@ function writeTerminalNotification(title, message) {
 [ulpi] ${title}: ${message}
 `);
 }
+var MACOS_SOUNDS = {
+  success: "/System/Library/Sounds/Glass.aiff",
+  error: "/System/Library/Sounds/Sosumi.aiff",
+  warning: "/System/Library/Sounds/Basso.aiff",
+  complete: "/System/Library/Sounds/Hero.aiff"
+};
+var LINUX_SOUNDS = {
+  success: "/usr/share/sounds/freedesktop/stereo/complete.oga",
+  error: "/usr/share/sounds/freedesktop/stereo/dialog-error.oga",
+  warning: "/usr/share/sounds/freedesktop/stereo/dialog-warning.oga",
+  complete: "/usr/share/sounds/freedesktop/stereo/complete.oga"
+};
+var WIN_SOUNDS = {
+  success: "Asterisk",
+  error: "Hand",
+  warning: "Exclamation",
+  complete: "Asterisk"
+};
+function playSound(soundName) {
+  const os2 = platform2();
+  try {
+    switch (os2) {
+      case "darwin": {
+        const soundPath = MACOS_SOUNDS[soundName];
+        const proc = spawn("afplay", [soundPath], {
+          stdio: "ignore",
+          detached: true
+        });
+        proc.unref();
+        return true;
+      }
+      case "linux": {
+        const soundPath = LINUX_SOUNDS[soundName];
+        const proc = spawn("paplay", [soundPath], {
+          stdio: "ignore",
+          detached: true
+        });
+        proc.on("error", () => {
+          const fallback = spawn("aplay", ["-q", soundPath], {
+            stdio: "ignore",
+            detached: true
+          });
+          fallback.unref();
+        });
+        proc.unref();
+        return true;
+      }
+      case "win32": {
+        const systemSound = WIN_SOUNDS[soundName];
+        const proc = spawn(
+          "powershell",
+          [
+            "-NoProfile",
+            "-Command",
+            `[System.Media.SystemSounds]::${systemSound}.Play()`
+          ],
+          {
+            stdio: "ignore",
+            detached: true,
+            windowsHide: true
+          }
+        );
+        proc.unref();
+        return true;
+      }
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+}
 var deduplicator = new NotificationDeduplicator();
 function getEventConfig(classified, config) {
   const key = classified;
@@ -517,6 +584,10 @@ async function routeToChannel(channel, title, message, timestamp, event) {
         timestamp
       });
     }
+    case "sound": {
+      const soundName = channel.sound_name;
+      return playSound(soundName ?? "complete");
+    }
     default:
       return false;
   }
@@ -808,453 +879,6 @@ async function dispatchToChannel(channel, title, message) {
   }
 }
 
-// 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;
@@ -1324,32 +948,6 @@ async function handlePreTool(ctx) {
     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));
@@ -1377,15 +975,12 @@ async function handlePostTool(ctx) {
     }
   }
   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));
+    const { collectPostReviewContexts } = await import("./review-integration-5WHEJU2A.js");
+    const reviewCtx = collectPostReviewContexts(input.session_id);
+    if (reviewCtx.feedback) {
+      process.stderr.write(`[ulpi] Review feedback:
+${reviewCtx.feedback}
+`);
     }
   } catch {
   }
@@ -1473,7 +1068,7 @@ ${failureFeedback.join("\n\n")}`
     }
   }
   try {
-    const { isMemoryEnabled, loadMemoryConfig, appendMemoryEvent, toClassificationEvent } = await import("./dist-GJYT2OQV.js");
+    const { isMemoryEnabled, loadMemoryConfig, appendMemoryEvent, toClassificationEvent } = await import("./dist-JLU26AB6.js");
     if (isMemoryEnabled(projectDir2)) {
       const memConfig = loadMemoryConfig(projectDir2);
       if (memConfig.captureMode === "continuous") {
@@ -1493,8 +1088,8 @@ ${failureFeedback.join("\n\n")}`
   }
   if (input.tool_name === "Bash" && /\bgit\s+push\b/.test(String(input.tool_input?.command ?? ""))) {
     try {
-      const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-CB5D5LMO.js");
-      const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+      const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-YFFG2ZD6.js");
+      const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
       const codemapConfig = loadCodemapConfig(projectDir2);
       if (codemapConfig.autoExport) {
         const branch = state.branch ?? getCurrentBranch(projectDir2);
@@ -1540,6 +1135,51 @@ async function captureOnCommit(projectDir2, state, input, sha) {
 // src/hooks/permission.ts
 async function handlePermission(ctx) {
   const { input, state, rules, projectDir: projectDir2, store } = ctx;
+  if (input.tool_name === "ExitPlanMode") {
+    try {
+      if (isReviewEnabled("plan", rules)) {
+        const plan = extractPlanForReview(input);
+        if (plan) {
+          appendEvent(input.session_id, {
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            event: "review_plan_started",
+            hookEvent: input.hook_event_name,
+            toolName: input.tool_name,
+            message: "Plan review started"
+          }, projectDir2);
+          const reviewResult = await runPlanReviewSession(plan, projectDir2, input.session_id);
+          if (reviewResult) {
+            if (reviewResult.behavior === "deny") {
+              appendEvent(input.session_id, {
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                event: "review_plan_denied",
+                hookEvent: input.hook_event_name,
+                toolName: input.tool_name,
+                message: reviewResult.feedback ?? "Plan review denied"
+              }, projectDir2);
+              state.actionsBlocked++;
+              store.save(state);
+              process.stderr.write(
+                reviewResult.feedback ? `[ulpi] Plan review denied:
+${reviewResult.feedback}` : "[ulpi] Plan review denied by reviewer."
+              );
+              return 2;
+            }
+            appendEvent(input.session_id, {
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              event: "review_plan_approved",
+              hookEvent: input.hook_event_name,
+              toolName: input.tool_name,
+              message: "Plan review approved"
+            }, projectDir2);
+            state.planApproved = true;
+            store.save(state);
+          }
+        }
+      }
+    } catch {
+    }
+  }
   const result = evaluateRules(input, rules, state, projectDir2);
   const hookDecision = result.stdoutJson?.hookSpecificOutput?.decision?.behavior ?? result.stdoutJson?.hookSpecificOutput?.permissionDecision;
   if (hookDecision) {
@@ -1597,60 +1237,6 @@ async function handlePermission(ctx) {
     }
     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;
 }
 
@@ -1747,7 +1333,7 @@ ${warnings.map((w) => `  - ${w}`).join("\n")}`
 }
 
 // src/hooks/session-end.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 async function captureSessionCommits(ctx) {
   const { input, state, projectDir: projectDir2 } = ctx;
   if (!state.headAtStart) return;
@@ -1835,7 +1421,7 @@ async function handleSessionEnd(ctx) {
   } catch {
   }
   try {
-    const memEngine = await import("./dist-GJYT2OQV.js");
+    const memEngine = await import("./dist-JLU26AB6.js");
     if (memEngine.isMemoryEnabled(projectDir2)) {
       const config = memEngine.loadMemoryConfig(projectDir2);
       memEngine.finalizeCapture(input.session_id, state, projectDir2);
@@ -1843,7 +1429,7 @@ async function handleSessionEnd(ctx) {
         try {
           const args2 = ["memory", "classify", "-p", projectDir2, "--session", input.session_id];
           if (config.autoExport) args2.push("--export");
-          const child = spawn(process.execPath, [process.argv[1], ...args2], {
+          const child = spawn2(process.execPath, [process.argv[1], ...args2], {
             detached: true,
             stdio: "ignore",
             env: { ...process.env, ULPI_BG_CLASSIFY: "1" }
@@ -1865,7 +1451,7 @@ async function handleSessionEnd(ctx) {
   try {
     if (historyBranchExists(projectDir2)) {
       const args2 = ["history", "backfill", "-p", projectDir2, "--limit", "50", "--branch-only"];
-      const child = spawn(process.execPath, [process.argv[1], ...args2], {
+      const child = spawn2(process.execPath, [process.argv[1], ...args2], {
         detached: true,
         stdio: "ignore"
       });
@@ -1874,8 +1460,8 @@ async function handleSessionEnd(ctx) {
   } catch {
   }
   try {
-    const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-CB5D5LMO.js");
-    const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+    const { loadCodemapConfig, getCodemapStatus, exportIndex } = await import("./dist-YFFG2ZD6.js");
+    const { getCurrentBranch } = await import("./dist-NUXMDXZ3.js");
     const codemapConfig = loadCodemapConfig(projectDir2);
     if (codemapConfig.autoExport) {
       const branch = state.branch ?? getCurrentBranch(projectDir2);
@@ -1888,10 +1474,51 @@ async function handleSessionEnd(ctx) {
   }
 }
 
+// src/hooks/normalize.ts
+var TOOL_NAME_MAP = {
+  fs_read: "Read",
+  read: "Read",
+  fs_write: "Write",
+  write: "Write",
+  fs_edit: "Edit",
+  edit: "Edit",
+  execute_bash: "Bash",
+  shell: "Bash",
+  fs_glob: "Glob",
+  glob: "Glob",
+  fs_grep: "Grep",
+  grep: "Grep",
+  web_fetch: "WebFetch",
+  web_search: "WebSearch"
+};
+var EVENT_NAME_MAP = {
+  preToolUse: "PreToolUse",
+  postToolUse: "PostToolUse",
+  permissionRequest: "PermissionRequest",
+  agentSpawn: "SessionStart",
+  sessionStart: "SessionStart",
+  sessionEnd: "SessionEnd",
+  userPromptSubmit: "UserPromptSubmit",
+  notification: "Notification",
+  stop: "Stop"
+};
+function normalizeHookInput(raw) {
+  if (typeof raw.hook_event_name === "string") {
+    raw.hook_event_name = EVENT_NAME_MAP[raw.hook_event_name] ?? raw.hook_event_name;
+  }
+  if (typeof raw.tool_name === "string") {
+    const lower = raw.tool_name.toLowerCase();
+    raw.tool_name = TOOL_NAME_MAP[lower] ?? raw.tool_name;
+  }
+  return raw;
+}
+
 // src/hooks/handler.ts
 function readStdinSync() {
   const raw = fs3.readFileSync(0, "utf-8");
-  return JSON.parse(raw);
+  const parsed = JSON.parse(raw);
+  normalizeHookInput(parsed);
+  return parsed;
 }
 function findRulesPath(projectDir2) {
   const projectRules = projectGuardsFile(projectDir2);
@@ -1940,6 +1567,98 @@ function validateInput(input) {
     throw new Error("Missing or invalid hook_event_name");
   }
 }
+function emitToApi(event) {
+  try {
+    const lockData = JSON.parse(fs3.readFileSync(API_LOCK_FILE, "utf-8"));
+    const port = lockData.port;
+    if (!port) return;
+    const body = JSON.stringify(event);
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": String(Buffer.byteLength(body))
+    };
+    if (lockData.secret) {
+      headers["X-Ulpi-Secret"] = lockData.secret;
+    }
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/events/emit",
+      method: "POST",
+      headers,
+      timeout: 2e3
+    });
+    req.on("error", () => {
+    });
+    req.on("timeout", () => req.destroy());
+    req.write(body);
+    req.end();
+  } catch {
+  }
+}
+function buildHookEvent(hookName, input, exitCode) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionId = input.session_id;
+  switch (hookName) {
+    case "session-start":
+      return {
+        type: "hook:session-start",
+        ts,
+        sessionId,
+        projectDir: input.cwd,
+        cwd: input.cwd
+      };
+    case "session-end":
+      return {
+        type: "hook:session-end",
+        ts,
+        sessionId,
+        durationMs: 0
+        // Duration not available at hook level
+      };
+    case "pre-tool":
+      return {
+        type: "hook:pre-tool",
+        ts,
+        sessionId,
+        toolName: input.tool_name ?? "unknown",
+        filePath: input.tool_input?.file_path
+      };
+    case "post-tool":
+      return {
+        type: "hook:post-tool",
+        ts,
+        sessionId,
+        toolName: input.tool_name ?? "unknown",
+        filePath: input.tool_input?.file_path,
+        durationMs: 0
+        // Duration not available at hook level
+      };
+    case "permission":
+      return {
+        type: "hook:permission",
+        ts,
+        sessionId,
+        toolName: input.tool_name ?? "unknown",
+        decision: exitCode === 0 ? "allow" : "deny"
+      };
+    case "notification":
+      return {
+        type: "hook:notification",
+        ts,
+        sessionId,
+        message: input.message ?? ""
+      };
+    case "stop":
+      return {
+        type: "hook:stop",
+        ts,
+        sessionId
+      };
+    default:
+      return null;
+  }
+}
 async function handleHook(hookName) {
   const input = readStdinSync();
   validateInput(input);
@@ -1960,9 +1679,9 @@ async function handleHook(hookName) {
     projectDir: projectDir2,
     store
   };
-  if (hookName === "session-start") {
+  if (hookName === "session-start" && !projectDir2.includes(".ulpi-worktrees")) {
     try {
-      registerProject(projectDir2, {
+      registerRepo(projectDir2, {
         sessionId: input.session_id
       });
     } catch {
@@ -1992,6 +1711,10 @@ async function handleHook(hookName) {
       await handleSessionEnd(ctx);
       break;
   }
+  const hookEvent = buildHookEvent(hookName, input, exitCode);
+  if (hookEvent) {
+    emitToApi(hookEvent);
+  }
   process.exit(exitCode);
 }
 
@@ -2010,7 +1733,7 @@ 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);
+    const entry = getRepo(projectRef);
     if (!entry) {
       console.error(`Error: Unknown project: ${projectRef}`);
       console.error("Run 'ulpi projects list' to see registered projects.");
@@ -2024,7 +1747,7 @@ function parseGlobalFlags(args2) {
   if (isProjectDir) {
     return { projectDir: cwd, remainingArgs: args2 };
   }
-  const defaultProject = getDefaultProject();
+  const defaultProject = getDefaultRepo();
   if (defaultProject) {
     return { projectDir: defaultProject.path, remainingArgs: args2 };
   }
@@ -2045,47 +1768,81 @@ async function main() {
   switch (command) {
     case "init": {
       const initDir = rawArgs.some((a) => a === "--project" || a === "-p") ? projectDir : process.cwd();
-      return (await import("./init-6CH4HV5T.js")).runInit([initDir, ...args.slice(1)]);
+      return (await import("./init-5FK3VKRT.js")).runInit([initDir, ...args.slice(1)]);
     }
     case "rules":
-      return (await import("./rules-E427DKYJ.js")).runRules(args.slice(1), projectDir);
+      return (await import("./rules-Y4VSOY5Y.js")).runRules(args.slice(1), projectDir);
     case "templates":
-      return (await import("./templates-U7T6MARD.js")).runTemplates(args.slice(1), projectDir);
+      return (await import("./templates-CBRUJ66V.js")).runTemplates(args.slice(1), projectDir);
     case "skills":
-      return (await import("./skills-CX73O3IV.js")).runSkills(args.slice(1), projectDir);
+      return (await import("./skills-QEYU2N27.js")).runSkills(args.slice(1), projectDir);
     case "status":
-      return (await import("./status-4DFHDJMN.js")).runStatus(args.slice(1), projectDir);
+      return (await import("./status-BHQYYGAL.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);
+      return (await import("./export-import-JFQH4KSJ.js")).runExport(args.slice(1), projectDir);
     case "import":
-      return (await import("./export-import-4A5MWLIA.js")).runImport(args.slice(1), projectDir);
+      return (await import("./export-import-JFQH4KSJ.js")).runImport(args.slice(1), projectDir);
     case "uninstall":
-      return (await import("./uninstall-6SW35IK4.js")).runUninstall(args.slice(1), projectDir);
+      return (await import("./uninstall-ICUV6DDV.js")).runUninstall(args.slice(1), projectDir);
+    case "start":
+      return (await import("./start-JYOEL7AJ.js")).runStart(args.slice(1), projectDir);
     case "ui":
-      return (await import("./ui-OWXZ3YSR.js")).runUI(args.slice(1), projectDir);
+      console.log(chalk.yellow("'ulpi ui' is deprecated. Use 'ulpi start' instead."));
+      return (await import("./start-JYOEL7AJ.js")).runStart(args.slice(1), projectDir);
     case "update":
-      return (await import("./update-M6IBJNYP.js")).runUpdate(args.slice(1));
+      return (await import("./update-7ZMAYRBH.js")).runUpdate(args.slice(1));
     case "history":
-      return (await import("./history-3MOBX4MA.js")).runHistory(args.slice(1), projectDir);
+      return (await import("./history-5NE46ZAH.js")).runHistory(args.slice(1), projectDir);
     case "review":
-      return (await import("./review-ADUPV3PN.js")).runReview(args.slice(1), projectDir);
+      console.error("The 'review' command has been removed in ULPI v2.");
+      process.exit(1);
+      return;
     case "config":
-      return (await import("./config-EGAXXCGL.js")).runConfig(args.slice(1));
+      return (await import("./config-OOELBYTH.js")).runConfig(args.slice(1));
     case "codemap":
-      return (await import("./codemap-RKSD4MIE.js")).runCodemap(args.slice(1), projectDir);
+      return (await import("./codemap-XNGMAF3F.js")).runCodemap(args.slice(1), projectDir);
     case "memory":
-      return (await import("./memory-Y6OZTXJ2.js")).runMemory(args.slice(1), projectDir);
-    case "projects":
-      return (await import("./projects-ATHDD3D6.js")).runProjects(args.slice(1));
+      return (await import("./memory-ZNAEAK3B.js")).runMemory(args.slice(1), projectDir);
+    case "repos":
+      return (await import("./repos-WWZXNN3P.js")).runRepos(args.slice(1));
     case "ci":
-      return (await import("./ci-STSL2LSP.js")).runCi(args.slice(1), projectDir);
+      return (await import("./ci-X3U2W4HC.js")).runCi(args.slice(1), projectDir);
     case "auth":
-      return (await import("./auth-ECQ3IB4E.js")).runAuth(args.slice(1));
+      return (await import("./auth-HDK7ECJL.js")).runAuth(args.slice(1));
+    case "prd":
+      return (await import("./prd-Q4J5NVAR.js")).runPrd(args.slice(1), projectDir);
+    case "run":
+      return (await import("./run-VPNXEIBY.js")).runRunCommand(args.slice(1), projectDir);
+    case "job":
+      return (await import("./job-HIDMAFW2.js")).runJobCommand(args.slice(1), projectDir);
+    case "tui":
+      return (await import("./tui-DP7736EX.js")).runTuiCommand(args.slice(1), projectDir);
+    case "portal":
+      return (await import("./portal-JYWVHXDU.js")).runPortalCommand(args.slice(1), projectDir);
+    case "doctor":
+      return (await import("./doctor-SI4LLLDZ.js")).runDoctorCommand(args.slice(1), projectDir);
+    case "kiro":
+      return (await import("./kiro-VMUHDFGK.js")).runKiro(args.slice(1), projectDir);
+    case "codex":
+      return (await import("./codex-MB5YTMRT.js")).runCodex(args.slice(1), projectDir);
+    case "mcp":
+      if (args[1] === "setup") {
+        return (await import("./mcp-setup-OA7IB3H3.js")).runMcpSetup(projectDir);
+      }
+      if (args[1] === "codemap") {
+        return (await import("./codemap-XNGMAF3F.js")).runCodemap(["serve"], projectDir);
+      }
+      if (args[1] === "memory") {
+        return (await import("./memory-ZNAEAK3B.js")).runMemory(["serve"], projectDir);
+      }
+      return (await import("./mcp-PDUD7SGP.js")).runMcp(args.slice(1), projectDir);
+    case "cloud":
+      return (await import("./cloud-2F3NLVHN.js")).runCloud(args.slice(1), projectDir);
     case "--version":
     case "-v":
-      console.log("0.1.4");
+      console.log("0.1.6");
       return;
     case "--help":
     case "-h":
@@ -2099,11 +1856,11 @@ async function main() {
 }
 function printUsage() {
   console.log(`
-ULPI \u2014 Rules engine for AI coding agents
+ULPI \u2014 Autonomous AI agent orchestration engine
 
 Usage: ulpi <command> [options]
 
-Hook Handlers (invoked by Claude Code):
+Hook Handlers (invoked by AI agents):
   session-start     Initialize session state
   pre-tool          Evaluate rules before tool execution
   post-tool         Track state and run postconditions
@@ -2112,23 +1869,42 @@ Hook Handlers (invoked by Claude Code):
   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)
+Core Commands:
+  start             Start ULPI daemon (API server + codemap watcher)
+  run               Start execution engine loop (agent + tracker)
+  init              Detect stack, generate guards, install hooks
+
+Management Commands:
+  repos             Manage registered repos (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)
+  config            Manage settings and API keys
+  prd               PRD management (create/convert/show)
+  job               Manage execution jobs (create/list/status/cancel/logs)
+
+Monitoring Commands:
   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
+  tui               Terminal UI client (connects to daemon)
+  portal            Start Portal dashboard in local mode (start/stop)
+  doctor            System health check (agents, MCP, hooks, intelligence)
+
+Data & Intelligence:
   codemap           Semantic code indexing (init/search/status/reindex/watch)
   memory            Agent memory (init/search/remember/status/export/import/serve)
+  mcp               MCP management (gateway/list/add/remove/enable/disable/catalog/setup)
+  cloud             Connect to Cloud MCP Gateway (connect/status/disconnect)
+
+Agent Integrations:
+  kiro              Manage Kiro CLI integration (install/uninstall/status)
+  codex             Manage Codex CLI integration (install/convert/uninstall/status)
+
+Utility:
+  export            Export rules configuration
+  import            Import rules configuration
+  uninstall         Remove hooks
   ci                Run in CI/PR worker mode (used inside worker containers)
   auth              Manage Claude Code credentials for CI workers
   update            Check for and install updates