agendex-cli 0.11.0 → 0.13.0

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -44,6 +45,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -1057,8 +1059,8 @@ var init_cleanup = __esm(() => {
 
 // src/cli.ts
 import { spawn as spawn3 } from "node:child_process";
-import { writeSync } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync9, statSync as statSync2, writeSync } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../shared/src/adapters/catalog.ts
@@ -2198,7 +2200,7 @@ var activeAdapters = resolveAdapters(getDefaultAdapterIds());
 import { randomBytes } from "node:crypto";
 import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join7, resolve as resolve2 } from "node:path";
 
 // ../shared/src/setup/adapter-selection.ts
 init_dist2();
@@ -2288,6 +2290,37 @@ function normalizeAdapterIds(input) {
     return [];
   return sanitizeEnabledAdapterIds(input.filter((item) => typeof item === "string"));
 }
+function expandHomePath(p) {
+  if (p.startsWith("~/") || p === "~")
+    return join7(homedir7(), p.slice(1));
+  return p;
+}
+function resolveCustomPlanDirPath(userPath) {
+  const trimmed = userPath.trim();
+  if (!trimmed) {
+    throw new Error("Custom plan directory path must not be empty");
+  }
+  return resolve2(expandHomePath(trimmed));
+}
+function normalizeCustomPlanDirs(input) {
+  if (!Array.isArray(input))
+    return [];
+  const seen = new Set;
+  const result = [];
+  for (const item of input) {
+    if (typeof item !== "string")
+      continue;
+    const trimmed = item.trim();
+    if (!trimmed)
+      continue;
+    const normalized = resolveCustomPlanDirPath(trimmed);
+    if (seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
 function normalizeStoredConfig(raw) {
   if (!raw)
     return null;
@@ -2301,7 +2334,8 @@ function normalizeStoredConfig(raw) {
     cloudToken,
     convexUrl,
     deviceId,
-    enabledAdapters: normalizeAdapterIds(raw.enabledAdapters)
+    enabledAdapters: normalizeAdapterIds(raw.enabledAdapters),
+    customPlanDirs: normalizeCustomPlanDirs(raw.customPlanDirs)
   };
 }
 function loadConfig() {
@@ -2315,7 +2349,8 @@ function saveConfig(config) {
     cloudToken: config.cloudToken,
     convexUrl: config.convexUrl,
     deviceId: config.deviceId,
-    enabledAdapters: sanitizeEnabledAdapterIds(config.enabledAdapters)
+    enabledAdapters: sanitizeEnabledAdapterIds(config.enabledAdapters),
+    customPlanDirs: normalizeCustomPlanDirs(config.customPlanDirs)
   };
   writeFileSync(getConfigPath(), JSON.stringify(payload, null, 2));
 }
@@ -2332,7 +2367,8 @@ function loadOrCreateToken() {
   saveConfig({
     configVersion: 3,
     token,
-    enabledAdapters: existing?.enabledAdapters ?? []
+    enabledAdapters: existing?.enabledAdapters ?? [],
+    customPlanDirs: existing?.customPlanDirs ?? []
   });
   console.log(`
 [agendex] generated auth token: ${token}`);
@@ -2349,7 +2385,8 @@ function loadOrCreateDeviceId() {
     ...existing ?? {},
     configVersion: 3,
     deviceId,
-    enabledAdapters: existing?.enabledAdapters ?? []
+    enabledAdapters: existing?.enabledAdapters ?? [],
+    customPlanDirs: existing?.customPlanDirs ?? []
   });
   return deviceId;
 }
@@ -2388,7 +2425,8 @@ async function loadOrInitConfig(options = {}) {
     cloudToken: existing?.cloudToken,
     convexUrl: existing?.convexUrl,
     deviceId,
-    enabledAdapters
+    enabledAdapters,
+    customPlanDirs: existing?.customPlanDirs ?? []
   };
   saveConfig(nextConfig);
   return {
@@ -2403,7 +2441,7 @@ var CLI_DAEMON_STALE_AFTER_MS = CLI_DAEMON_HEARTBEAT_INTERVAL_MS * 5;
 import { existsSync as existsSync4, readdirSync as readdirSync3, statSync } from "node:fs";
 import { lstat, mkdir, readdir as readdir2, readFile as readFile6, stat as stat6, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { join as join8, resolve as resolve2, sep as sep2 } from "node:path";
+import { join as join8, resolve as resolve3, sep as sep2 } from "node:path";
 function getUserPlansDir() {
   return join8(getConfigDir(), "plans");
 }
@@ -2489,7 +2527,7 @@ async function walkDir(dir, depth = 0, seen = new Set) {
     return [];
   if (!existsSync4(dir))
     return [];
-  const real = resolve2(dir);
+  const real = resolve3(dir);
   if (seen.has(real))
     return [];
   seen.add(real);
@@ -2512,7 +2550,36 @@ async function walkDir(dir, depth = 0, seen = new Set) {
   } catch {}
   return files;
 }
-async function scanUserPlans() {
+async function parseGenericMarkdownPlan(filePath, extraMetadata) {
+  try {
+    const content = await readFile6(filePath, "utf-8");
+    const stats = await stat6(filePath);
+    let agent = (typeof extraMetadata.agentHint === "string" ? extraMetadata.agentHint : "") || "unknown";
+    const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (fmMatch) {
+      const agentLine = fmMatch[1]?.match(/^agent:\s*(.+)$/m);
+      if (agentLine?.[1])
+        agent = agentLine[1].trim();
+    }
+    const bodyContent = fmMatch ? content.slice(fmMatch[0].length) : content;
+    const titleMatch = bodyContent.match(/^#\s+(.+)/m);
+    const title = titleMatch?.[1]?.trim() || filePath.split("/").pop()?.replace(".md", "") || "Untitled";
+    return {
+      id: hashPath(filePath),
+      agent,
+      title,
+      content: bodyContent,
+      filePath,
+      format: "md",
+      createdAt: stats.birthtime,
+      updatedAt: stats.mtime,
+      metadata: extraMetadata
+    };
+  } catch {
+    return null;
+  }
+}
+async function scanUserPlans(into) {
   const userPlansDir = getUserPlansDir();
   if (!existsSync4(userPlansDir))
     return;
@@ -2520,55 +2587,91 @@ async function scanUserPlans() {
   for (const file of files) {
     if (!file.endsWith(".md"))
       continue;
-    try {
-      const content = await readFile6(file, "utf-8");
-      const stats = await stat6(file);
-      let agent = "unknown";
-      const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
-      if (fmMatch) {
-        const agentLine = fmMatch[1]?.match(/^agent:\s*(.+)$/m);
-        if (agentLine?.[1])
-          agent = agentLine[1].trim();
+    const plan = await parseGenericMarkdownPlan(file, { userCreated: true });
+    if (plan)
+      into.set(plan.id, plan);
+  }
+}
+function getCustomPlanDirs() {
+  return loadConfig()?.customPlanDirs ?? [];
+}
+function pathsOverlapFilesystemTree(a, b) {
+  const ra = resolve3(a);
+  const rb = resolve3(b);
+  if (ra === rb)
+    return true;
+  if (ra.startsWith(rb + sep2))
+    return true;
+  if (rb.startsWith(ra + sep2))
+    return true;
+  return false;
+}
+function overlapsAnyRoot(candidate, roots) {
+  const resolvedCandidate = resolve3(candidate);
+  for (const root of roots) {
+    if (pathsOverlapFilesystemTree(resolvedCandidate, root))
+      return true;
+  }
+  return false;
+}
+async function scanCustomPlanDirs(coveredPaths, into) {
+  const dirs = getCustomPlanDirs();
+  const userPlansDir = resolve3(getUserPlansDir());
+  for (const dir of dirs) {
+    const resolved = resolve3(dir);
+    if (overlapsAnyRoot(resolved, coveredPaths)) {
+      console.log(`[agendex] skipping custom dir (overlaps adapter / discovered coverage): ${dir}`);
+      continue;
+    }
+    if (pathsOverlapFilesystemTree(resolved, userPlansDir)) {
+      console.log(`[agendex] skipping custom dir (overlaps user plans): ${dir}`);
+      continue;
+    }
+    if (!existsSync4(dir)) {
+      console.log(`[agendex] skipping custom dir (not found): ${dir}`);
+      continue;
+    }
+    const files = await walkDir(dir);
+    const dirBasename = dir.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "custom";
+    let count = 0;
+    for (const file of files) {
+      if (!file.endsWith(".md"))
+        continue;
+      const plan = await parseGenericMarkdownPlan(file, {
+        source: "custom-dir",
+        customDir: dir,
+        agentHint: dirBasename
+      });
+      if (plan) {
+        into.set(plan.id, plan);
+        count++;
       }
-      const bodyContent = fmMatch ? content.slice(fmMatch[0].length) : content;
-      const titleMatch = bodyContent.match(/^#\s+(.+)/m);
-      const title = titleMatch?.[1]?.trim() || file.split("/").pop()?.replace(".md", "") || "Untitled";
-      const plan = {
-        id: hashPath(file),
-        agent,
-        title,
-        content: bodyContent,
-        filePath: file,
-        format: "md",
-        createdAt: stats.birthtime,
-        updatedAt: stats.mtime,
-        metadata: { userCreated: true }
-      };
-      store.set(plan.id, plan);
-    } catch {}
+    }
+    console.log(`[agendex] custom dir: ${dir} (${count} plans)`);
   }
 }
 async function scan() {
   const adapters = getActiveAdapters();
-  store.clear();
+  const next = new Map;
   const coveredPaths = new Set;
   for (const adapter of adapters) {
     for (const searchPath of adapter.getSearchPaths()) {
-      coveredPaths.add(resolve2(searchPath));
+      coveredPaths.add(resolve3(searchPath));
       const files = await walkDir(searchPath);
       for (const file of files) {
         if (!adapter.matches(file))
           continue;
         const plans = await adapter.parse(file);
         for (const plan of plans) {
-          store.set(plan.id, plan);
+          next.set(plan.id, plan);
         }
       }
     }
   }
   const discovered = discoverProjectPlanDirs();
   for (const { dir, agent } of discovered) {
-    if (coveredPaths.has(resolve2(dir)))
+    const resolvedDir = resolve3(dir);
+    if (coveredPaths.has(resolvedDir))
       continue;
     const adapter = adapters.find((a) => a.agent === agent);
     if (!adapter)
@@ -2579,12 +2682,15 @@ async function scan() {
         continue;
       const plans = await adapter.parse(file);
       for (const plan of plans) {
-        store.set(plan.id, plan);
+        next.set(plan.id, plan);
       }
     }
+    coveredPaths.add(resolvedDir);
     console.log(`[agendex] discovered project plans: ${dir}`);
   }
-  await scanUserPlans();
+  await scanUserPlans(next);
+  await scanCustomPlanDirs(coveredPaths, next);
+  store = next;
   notifyPlansChanged();
   console.log(`[agendex] indexed ${store.size} plans from ${adapters.length} adapters`);
 }
@@ -2593,13 +2699,13 @@ function getAll() {
 }
 async function rescanFile(filePath) {
   const adapters = getActiveAdapters();
-  const normalized = resolve2(filePath);
+  const normalized = resolve3(filePath);
   for (const adapter of adapters) {
     if (!adapter.matches(filePath))
       continue;
-    const discoveredDirs = discoverProjectPlanDirs().filter((d2) => d2.agent === adapter.agent).map((d2) => resolve2(d2.dir));
+    const discoveredDirs = discoverProjectPlanDirs().filter((d2) => d2.agent === adapter.agent).map((d2) => resolve3(d2.dir));
     const allSearchPaths = [
-      ...adapter.getSearchPaths().map((sp) => resolve2(sp)),
+      ...adapter.getSearchPaths().map((sp) => resolve3(sp)),
       ...discoveredDirs
     ];
     const isInSearchPath = allSearchPaths.some((sp) => normalized.startsWith(sp + sep2) || normalized === sp);
@@ -2612,18 +2718,58 @@ async function rescanFile(filePath) {
     notifyPlansChanged();
     return plans;
   }
+  const userPlansDir = resolve3(getUserPlansDir());
+  if (normalized.endsWith(".md") && (normalized.startsWith(userPlansDir + sep2) || normalized === userPlansDir)) {
+    const plan = await parseGenericMarkdownPlan(filePath, { userCreated: true });
+    if (plan) {
+      store.set(plan.id, plan);
+      notifyPlansChanged();
+      return [plan];
+    }
+  }
+  if (normalized.endsWith(".md")) {
+    const customDirs = getCustomPlanDirs();
+    for (const dir of customDirs) {
+      const resolvedDir = resolve3(dir);
+      if (normalized.startsWith(resolvedDir + sep2) || normalized === resolvedDir) {
+        const plan = await parseGenericMarkdownPlan(filePath, {
+          source: "custom-dir",
+          customDir: dir
+        });
+        if (plan) {
+          store.set(plan.id, plan);
+          notifyPlansChanged();
+          return [plan];
+        }
+      }
+    }
+  }
   return [];
 }
 // ../shared/src/services/watcher.ts
 import { existsSync as existsSync5, watch } from "node:fs";
-import { join as join9, resolve as resolve3 } from "node:path";
+import { join as join9, resolve as resolve4 } from "node:path";
 var debounceTimer = null;
 var pendingFiles = new Set;
+var activeWatchers = [];
+function closeAllWatchers() {
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+  pendingFiles.clear();
+  for (const watcher of activeWatchers) {
+    try {
+      watcher.close();
+    } catch {}
+  }
+  activeWatchers.length = 0;
+}
 function watchDir(dir, matchFn, onChange) {
   if (!existsSync5(dir))
     return;
   try {
-    watch(dir, { recursive: true }, async (_event, filename) => {
+    const watcher = watch(dir, { recursive: true }, async (_event, filename) => {
       if (!filename)
         return;
       const fullPath = join9(dir, filename);
@@ -2643,27 +2789,51 @@ function watchDir(dir, matchFn, onChange) {
         onChange?.(allPlans);
       }, 300);
     });
+    activeWatchers.push(watcher);
     console.log(`[agendex] watching ${dir}`);
   } catch {}
 }
 function startWatching(onChange) {
+  closeAllWatchers();
+  setupWatchers(onChange);
+}
+function stopWatching() {
+  closeAllWatchers();
+}
+function setupWatchers(onChange) {
   const adapters = getActiveAdapters();
   const watchedPaths = new Set;
   for (const adapter of adapters) {
     for (const watchPath of adapter.getWatchPaths()) {
-      watchedPaths.add(resolve3(watchPath));
+      watchedPaths.add(resolve4(watchPath));
       watchDir(watchPath, (f) => adapter.matches(f), onChange);
     }
   }
   const discovered = discoverProjectPlanDirs();
   for (const { dir, agent } of discovered) {
-    if (watchedPaths.has(resolve3(dir)))
+    if (watchedPaths.has(resolve4(dir)))
       continue;
     const adapter = adapters.find((a) => a.agent === agent);
     if (!adapter)
       continue;
+    watchedPaths.add(resolve4(dir));
     watchDir(dir, (f) => adapter.matches(f), onChange);
   }
+  const customDirs = getCustomPlanDirs();
+  for (const dir of customDirs) {
+    const resolvedCustom = resolve4(dir);
+    let overlaps = false;
+    for (const watched of watchedPaths) {
+      if (pathsOverlapFilesystemTree(resolvedCustom, watched)) {
+        overlaps = true;
+        break;
+      }
+    }
+    if (overlaps)
+      continue;
+    watchedPaths.add(resolvedCustom);
+    watchDir(dir, (f) => f.endsWith(".md"), onChange);
+  }
 }
 // src/api.ts
 import { request as httpRequest } from "node:http";
@@ -2853,7 +3023,7 @@ function requestText(urlString, options) {
   if (options.body) {
     headers["Content-Length"] = String(Buffer.byteLength(options.body));
   }
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const req = request(url, {
       agent: false,
       headers,
@@ -2865,7 +3035,7 @@ function requestText(urlString, options) {
         body += chunk;
       });
       res.on("end", () => {
-        resolve4({
+        resolve5({
           status: res.statusCode ?? 0,
           body
         });
@@ -2979,7 +3149,8 @@ async function login(siteUrlOverride) {
     token: existing?.token,
     cloudToken: callback.token,
     convexUrl: callback.convexUrl,
-    enabledAdapters: existing?.enabledAdapters ?? []
+    enabledAdapters: existing?.enabledAdapters ?? [],
+    customPlanDirs: existing?.customPlanDirs ?? []
   };
   saveConfig(config);
   console.log(`[agendex] Logged in successfully!`);
@@ -2996,7 +3167,8 @@ function logout() {
     token: existing.token,
     cloudToken: undefined,
     convexUrl: undefined,
-    enabledAdapters: existing.enabledAdapters
+    enabledAdapters: existing.enabledAdapters,
+    customPlanDirs: existing.customPlanDirs
   };
   saveConfig(config);
   console.log("[agendex] Logged out. Cloud token removed.");
@@ -3007,14 +3179,14 @@ async function startCallbackServer() {
   let timeout;
   let settle;
   let fail;
-  const result = new Promise((resolve4, reject) => {
-    settle = resolve4;
+  const result = new Promise((resolve5, reject) => {
+    settle = resolve5;
     fail = reject;
   });
   const finish = (value) => {
     if (!settle || !fail)
       return;
-    const resolve4 = settle;
+    const resolve5 = settle;
     const reject = fail;
     settle = undefined;
     fail = undefined;
@@ -3031,7 +3203,7 @@ async function startCallbackServer() {
       reject(value);
       return;
     }
-    resolve4(value);
+    resolve5(value);
   };
   server.on("request", (req, res) => {
     const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -3065,8 +3237,8 @@ async function startCallbackServer() {
       sockets.delete(socket);
     });
   });
-  await new Promise((resolve4, reject) => {
-    server.listen(0, "127.0.0.1", () => resolve4());
+  await new Promise((resolve5, reject) => {
+    server.listen(0, "127.0.0.1", () => resolve5());
     server.once("error", reject);
   });
   server.once("error", (error) => {
@@ -3146,7 +3318,7 @@ function spawnBrowser(command, args, options = {}) {
 
 // src/daemon.ts
 import { spawn as spawn2 } from "node:child_process";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/sync-cache.ts
@@ -3309,6 +3481,7 @@ async function runWorker() {
   });
   console.log(`[agendex] daemon running. Watching for file changes...`);
   async function gracefulShutdown() {
+    stopWatching();
     await sendShutdown();
     process.exit(0);
   }
@@ -3332,17 +3505,17 @@ async function startSupervisor() {
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  const scriptPath = resolve4(process.argv[1] ?? fileURLToPath(new URL("./cli.ts", import.meta.url)));
+  const scriptPath = resolve5(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 exitCode = await new Promise((resolve5) => {
-      workerProc?.once("exit", (code) => resolve5(code));
+    const exitCode = await new Promise((resolve6) => {
+      workerProc?.once("exit", (code) => resolve6(code));
       workerProc?.once("error", (error) => {
         console.error("[agendex] failed to spawn worker:", error);
-        resolve5(1);
+        resolve6(1);
       });
     });
     workerProc = null;
@@ -3421,7 +3594,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "agendex-cli",
-  version: "0.11.0",
+  version: "0.13.0",
   description: "Agendex CLI for login, sync, and daemon workflows",
   homepage: "https://github.com/Tyru5/Agendex#readme",
   repository: {
@@ -3568,7 +3741,7 @@ function firstCommandToken(argv) {
   return;
 }
 var command = firstCommandToken(args) ?? "start";
-var cliEntry = resolve5(process.argv[1] ?? fileURLToPath2(import.meta.url));
+var cliEntry = resolve6(process.argv[1] ?? fileURLToPath2(import.meta.url));
 async function main() {
   const isInternal = args.includes("--daemon") || args.includes("--worker");
   if (command === "--version" || command === "-v") {
@@ -3583,6 +3756,9 @@ async function main() {
     "open",
     "view",
     "cleanup",
+    "add-dir",
+    "remove-dir",
+    "list-dirs",
     "help",
     "--help",
     "-h"
@@ -3758,6 +3934,112 @@ async function main() {
       }
       return 0;
     }
+    case "add-dir": {
+      const dirPath = args.find((a) => a !== "add-dir" && a !== "--dev" && !a.startsWith("--"));
+      if (!dirPath || !dirPath.trim()) {
+        writeStderr("[agendex] usage: agendex add-dir <path>");
+        return 1;
+      }
+      const resolved = resolveCustomPlanDirPath(dirPath);
+      if (!existsSync9(resolved)) {
+        writeStderr(`[agendex] path does not exist: ${resolved}`);
+        return 1;
+      }
+      if (!statSync2(resolved).isDirectory()) {
+        writeStderr(`[agendex] path is not a directory: ${resolved}`);
+        return 1;
+      }
+      if (args.includes("--live")) {
+        const cfg = loadConfig();
+        const token = cfg?.token;
+        if (!token) {
+          writeStderr("[agendex] no local token found in config — is the server running?");
+          return 1;
+        }
+        const port = process.env.PORT ?? "4890";
+        const { request } = await import("node:http");
+        const body = JSON.stringify({ path: resolved });
+        try {
+          const res = await new Promise((resolve7, reject) => {
+            const req = request(`http://localhost:${port}/api/v1/plan-sources`, {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+                "Content-Length": String(Buffer.byteLength(body))
+              }
+            }, (res2) => {
+              let data = "";
+              res2.setEncoding("utf8");
+              res2.on("data", (chunk) => {
+                data += chunk;
+              });
+              res2.on("end", () => resolve7({ status: res2.statusCode ?? 0, body: data }));
+              res2.on("error", reject);
+            });
+            req.on("error", reject);
+            req.write(body);
+            req.end();
+          });
+          if (res.status >= 200 && res.status < 300) {
+            writeStdout(`[agendex] added custom plan dir: ${resolved}`);
+            writeStdout(`[agendex] server notified — scanning + watching now`);
+          } else {
+            writeStderr(`[agendex] server returned ${res.status}: ${res.body}`);
+            return 1;
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          writeStderr(`[agendex] could not reach local server on port ${port}: ${msg}`);
+          return 1;
+        }
+      } else {
+        const cfg = loadConfig();
+        const currentDirs = cfg?.customPlanDirs ?? [];
+        const updated = normalizeCustomPlanDirs([...currentDirs, resolved]);
+        saveConfig({
+          ...cfg ?? { configVersion: 3, enabledAdapters: [] },
+          customPlanDirs: updated
+        });
+        writeStdout(`[agendex] added custom plan dir: ${resolved}`);
+        writeStdout(`[agendex] daemon will pick up the change automatically`);
+      }
+      return 0;
+    }
+    case "remove-dir": {
+      const dirPath = args.find((a) => a !== "remove-dir" && a !== "--dev" && !a.startsWith("--"));
+      if (!dirPath || !dirPath.trim()) {
+        writeStderr("[agendex] usage: agendex remove-dir <path>");
+        return 1;
+      }
+      const resolved = resolveCustomPlanDirPath(dirPath);
+      const cfg = loadConfig();
+      const currentDirs = cfg?.customPlanDirs ?? [];
+      const updated = currentDirs.filter((d2) => d2 !== resolved);
+      if (updated.length === currentDirs.length) {
+        writeStderr(`[agendex] directory not in custom plan dirs: ${resolved}`);
+        return 1;
+      }
+      saveConfig({
+        ...cfg ?? { configVersion: 3, enabledAdapters: [] },
+        customPlanDirs: updated
+      });
+      writeStdout(`[agendex] removed custom plan dir: ${resolved}`);
+      return 0;
+    }
+    case "list-dirs": {
+      const cfg = loadConfig();
+      const dirs = cfg?.customPlanDirs ?? [];
+      if (dirs.length === 0) {
+        writeStdout("[agendex] no custom plan directories configured");
+      } else {
+        writeStdout(`[agendex] custom plan directories (${dirs.length}):`);
+        for (const dir of dirs) {
+          writeStdout(`  - ${dir}`);
+        }
+      }
+      return 0;
+    }
     case "status": {
       const config = loadConfig();
       const pidInfo = readPidInfo();
@@ -3768,6 +4050,11 @@ async function main() {
       writeStdout(`[agendex] Cloud token: ${config?.cloudToken ? "set" : "not set"}`);
       writeStdout(`[agendex] Convex URL: ${config?.convexUrl ?? "not set"}`);
       writeStdout(`[agendex] Enabled adapters: ${config?.enabledAdapters.join(", ") || "none"}`);
+      const customDirs = config?.customPlanDirs ?? [];
+      writeStdout(`[agendex] Custom plan dirs: ${customDirs.length > 0 ? customDirs.length : "none"}`);
+      for (const dir of customDirs) {
+        writeStdout(`  - ${dir}`);
+      }
       writeStdout(`[agendex] Daemon: ${running ? `running (PID ${pid})` : "not running"}`);
       if (running && pidInfo?.startedAtMs) {
         writeStdout(`[agendex] Uptime: ${formatDuration(Date.now() - pidInfo.startedAtMs)}`);
@@ -3832,6 +4119,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 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
+  agendex list-dirs    List custom plan directories
   agendex sync         One-shot scan + sync to cloud (skips unchanged plans)
   agendex sync --force Re-sync all plans, ignoring cache
   agendex cleanup      Interactively remove cloud daemons
@@ -3865,13 +4156,13 @@ function flushStream(stream) {
   if (stream.destroyed || !stream.writable) {
     return Promise.resolve();
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     stream.write("", (error) => {
       if (error) {
         reject(error);
         return;
       }
-      resolve6();
+      resolve7();
     });
   });
 }

package/package.json

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