agendex-cli 0.18.0 → 1.1.0

package/dist/cli.js

@@ -1059,8 +1059,8 @@ var init_cleanup = __esm(() => {
 
 // src/cli.ts
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync11, statSync as statSync2, writeSync } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { existsSync as existsSync12, statSync as statSync2, writeSync } from "node:fs";
+import { resolve as resolve9 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../shared/src/adapters/catalog.ts
@@ -1924,6 +1924,19 @@ function parseDate2(value) {
     return;
   return date;
 }
+function liveSessionIdentity(input) {
+  if (input.sourcePlanPath) {
+    return hashPath(`plannotator-live:${resolve2(input.sourcePlanPath)}`);
+  }
+  if (input.session.reviewId) {
+    return hashPath(`plannotator-live-review:${input.session.reviewId}`);
+  }
+  const project = input.session.project ?? input.planResponse.versionInfo?.project ?? input.planResponse.projectRoot;
+  if (project && input.session.label) {
+    return hashPath(`plannotator-live:${project}:${input.session.label}:${input.mode}`);
+  }
+  return hashPath(input.sessionPath);
+}
 function metadataRecord(metadata) {
   return {
     source: "plannotator",
@@ -2085,11 +2098,18 @@ async function parseLiveSession(filePath) {
       sessionPath: filePath,
       sourcePlanPath,
       startedAt: session.startedAt,
-      writebackCapable: true
+      writebackCapable: true,
+      liveness: "live"
     };
     return [
       {
-        id: hashPath(filePath),
+        id: liveSessionIdentity({
+          sessionPath: filePath,
+          session,
+          planResponse,
+          mode: responseMode,
+          sourcePlanPath
+        }),
         agent: origin ?? "plannotator",
         title: extractTitle5(planResponse.plan, session.label ?? filePath),
         content: planResponse.plan,
@@ -2181,6 +2201,12 @@ var plannotatorAdapter = {
       return false;
     if (!isSafePlannotatorUrl(metadata.url))
       return false;
+    if (payload.action === "approve") {
+      return await postJson(apiUrl(metadata.url, "/api/approve"), {
+        ...payload.feedback.trim() && { feedback: payload.feedback.trim() },
+        planSave: { enabled: true }
+      });
+    }
     const feedback = formatWritebackFeedback(plan, payload);
     if (metadata.mode === "review" || metadata.mode === "annotate") {
       return await postJson(apiUrl(metadata.url, "/api/feedback"), {
@@ -2910,6 +2936,8 @@ async function loadOrInitConfig(options = {}) {
 // ../shared/src/daemon-status.ts
 var CLI_DAEMON_HEARTBEAT_INTERVAL_MS = 30000;
 var CLI_DAEMON_STALE_AFTER_MS = CLI_DAEMON_HEARTBEAT_INTERVAL_MS * 5;
+// ../shared/src/services/annotation-store.ts
+var mutationQueue = Promise.resolve();
 // ../shared/src/services/plan-service.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, realpathSync, statSync } from "node:fs";
 import { lstat, mkdir, readdir as readdir2, readFile as readFile7, stat as stat7, writeFile as writeFile3 } from "node:fs/promises";
@@ -3578,7 +3606,13 @@ async function requestChanges(id, payload) {
     return false;
   const ok = await adapter.requestChanges(plan, payload);
   if (ok) {
-    const plannotator = typeof plan.metadata.plannotator === "object" && plan.metadata.plannotator !== null ? { ...plan.metadata.plannotator, lastWritebackStatus: "sent", lastWritebackAt: Date.now() } : undefined;
+    const writebackAt = Date.now();
+    const plannotator = typeof plan.metadata.plannotator === "object" && plan.metadata.plannotator !== null ? {
+      ...plan.metadata.plannotator,
+      ...payload.action === "approve" ? { status: "approved" } : {},
+      lastWritebackStatus: "sent",
+      lastWritebackAt: writebackAt
+    } : undefined;
     if (plannotator)
       plan.metadata = { ...plan.metadata, plannotator };
     plan.updatedAt = new Date;
@@ -4632,7 +4666,33 @@ var RESTART_WINDOW_MS = 60000;
 var RESTART_DELAY_MS = 5000;
 var PLANNOTATOR_WRITEBACK_POLL_INTERVAL_MS = 15000;
 var PLANNOTATOR_WRITEBACK_EXPIRED_ERROR = "Write-back expired before delivery.";
-var PLANNOTATOR_WRITEBACK_FAILED_ERROR = "No live Plannotator session accepted the request-changes payload.";
+var PLANNOTATOR_WRITEBACK_FAILED_ERROR = "No live Plannotator session accepted the write-back payload.";
+var PLANNOTATOR_LIVENESS_SWEEP_INTERVAL_MS = 20000;
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function isLivePlannotatorPayload(payload) {
+  const plannotator = isRecord5(payload.metadata) ? payload.metadata.plannotator : undefined;
+  if (!isRecord5(plannotator))
+    return false;
+  return plannotator.kind === "live-session" && plannotator.writebackCapable === true;
+}
+function buildEndedPlannotatorPayload(payload) {
+  const metadata = isRecord5(payload.metadata) ? payload.metadata : {};
+  const plannotator = isRecord5(metadata.plannotator) ? metadata.plannotator : {};
+  return {
+    ...payload,
+    metadata: {
+      ...metadata,
+      plannotator: {
+        ...plannotator,
+        writebackCapable: false,
+        liveness: "ended",
+        endedAt: Date.now()
+      }
+    }
+  };
+}
 async function runWorker() {
   const config = await loadOrInitConfig();
   const hostname2 = osHostname2();
@@ -4642,6 +4702,7 @@ async function runWorker() {
   const syncCache = loadSyncCache();
   const syncQueue = [];
   const pendingWritebackReports = loadPendingWritebackReports();
+  const liveSessions = new Map;
   let syncing = false;
   let cachedIpAddress;
   async function getSyncIpAddress() {
@@ -4717,6 +4778,31 @@ async function runWorker() {
     if (syncQueue.length > 0)
       processSyncQueue();
   }
+  async function reconcileLivePlannotatorSessions(plans2) {
+    const ipAddress = await getSyncIpAddress();
+    const livePayloads = new Map;
+    for (const plan of plans2) {
+      const payload = planToSyncPayload(plan, config.deviceId, hostname2, ipAddress);
+      if (isLivePlannotatorPayload(payload))
+        livePayloads.set(payload.localPlanId, payload);
+    }
+    let queued = false;
+    for (const [planId, lastPayload] of liveSessions) {
+      if (livePayloads.has(planId))
+        continue;
+      const endedPayload = buildEndedPlannotatorPayload(lastPayload);
+      syncQueue.push(endedPayload);
+      liveSessions.delete(planId);
+      queued = true;
+      console.log(`[agendex] Plannotator session ended: ${endedPayload.title}`);
+    }
+    for (const [planId, payload] of livePayloads) {
+      liveSessions.set(planId, payload);
+    }
+    if (queued)
+      processSyncQueue();
+    return queued;
+  }
   function persistPendingWritebackReports() {
     if (!savePendingWritebackReports(pendingWritebackReports)) {
       console.error("[agendex] failed to persist Plannotator write-back delivery cache");
@@ -4759,6 +4845,7 @@ async function runWorker() {
       return;
     }
     const ok = await requestChanges(job.localPlanId, {
+      action: job.action,
       feedback: job.feedback,
       revisedContent: job.revisedContent,
       annotations: job.annotations,
@@ -4769,7 +4856,11 @@ async function runWorker() {
     if (ok) {
       const updatedPlan = getById(job.localPlanId);
       if (updatedPlan) {
-        syncQueue.push(planToSyncPayload(updatedPlan, config.deviceId, hostname2, await getSyncIpAddress()));
+        const updatedPayload = planToSyncPayload(updatedPlan, config.deviceId, hostname2, await getSyncIpAddress());
+        syncQueue.push(updatedPayload);
+        if (isLivePlannotatorPayload(updatedPayload)) {
+          liveSessions.set(updatedPayload.localPlanId, updatedPayload);
+        }
       }
       pendingWritebackReports.set(job._id, "sent");
       persistPendingWritebackReports();
@@ -4834,6 +4925,7 @@ async function runWorker() {
   const lowValueSuffix = lowValuePlanCount > 0 ? `, ${lowValuePlanCount} low-value hidden/pruned` : "";
   console.log(`[agendex] syncing ${initialQueuedSyncable} plans${lowValueSuffix} (${initialQueuedLowValue} low-value queued, ${initialSkipped} unchanged)...`);
   await processSyncQueue();
+  await reconcileLivePlannotatorSessions(getAll());
   setInterval(() => {
     (async () => {
       await sendHeartbeat(await getSyncIpAddress());
@@ -4842,6 +4934,14 @@ async function runWorker() {
   if (shouldEnablePlannotatorSync(config)) {
     setInterval(() => void pollPlannotatorWritebacks(), PLANNOTATOR_WRITEBACK_POLL_INTERVAL_MS);
     pollPlannotatorWritebacks();
+    setInterval(() => {
+      (async () => {
+        await scan();
+        await reconcileLivePlannotatorSessions(getAll());
+      })().catch((err) => {
+        console.error("[agendex] Plannotator liveness sweep failed:", err);
+      });
+    }, PLANNOTATOR_LIVENESS_SWEEP_INTERVAL_MS);
   }
   startWatching((changedPlans) => {
     (async () => {
@@ -4850,6 +4950,7 @@ async function runWorker() {
         syncQueue.push(planToSyncPayload(plan, config.deviceId, hostname2, ipAddress));
       }
       processSyncQueue();
+      await reconcileLivePlannotatorSessions(getAll());
     })().catch((err) => {
       console.error("[agendex] failed to queue changed plans:", err);
     });
@@ -4883,8 +4984,12 @@ async function startSupervisor() {
   const scriptPath = resolve6(process.argv[1] ?? fileURLToPath(new URL("./cli.ts", import.meta.url)));
   const restartTimes = [];
   while (!stopping) {
-    workerProc = spawn2(process.execPath, [scriptPath, "start", "--worker"], {
-      stdio: ["ignore", "inherit", "inherit"]
+    const workerArgs = [scriptPath, "start", "--worker"];
+    if (isDevMode())
+      workerArgs.push("--dev");
+    workerProc = spawn2(process.execPath, workerArgs, {
+      stdio: ["ignore", "inherit", "inherit"],
+      env: { ...process.env, ...isDevMode() ? { AGENDEX_DEV: "1" } : {} }
     });
     const exitCode = await new Promise((resolve7) => {
       workerProc?.once("exit", (code) => resolve7(code));
@@ -4912,6 +5017,379 @@ async function startSupervisor() {
   removePid();
 }
 
+// src/hooks.ts
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { mkdir as mkdir2, rm, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir10 } from "node:os";
+import { dirname as dirname4, join as join14, resolve as resolve7 } from "node:path";
+var SUPPORTED_AGENTS = ["claude-code", "codex", "pi"];
+var MANAGED_MARKER = "agendex-plan-review";
+var HOOK_TIMEOUT_SECONDS = 345600;
+var CLAUDE_PREVIEW_FLAG = "--preview";
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function commandFor(cliEntry, agent) {
+  return `${shellQuote(process.execPath)} ${shellQuote(cliEntry)} review-plan --hook --agent ${agent}`;
+}
+function scopeRoot(scope) {
+  return scope === "repo" ? resolve7(process.env.PWD || process.cwd()) : homedir10();
+}
+function hooksJsonPath(agent, scope) {
+  const root = scopeRoot(scope);
+  if (agent === "claude-code")
+    return join14(root, ".claude", "hooks.json");
+  if (agent === "codex")
+    return join14(root, ".codex", "hooks.json");
+  return join14(root, scope === "repo" ? ".pi/extensions/agendex/index.ts" : ".pi/agent/extensions/agendex/index.ts");
+}
+function codexConfigPath(scope) {
+  return join14(scopeRoot(scope), ".codex", "config.toml");
+}
+function readJsonFile(path) {
+  if (!existsSync10(path))
+    return {};
+  try {
+    return JSON.parse(readFileSync7(path, "utf-8"));
+  } catch (err) {
+    throw new Error(`Could not parse ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function backupPathFor(path) {
+  return `${path}.bak-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+}
+async function writeWithBackup(path, content, dryRun) {
+  if (dryRun)
+    return;
+  await mkdir2(dirname4(path), { recursive: true });
+  if (existsSync10(path)) {
+    await writeFile4(backupPathFor(path), readFileSync7(path, "utf-8"), "utf-8");
+  }
+  await writeFile4(path, content, "utf-8");
+}
+async function removeWithBackup(path, dryRun) {
+  if (dryRun || !existsSync10(path))
+    return;
+  await writeFile4(backupPathFor(path), readFileSync7(path, "utf-8"), "utf-8");
+  await rm(path);
+}
+function mergeCommandHook({
+  config,
+  event,
+  matcher,
+  command
+}) {
+  const hooks = isRecord6(config.hooks) ? { ...config.hooks } : {};
+  const existingEvent = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+  const entry = {
+    ...matcher ? { matcher } : {},
+    id: MANAGED_MARKER,
+    hooks: [
+      {
+        type: "command",
+        command,
+        timeout: HOOK_TIMEOUT_SECONDS
+      }
+    ]
+  };
+  const index = existingEvent.findIndex((item) => {
+    if (!isRecord6(item))
+      return false;
+    if (item.id === MANAGED_MARKER)
+      return true;
+    return JSON.stringify(item).includes("agendex") && JSON.stringify(item).includes("review-plan");
+  });
+  if (index >= 0)
+    existingEvent[index] = entry;
+  else
+    existingEvent.push(entry);
+  hooks[event] = existingEvent;
+  return { ...config, hooks };
+}
+function hasManagedHook(path) {
+  if (!existsSync10(path))
+    return false;
+  const raw = readFileSync7(path, "utf-8");
+  return raw.includes(MANAGED_MARKER) || raw.includes("agendex") && raw.includes("review-plan");
+}
+function isManagedHookEntry(item) {
+  if (!isRecord6(item))
+    return false;
+  if (item.id === MANAGED_MARKER)
+    return true;
+  const serialized = JSON.stringify(item);
+  return serialized.includes("agendex") && serialized.includes("review-plan");
+}
+function removeManagedHooks(config) {
+  if (!isRecord6(config.hooks))
+    return config;
+  const hooks = {};
+  for (const [event, value] of Object.entries(config.hooks)) {
+    if (!Array.isArray(value)) {
+      hooks[event] = value;
+      continue;
+    }
+    const kept = value.filter((item) => !isManagedHookEntry(item));
+    if (kept.length > 0)
+      hooks[event] = kept;
+  }
+  return Object.keys(hooks).length > 0 ? { ...config, hooks } : { ...config, hooks: {} };
+}
+function ensureCodexHooksEnabled(raw) {
+  const lines = raw ? raw.split(`
+`) : [];
+  const featuresIndex = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+  if (featuresIndex === -1) {
+    return `${raw.trimEnd()}
+
+[features]
+hooks = true
+`;
+  }
+  let insertAt = lines.length;
+  for (let i = featuresIndex + 1;i < lines.length; i++) {
+    if (/^\s*\[.+\]\s*$/.test(lines[i] ?? "")) {
+      insertAt = i;
+      break;
+    }
+    if (/^\s*hooks\s*=/.test(lines[i] ?? "")) {
+      lines[i] = "hooks = true";
+      return `${lines.join(`
+`).trimEnd()}
+`;
+    }
+  }
+  lines.splice(insertAt, 0, "hooks = true");
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function printClaudePreviewBlock() {
+  console.error("[agendex] refusing to install claude-code hook: hook-native plan review is not implemented yet.");
+  console.error("[agendex] Installing it now would cause Claude Code to deny ExitPlanMode permission requests.");
+  console.error(`[agendex] Re-run with ${CLAUDE_PREVIEW_FLAG} to opt in deliberately, or install codex/pi separately.`);
+}
+function printClaudePreviewWarning(dryRun) {
+  console.error("[agendex] WARNING: claude-code hook support is preview-only.");
+  console.error(dryRun ? "[agendex] This dry run describes a PermissionRequest hook that would deny ExitPlanMode until hook-native plan review ships." : "[agendex] The installed PermissionRequest hook will deny ExitPlanMode until hook-native plan review ships.");
+  console.error("[agendex] Remove it with: agendex hooks uninstall claude-code");
+}
+async function installClaude(scope, cliEntry, dryRun) {
+  const path = hooksJsonPath("claude-code", scope);
+  const config = mergeCommandHook({
+    config: readJsonFile(path),
+    event: "PermissionRequest",
+    matcher: "ExitPlanMode",
+    command: commandFor(cliEntry, "claude-code")
+  });
+  await writeWithBackup(path, `${JSON.stringify(config, null, 2)}
+`, dryRun);
+  return path;
+}
+async function installCodex(scope, cliEntry, dryRun) {
+  const configPath = codexConfigPath(scope);
+  const config = existsSync10(configPath) ? readFileSync7(configPath, "utf-8") : "";
+  await writeWithBackup(configPath, ensureCodexHooksEnabled(config), dryRun);
+  const hooksPath = hooksJsonPath("codex", scope);
+  const hookConfig = mergeCommandHook({
+    config: readJsonFile(hooksPath),
+    event: "Stop",
+    command: commandFor(cliEntry, "codex")
+  });
+  await writeWithBackup(hooksPath, `${JSON.stringify(hookConfig, null, 2)}
+`, dryRun);
+  return hooksPath;
+}
+function piExtensionSource(cliEntry) {
+  const command = commandFor(cliEntry, "pi");
+  return `import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+
+const REVIEW_COMMAND = ${JSON.stringify(command)};
+
+export default function agendexPiExtension(pi: ExtensionAPI): void {
+  pi.registerCommand('agendex-review-plan', {
+    description: 'Open an Agendex plan review gate for the current Pi session',
+    handler: async (_args, ctx) => {
+      ctx.ui.notify('Agendex review command registered. Native interactive review is handled by the Agendex CLI hook path.', 'info');
+      pi.sendMessage(
+        {
+          customType: 'agendex-review-command',
+          content: '[Agendex] Run this hook command from a shell-integrated Pi workflow when you need hook-native review JSON:
+' + REVIEW_COMMAND,
+          display: true,
+        },
+        { triggerTurn: false },
+      );
+    },
+  });
+
+  pi.registerCommand('agendex-annotate', {
+    description: 'Record Agendex annotation feedback in the active Pi session',
+    handler: async (args, ctx) => {
+      const feedback = args?.trim();
+      if (!feedback) {
+        ctx.ui.notify('Usage: /agendex-annotate <feedback>', 'warning');
+        return;
+      }
+      pi.sendMessage(
+        {
+          customType: 'agendex-annotation-feedback',
+          content: '[Agendex annotation feedback]
+' + feedback,
+          display: true,
+        },
+        { triggerTurn: true },
+      );
+    },
+  });
+
+  pi.on('session_start', async (_event, ctx) => {
+    ctx.ui.setStatus('agendex', 'agendex hooks');
+  });
+}
+`;
+}
+async function installPi(scope, cliEntry, dryRun) {
+  const path = hooksJsonPath("pi", scope);
+  await writeWithBackup(path, piExtensionSource(cliEntry), dryRun);
+  return path;
+}
+async function installAgent(agent, scope, cliEntry, dryRun) {
+  if (agent === "claude-code")
+    return await installClaude(scope, cliEntry, dryRun);
+  if (agent === "codex")
+    return await installCodex(scope, cliEntry, dryRun);
+  return await installPi(scope, cliEntry, dryRun);
+}
+async function uninstallJsonAgent(agent, scope, dryRun) {
+  const path = hooksJsonPath(agent, scope);
+  if (!existsSync10(path))
+    return path;
+  const updated = removeManagedHooks(readJsonFile(path));
+  await writeWithBackup(path, `${JSON.stringify(updated, null, 2)}
+`, dryRun);
+  return path;
+}
+async function uninstallPi(scope, dryRun) {
+  const path = hooksJsonPath("pi", scope);
+  if (hasManagedHook(path))
+    await removeWithBackup(path, dryRun);
+  return path;
+}
+async function uninstallAgent(agent, scope, dryRun) {
+  if (agent === "claude-code" || agent === "codex")
+    return await uninstallJsonAgent(agent, scope, dryRun);
+  return await uninstallPi(scope, dryRun);
+}
+function statusFor(agent, scope) {
+  const path = hooksJsonPath(agent, scope);
+  if (agent === "codex") {
+    const configPath = codexConfigPath(scope);
+    const configEnabled = existsSync10(configPath) && /hooks\s*=\s*true/.test(readFileSync7(configPath, "utf-8"));
+    const installed2 = configEnabled && hasManagedHook(path);
+    return {
+      agent,
+      installed: installed2,
+      path,
+      detail: installed2 ? "Stop hook installed and hooks feature enabled" : "Missing Stop hook or [features].hooks = true"
+    };
+  }
+  const installed = hasManagedHook(path);
+  return {
+    agent,
+    installed,
+    path,
+    detail: installed ? "Agendex hook installed" : "Agendex hook not installed"
+  };
+}
+function parseScope(args) {
+  const scopeIndex = args.indexOf("--scope");
+  const value = scopeIndex >= 0 ? args[scopeIndex + 1] : undefined;
+  if (value === "user" || value === "repo")
+    return value;
+  return args.includes("--user") ? "user" : "repo";
+}
+function parseAgent(value) {
+  if (!value)
+    return;
+  if (value === "all")
+    return "all";
+  if (value === "claude" || value === "claude-code")
+    return "claude-code";
+  if (value === "codex")
+    return "codex";
+  if (value === "pi")
+    return "pi";
+  return;
+}
+async function runHooksCommand(args, cliEntry) {
+  const subcommand = args.find((arg) => arg !== "hooks" && arg !== "--dev" && !arg.startsWith("--"));
+  const scope = parseScope(args);
+  if (!subcommand || subcommand === "status") {
+    const rows = SUPPORTED_AGENTS.map((agent) => statusFor(agent, scope));
+    for (const row of rows) {
+      console.log(`[agendex] ${row.agent}: ${row.installed ? "installed" : "not installed"} (${row.detail})`);
+      console.log(`  ${row.path}`);
+    }
+    return 0;
+  }
+  if (subcommand === "doctor") {
+    await runHooksCommand(["hooks", "status", "--scope", scope], cliEntry);
+    console.log("[agendex] restart the target agent after installing or changing hooks.");
+    return 0;
+  }
+  if (subcommand === "install") {
+    const agentArg = args.find((arg, index) => index > args.indexOf("install") && !arg.startsWith("--") && arg !== scope);
+    const parsed = parseAgent(agentArg);
+    if (!parsed) {
+      console.error(`[agendex] usage: agendex hooks install <claude-code|codex|pi|all> [--scope repo|user] [--dry-run] [${CLAUDE_PREVIEW_FLAG}]`);
+      return 1;
+    }
+    const dryRun = args.includes("--dry-run");
+    const preview = args.includes(CLAUDE_PREVIEW_FLAG);
+    const agents = parsed === "all" ? SUPPORTED_AGENTS : [parsed];
+    if (!preview && agents.includes("claude-code")) {
+      printClaudePreviewBlock();
+      return 1;
+    }
+    for (const agent of agents) {
+      if (agent === "claude-code")
+        printClaudePreviewWarning(dryRun);
+      const path = await installAgent(agent, scope, resolve7(cliEntry), dryRun);
+      console.log(`[agendex] ${dryRun ? "would install" : "installed"} ${agent} hook: ${path}`);
+    }
+    return 0;
+  }
+  if (subcommand === "uninstall") {
+    const agentArg = args.find((arg, index) => index > args.indexOf("uninstall") && !arg.startsWith("--") && arg !== scope);
+    const parsed = parseAgent(agentArg);
+    if (!parsed) {
+      console.error("[agendex] usage: agendex hooks uninstall <claude-code|codex|pi|all> [--scope repo|user] [--dry-run]");
+      return 1;
+    }
+    const dryRun = args.includes("--dry-run");
+    const agents = parsed === "all" ? SUPPORTED_AGENTS : [parsed];
+    for (const agent of agents) {
+      const path = await uninstallAgent(agent, scope, dryRun);
+      console.log(`[agendex] ${dryRun ? "would uninstall" : "uninstalled"} ${agent} hook: ${path}`);
+    }
+    return 0;
+  }
+  console.error(`[agendex] unknown hooks command: ${subcommand}`);
+  return 1;
+}
+async function runHookReviewCommand(args) {
+  if (!args.includes("--hook")) {
+    console.error("[agendex] review-plan currently supports hook mode only: agendex review-plan --hook --agent <agent>");
+    return 1;
+  }
+  console.error("[agendex] hook-native plan review is not implemented yet. Uninstall this hook or wait for the interactive review-session server before enabling it.");
+  return 1;
+}
+
 // src/sync.ts
 import { hostname as osHostname3 } from "node:os";
 async function syncAll(force = false) {
@@ -4970,17 +5448,17 @@ async function syncAll(force = false) {
 // src/upgrade.ts
 import { spawn as spawn3, spawnSync } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { dirname as dirname4, resolve as resolve7, sep as sep4 } from "node:path";
+import { dirname as dirname5, resolve as resolve8, sep as sep4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/version.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 // package.json
 var package_default = {
   name: "agendex-cli",
-  version: "0.18.0",
+  version: "1.1.0",
   description: "Agendex CLI for login, sync, and daemon workflows",
   homepage: "https://github.com/Tyru5/Agendex#readme",
   bugs: {
@@ -5024,14 +5502,14 @@ var package_default = {
 
 // src/version.ts
 var CLI_VERSION = package_default.version;
-var CACHE_FILE = process.env.AGENDEX_UPDATE_CACHE_FILE ?? join14(tmpdir(), ".agendex-update-cache.json");
+var CACHE_FILE = process.env.AGENDEX_UPDATE_CACHE_FILE ?? join15(tmpdir(), ".agendex-update-cache.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 var UPDATE_URL = process.env.AGENDEX_UPDATE_URL ?? "https://registry.npmjs.org/agendex-cli/latest";
 function readCache(current) {
   try {
-    if (!existsSync10(CACHE_FILE))
+    if (!existsSync11(CACHE_FILE))
       return null;
-    const { result, ts } = JSON.parse(readFileSync7(CACHE_FILE, "utf8"));
+    const { result, ts } = JSON.parse(readFileSync8(CACHE_FILE, "utf8"));
     if (Date.now() - ts > CACHE_TTL_MS)
       return null;
     return normalizeResult(result, current);
@@ -5100,12 +5578,12 @@ function isNewer(latest, current) {
 
 // src/upgrade.ts
 var PACKAGE_NAME = "agendex-cli";
-var moduleDir = dirname4(fileURLToPath2(import.meta.url));
+var moduleDir = dirname5(fileURLToPath2(import.meta.url));
 function getPackageRoot() {
   try {
-    return realpathSync2(resolve7(moduleDir, ".."));
+    return realpathSync2(resolve8(moduleDir, ".."));
   } catch {
-    return resolve7(moduleDir, "..");
+    return resolve8(moduleDir, "..");
   }
 }
 function detectPackageManager(packageRoot) {
@@ -5324,7 +5802,7 @@ function firstCommandToken(argv) {
   return;
 }
 var command = firstCommandToken(args) ?? "start";
-var cliEntry = resolve8(process.argv[1] ?? fileURLToPath3(import.meta.url));
+var cliEntry = resolve9(process.argv[1] ?? fileURLToPath3(import.meta.url));
 async function main() {
   const isInternal = args.includes("--daemon") || args.includes("--worker");
   if (command === "--version" || command === "-v") {
@@ -5339,6 +5817,8 @@ async function main() {
     "open",
     "view",
     "cleanup",
+    "hooks",
+    "review-plan",
     "add-dir",
     "remove-dir",
     "list-dirs",
@@ -5442,6 +5922,12 @@ async function main() {
       await syncAll(force);
       return 0;
     }
+    case "hooks": {
+      return await runHooksCommand(args, cliEntry);
+    }
+    case "review-plan": {
+      return await runHookReviewCommand(args);
+    }
     case "cleanup": {
       const config = loadConfig();
       if (!config?.cloudToken || !config?.convexUrl) {
@@ -5524,7 +6010,7 @@ async function main() {
         return 1;
       }
       const resolved = resolveCustomPlanDirPath(dirPath);
-      if (!existsSync11(resolved)) {
+      if (!existsSync12(resolved)) {
         writeStderr(`[agendex] path does not exist: ${resolved}`);
         return 1;
       }
@@ -5543,7 +6029,7 @@ async function main() {
         const { request } = await import("node:http");
         const body = JSON.stringify({ path: resolved });
         try {
-          const res = await new Promise((resolve9, reject) => {
+          const res = await new Promise((resolve10, reject) => {
             const req = request(`http://localhost:${port}/api/v1/plan-sources`, {
               method: "POST",
               headers: {
@@ -5557,7 +6043,7 @@ async function main() {
               res2.on("data", (chunk) => {
                 data += chunk;
               });
-              res2.on("end", () => resolve9({ status: res2.statusCode ?? 0, body: data }));
+              res2.on("end", () => resolve10({ status: res2.statusCode ?? 0, body: data }));
               res2.on("error", reject);
             });
             req.on("error", reject);
@@ -5707,6 +6193,10 @@ Usage:
   agendex view <url>   Open a shared plan URL in your browser
   agendex logout       Clear stored cloud token
   agendex configure    Select which agents/adapters to index
+  agendex hooks status Show Claude Code, Codex, and Pi hook status
+  agendex hooks install <agent|all>  Install hook integration (--preview required for claude-code)
+  agendex hooks uninstall <agent|all>  Remove managed Agendex hook entries
+  agendex review-plan --hook --agent <agent>  Hook-native plan review command
   agendex add-dir <path>  Add a custom directory to scan for plans
   agendex add-dir <path> --live  Add dir and notify running server immediately
   agendex remove-dir <path>  Remove a custom directory
@@ -5746,13 +6236,13 @@ function flushStream(stream) {
   if (stream.destroyed || !stream.writable) {
     return Promise.resolve();
   }
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     stream.write("", (error) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve9();
+      resolve10();
     });
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agendex-cli",
-  "version": "0.18.0",
+  "version": "1.1.0",
   "description": "Agendex CLI for login, sync, and daemon workflows",
   "homepage": "https://github.com/Tyru5/Agendex#readme",
   "repository": {