open-walnut 0.3.0

package/dist/integrations/ms-todo/index.js

@@ -0,0 +1,4672 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/constants.ts
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+function resolveOpenWalnutHome() {
+  const envHome = process.env.OPEN_WALNUT_HOME;
+  const productionHome = path.join(os.homedir(), ".open-walnut");
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (isTestEnv) {
+    if (envHome && envHome !== productionHome && !envHome.startsWith(productionHome + path.sep)) {
+      assertNotProductionPath(envHome);
+      return envHome;
+    }
+    const testHome = path.join(os.tmpdir(), `open-walnut-test-${process.pid}`);
+    process.env.OPEN_WALNUT_HOME = testHome;
+    return testHome;
+  }
+  if (!envHome) return productionHome;
+  if (process.argv.includes("--_ephemeral-child")) return envHome;
+  if (isEphemeralTmpDir(envHome)) {
+    process.stderr.write(
+      `WARNING: OPEN_WALNUT_HOME=${envHome} looks like a leaked ephemeral temp dir.
+  Overriding to ${productionHome}. (Only --_ephemeral-child processes may use one.)
+`
+    );
+    process.env.OPEN_WALNUT_HOME = productionHome;
+    return productionHome;
+  }
+  return envHome;
+}
+function assertNotProductionPath(inputPath) {
+  const isTestEnv = !!(process.env.VITEST || process.env.VITEST_WORKER_ID || process.env.NODE_ENV === "test");
+  if (!isTestEnv) return;
+  const resolved = path.resolve(inputPath);
+  const prodHome = path.join(os.homedir(), ".open-walnut");
+  if (resolved === prodHome || resolved.startsWith(prodHome + path.sep)) {
+    throw new Error(
+      `SAFETY: Test process attempted to use production path: ${resolved}
+  This would destroy real user data in ~/.open-walnut/.
+  Set OPEN_WALNUT_HOME to a temp directory or let constants.ts auto-assign one.`
+    );
+  }
+}
+function isEphemeralTmpDir(inputPath) {
+  if (!/[\\/]open-walnut-[^\\/]+$/.test(inputPath)) return false;
+  const tmpDirs = /* @__PURE__ */ new Set();
+  tmpDirs.add(os.tmpdir());
+  try {
+    tmpDirs.add(fs.realpathSync(os.tmpdir()));
+  } catch {
+  }
+  try {
+    tmpDirs.add(fs.realpathSync("/tmp"));
+  } catch {
+  }
+  const parent = path.dirname(path.resolve(inputPath));
+  if (tmpDirs.has(parent)) return true;
+  try {
+    return tmpDirs.has(fs.realpathSync(parent));
+  } catch {
+    return false;
+  }
+}
+function agentMemoryDir(agentId) {
+  if (!agentId || agentId === "general") return WALNUT_HOME;
+  return path.join(MEMORY_DIR, "agents", agentId);
+}
+var WALNUT_HOME, IS_EPHEMERAL, CLOUD_MODE, TASKS_DIR, TASKS_FILE, ARCHIVE_DIR, MEMORY_DIR, SESSIONS_DIR, PROJECTS_DIR, CONFIG_FILE, SYNC_DIR, PLUGIN_STORES_DIR, SESSIONS_FILE, CLAUDE_HOME, HISTORY_CACHE_DIR, PROJECTION_CACHE_DIR, TRANSCRIPT_CACHE_DIR, TASK_QUEUE_DIR, HOST_MODEL_CATALOG_FILE, HOOK_LOG_FILE, DAILY_DIR, MEMORY_FILE, USER_FILE, LEGACY_MEMORY_FILE, PROJECTS_MEMORY_DIR, CHAT_HISTORY_FILE, CONVERSATIONS_DIR, GLOBAL_SKILLS_DIR, SKILL_SETTINGS_FILE, CLAUDE_SKILLS_DIR, CLAUDE_SETTINGS_FILE, CLAUDE_PLUGINS_DIR, CLAUDE_CREDENTIALS_FILE, CRON_FILE, USAGE_DB_FILE, LOG_DIR, SESSION_STREAMS_DIR, DTACH_SOCKET_DIR, SESSION_QUEUE_FILE, IMAGES_DIR, REMOTE_IMAGES_DIR, PASTES_DIR, HEARTBEAT_FILE, COMMANDS_DIR, BUILTIN_COMMANDS_DIR, BUILTIN_SKILLS_DIR, FREQUENT_DIRS_FILE, MENTION_DIRS_FILE, NOTES_DIR, GLOBAL_NOTES_FILE, NOTES_AGENTS_FILE, NOTES_CLAUDE_FILE, REPOSITORIES_DIR, REPOS_MEMORY_DIR, TOPICS_DIR, COMPACTION_DIR, MEMORY_INDEX_FILE, WORKING_MEMORY_FILE, TIMELINE_DIR, CONFIG_SHARE_DIR, UI_PREFS_FILE, STT_VOCAB_FILE, TMP_DIR, RECORDINGS_DIR, LOG_PREFIX, DAEMON_BINARIES_DIR, WALNUT_INSTALL_DIR;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    WALNUT_HOME = resolveOpenWalnutHome();
+    IS_EPHEMERAL = process.argv.includes("--_ephemeral-child");
+    CLOUD_MODE = process.env.WALNUT_CLOUD_MODE === "1";
+    TASKS_DIR = path.join(WALNUT_HOME, "tasks");
+    TASKS_FILE = path.join(TASKS_DIR, "tasks.json");
+    ARCHIVE_DIR = path.join(TASKS_DIR, "archive");
+    MEMORY_DIR = path.join(WALNUT_HOME, "memory");
+    SESSIONS_DIR = path.join(MEMORY_DIR, "sessions");
+    PROJECTS_DIR = path.join(MEMORY_DIR, "projects");
+    CONFIG_FILE = path.join(WALNUT_HOME, "config.yaml");
+    SYNC_DIR = path.join(WALNUT_HOME, "sync");
+    PLUGIN_STORES_DIR = path.join(WALNUT_HOME, "plugin-stores");
+    SESSIONS_FILE = path.join(WALNUT_HOME, "sessions.json");
+    CLAUDE_HOME = path.join(os.homedir(), ".claude");
+    HISTORY_CACHE_DIR = path.join(WALNUT_HOME, "cache", "history");
+    PROJECTION_CACHE_DIR = path.join(WALNUT_HOME, "cache", "projections");
+    TRANSCRIPT_CACHE_DIR = path.join(WALNUT_HOME, "cache", "transcripts");
+    TASK_QUEUE_DIR = path.join(WALNUT_HOME, "cache", "task-queue");
+    HOST_MODEL_CATALOG_FILE = path.join(WALNUT_HOME, "cache", "host-model-catalogs.json");
+    HOOK_LOG_FILE = path.join(WALNUT_HOME, "hook-errors.log");
+    DAILY_DIR = path.join(MEMORY_DIR, "daily");
+    MEMORY_FILE = path.join(MEMORY_DIR, "MEMORY.md");
+    USER_FILE = path.join(MEMORY_DIR, "USER.md");
+    LEGACY_MEMORY_FILE = path.join(WALNUT_HOME, "MEMORY.md");
+    PROJECTS_MEMORY_DIR = path.join(MEMORY_DIR, "projects");
+    CHAT_HISTORY_FILE = path.join(WALNUT_HOME, "chat-history.json");
+    CONVERSATIONS_DIR = path.join(WALNUT_HOME, "conversations");
+    GLOBAL_SKILLS_DIR = path.join(WALNUT_HOME, "skills");
+    SKILL_SETTINGS_FILE = path.join(WALNUT_HOME, "skill-settings.json");
+    CLAUDE_SKILLS_DIR = path.join(CLAUDE_HOME, "skills");
+    CLAUDE_SETTINGS_FILE = path.join(CLAUDE_HOME, "settings.json");
+    CLAUDE_PLUGINS_DIR = path.join(CLAUDE_HOME, "plugins");
+    CLAUDE_CREDENTIALS_FILE = path.join(CLAUDE_HOME, ".credentials.json");
+    CRON_FILE = path.join(WALNUT_HOME, "cron-jobs.json");
+    USAGE_DB_FILE = path.join(WALNUT_HOME, "usage.sqlite");
+    LOG_DIR = process.env.WALNUT_DAEMON_DIR || "/tmp/open-walnut";
+    SESSION_STREAMS_DIR = path.join(LOG_DIR, "streams");
+    DTACH_SOCKET_DIR = path.join(LOG_DIR, "term");
+    SESSION_QUEUE_FILE = path.join(WALNUT_HOME, "session-message-queue.json");
+    IMAGES_DIR = path.join(LOG_DIR, "images");
+    REMOTE_IMAGES_DIR = path.join(IMAGES_DIR, "remote");
+    PASTES_DIR = path.join(LOG_DIR, "pastes");
+    HEARTBEAT_FILE = path.join(WALNUT_HOME, "HEARTBEAT.md");
+    COMMANDS_DIR = path.join(WALNUT_HOME, "commands");
+    BUILTIN_COMMANDS_DIR = (() => {
+      let dir = path.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, "data", "slash-commands");
+        try {
+          if (fs.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path.dirname(dir);
+      }
+      return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "slash-commands");
+    })();
+    BUILTIN_SKILLS_DIR = (() => {
+      let dir = path.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, "data", "skills");
+        try {
+          if (fs.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path.dirname(dir);
+      }
+      return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "data", "skills");
+    })();
+    FREQUENT_DIRS_FILE = path.join(WALNUT_HOME, "frequent-directories.json");
+    MENTION_DIRS_FILE = path.join(WALNUT_HOME, "mention-directories.json");
+    NOTES_DIR = path.join(WALNUT_HOME, "notes");
+    GLOBAL_NOTES_FILE = path.join(NOTES_DIR, "global-notes.md");
+    NOTES_AGENTS_FILE = path.join(NOTES_DIR, "AGENTS.md");
+    NOTES_CLAUDE_FILE = path.join(NOTES_DIR, "CLAUDE.md");
+    REPOSITORIES_DIR = path.join(WALNUT_HOME, "repositories");
+    REPOS_MEMORY_DIR = path.join(GLOBAL_SKILLS_DIR, "repos");
+    TOPICS_DIR = path.join(MEMORY_DIR, "topics");
+    COMPACTION_DIR = path.join(MEMORY_DIR, "compaction");
+    MEMORY_INDEX_FILE = path.join(MEMORY_DIR, "index.md");
+    WORKING_MEMORY_FILE = path.join(MEMORY_DIR, "working-memory.md");
+    TIMELINE_DIR = path.join(WALNUT_HOME, "timeline");
+    CONFIG_SHARE_DIR = path.join(WALNUT_HOME, "config", "share");
+    UI_PREFS_FILE = path.join(CONFIG_SHARE_DIR, "ui-prefs.json");
+    STT_VOCAB_FILE = path.join(CONFIG_SHARE_DIR, "stt-vocab.txt");
+    TMP_DIR = path.join(WALNUT_HOME, "tmp");
+    RECORDINGS_DIR = path.join(TMP_DIR, "recordings");
+    LOG_PREFIX = "open-walnut-";
+    DAEMON_BINARIES_DIR = (() => {
+      let dir = path.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 5; i++) {
+        const candidate = path.join(dir, "dist", "daemon-binaries");
+        try {
+          if (fs.statSync(candidate).isDirectory()) return candidate;
+        } catch {
+        }
+        dir = path.dirname(dir);
+      }
+      return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dist", "daemon-binaries");
+    })();
+    WALNUT_INSTALL_DIR = (() => {
+      let dir = path.dirname(fileURLToPath(import.meta.url));
+      for (let i = 0; i < 6; i++) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+          if (pkg.name === "open-walnut" && fs.statSync(path.join(dir, ".git")).isDirectory()) return dir;
+        } catch {
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+      return null;
+    })();
+  }
+});
+
+// src/logging/redact.ts
+function redactSensitiveText(text) {
+  let result = text;
+  for (const { re, replacement } of patterns) {
+    result = result.replace(re, replacement);
+  }
+  return result;
+}
+var REDACTED, patterns;
+var init_redact = __esm({
+  "src/logging/redact.ts"() {
+    "use strict";
+    REDACTED = "[REDACTED]";
+    patterns = [
+      // PEM private key blocks (multiline)
+      {
+        re: /-----BEGIN\s[\w\s]*PRIVATE KEY-----[\s\S]*?-----END\s[\w\s]*PRIVATE KEY-----/g,
+        replacement: REDACTED
+      },
+      // Bearer tokens: Authorization: Bearer <token>
+      {
+        re: /(Bearer\s+)\S+/gi,
+        replacement: `$1${REDACTED}`
+      },
+      // OpenAI / Anthropic style keys: sk-... (at least 20 chars after prefix)
+      {
+        re: /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+        replacement: REDACTED
+      },
+      // AWS access key IDs: AKIA...
+      {
+        re: /\bAKIA[A-Z0-9]{12,}\b/g,
+        replacement: REDACTED
+      },
+      // AWS secret access key in key=value form
+      {
+        re: /(aws_secret_access_key\s*[=:]\s*)\S+/gi,
+        replacement: `$1${REDACTED}`
+      },
+      // AWS session token in key=value form
+      {
+        re: /(aws_session_token\s*[=:]\s*)\S+/gi,
+        replacement: `$1${REDACTED}`
+      },
+      // Credentials in URL userinfo: https://user:secret@host/...
+      // Motivating shape: execSync embeds the whole command in error.message, so a
+      // failed `git remote add origin https://walnut:<device-token>@host/git/data`
+      // otherwise logs the cloud companion's long-lived credential verbatim.
+      {
+        re: /(https?:\/\/[^/\s:@]+:)[^@/\s]+@/gi,
+        replacement: `$1${REDACTED}@`
+      },
+      // Generic secrets: password=, secret=, token=, api_key=, apikey=
+      {
+        re: /((?:password|secret|token|api_key|apikey)\s*[=:]\s*)\S+/gi,
+        replacement: `$1${REDACTED}`
+      }
+    ];
+  }
+});
+
+// src/logging/logger.ts
+import fs2 from "fs";
+import fsp from "fs/promises";
+import path2 from "path";
+function ensureLogDir() {
+  if (dirEnsured) return;
+  try {
+    fs2.mkdirSync(LOG_DIR, { recursive: true });
+    dirEnsured = true;
+  } catch {
+  }
+}
+function todayFileName() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${LOG_PREFIX}${yyyy}-${mm}-${dd}.log`;
+}
+function logFilePath() {
+  return path2.join(LOG_DIR, todayFileName());
+}
+function startFlushTimer() {
+  if (flushTimer) return;
+  flushTimer = setInterval(() => {
+    void flushLogBuffer();
+  }, FLUSH_INTERVAL_MS);
+  if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+    flushTimer.unref();
+  }
+}
+async function flushLogBuffer() {
+  if (flushing || buffer.length === 0) return;
+  flushing = true;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    await fsp.appendFile(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  } finally {
+    flushing = false;
+  }
+}
+function flushLogBufferSync() {
+  if (buffer.length === 0) return;
+  const batch = buffer;
+  buffer = [];
+  try {
+    ensureLogDir();
+    fs2.appendFileSync(logFilePath(), batch.join(""), "utf-8");
+  } catch {
+  }
+}
+function writeLogEntry(entry) {
+  const line = redactSensitiveText(JSON.stringify(entry)) + "\n";
+  buffer.push(line);
+  startFlushTimer();
+}
+var dirEnsured, FLUSH_INTERVAL_MS, buffer, flushTimer, flushing;
+var init_logger = __esm({
+  "src/logging/logger.ts"() {
+    "use strict";
+    init_constants();
+    init_redact();
+    dirEnsured = false;
+    FLUSH_INTERVAL_MS = 2e3;
+    buffer = [];
+    flushTimer = null;
+    flushing = false;
+    process.on("beforeExit", flushLogBufferSync);
+    process.on("exit", flushLogBufferSync);
+  }
+});
+
+// src/logging/levels.ts
+function resolveConfiguredLevel() {
+  const raw = process.env.WALNUT_LOG_LEVEL?.toLowerCase().trim();
+  if (raw && raw in LOG_LEVEL_ORDER) return raw;
+  return DEFAULT_LEVEL;
+}
+function shouldLog(messageLevel, configuredLevel = CONFIGURED_LOG_LEVEL) {
+  return LOG_LEVEL_ORDER[messageLevel] >= LOG_LEVEL_ORDER[configuredLevel];
+}
+var LOG_LEVEL_ORDER, DEFAULT_LEVEL, CONFIGURED_LOG_LEVEL;
+var init_levels = __esm({
+  "src/logging/levels.ts"() {
+    "use strict";
+    LOG_LEVEL_ORDER = {
+      trace: 0,
+      debug: 1,
+      info: 2,
+      warn: 3,
+      error: 4,
+      fatal: 5
+    };
+    DEFAULT_LEVEL = "info";
+    CONFIGURED_LOG_LEVEL = resolveConfiguredLevel();
+  }
+});
+
+// src/logging/subsystem.ts
+import chalk from "chalk";
+function timeStamp(d) {
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function formatMeta(meta) {
+  if (!meta || Object.keys(meta).length === 0) return "";
+  return " " + chalk.dim(JSON.stringify(meta));
+}
+function forwardToErrorSink(subsystem, message, meta) {
+  const sink = globalThis[ERROR_SINK_KEY];
+  if (!sink || inErrorSink) return;
+  if (subsystem.startsWith("notif")) return;
+  inErrorSink = true;
+  try {
+    sink({ subsystem, message, meta });
+  } catch {
+  } finally {
+    inErrorSink = false;
+  }
+}
+function emit(level, subsystem, message, meta) {
+  if (!shouldLog(level)) return;
+  const now = /* @__PURE__ */ new Date();
+  writeLogEntry({
+    time: now.toISOString(),
+    level,
+    subsystem,
+    message,
+    ...meta && Object.keys(meta).length > 0 ? meta : {}
+  });
+  if (level === "error" || level === "fatal") {
+    forwardToErrorSink(subsystem, message, meta);
+  }
+  try {
+    const colorFn = levelColor[level];
+    const tag = chalk.bold(`[${subsystem}]`);
+    const lbl = colorFn(levelLabel[level]);
+    const ts = chalk.dim(timeStamp(now));
+    const metaStr = formatMeta(meta);
+    const line = redactSensitiveText(`${ts} ${lbl} ${tag} ${message}${metaStr}
+`);
+    process.stderr.write(line);
+  } catch {
+  }
+}
+function createSubsystemLogger(subsystem) {
+  const logger = {
+    trace: (msg, meta) => emit("trace", subsystem, msg, meta),
+    debug: (msg, meta) => emit("debug", subsystem, msg, meta),
+    info: (msg, meta) => emit("info", subsystem, msg, meta),
+    warn: (msg, meta) => emit("warn", subsystem, msg, meta),
+    error: (msg, meta) => emit("error", subsystem, msg, meta),
+    fatal: (msg, meta) => emit("fatal", subsystem, msg, meta),
+    child(subName) {
+      return createSubsystemLogger(`${subsystem}/${subName}`);
+    }
+  };
+  return logger;
+}
+var levelColor, levelLabel, ERROR_SINK_KEY, inErrorSink;
+var init_subsystem = __esm({
+  "src/logging/subsystem.ts"() {
+    "use strict";
+    init_levels();
+    init_logger();
+    init_redact();
+    levelColor = {
+      trace: chalk.gray,
+      debug: chalk.cyan,
+      info: chalk.green,
+      warn: chalk.yellow,
+      error: chalk.red,
+      fatal: chalk.bgRed.white
+    };
+    levelLabel = {
+      trace: "TRC",
+      debug: "DBG",
+      info: "INF",
+      warn: "WRN",
+      error: "ERR",
+      fatal: "FTL"
+    };
+    ERROR_SINK_KEY = /* @__PURE__ */ Symbol.for("open-walnut.errorNotificationSink");
+    inErrorSink = false;
+  }
+});
+
+// src/logging/index.ts
+var log;
+var init_logging = __esm({
+  "src/logging/index.ts"() {
+    "use strict";
+    init_logger();
+    init_subsystem();
+    init_subsystem();
+    init_levels();
+    init_redact();
+    log = {
+      bus: createSubsystemLogger("bus"),
+      agent: createSubsystemLogger("agent"),
+      session: createSubsystemLogger("session"),
+      subagent: createSubsystemLogger("subagent"),
+      web: createSubsystemLogger("web"),
+      ws: createSubsystemLogger("ws"),
+      hook: createSubsystemLogger("hook"),
+      task: createSubsystemLogger("task"),
+      memory: createSubsystemLogger("memory"),
+      cron: createSubsystemLogger("cron"),
+      notif: createSubsystemLogger("notif"),
+      usage: createSubsystemLogger("usage"),
+      heartbeat: createSubsystemLogger("heartbeat"),
+      git: createSubsystemLogger("git"),
+      browser: createSubsystemLogger("browser"),
+      audio: createSubsystemLogger("audio"),
+      stt: createSubsystemLogger("stt"),
+      obs: createSubsystemLogger("obs"),
+      calendar: createSubsystemLogger("calendar")
+    };
+  }
+});
+
+// src/utils/file-lock.ts
+import fs3 from "fs";
+import fsp2 from "fs/promises";
+import path3 from "path";
+function lockDir(filePath) {
+  return filePath + ".lock";
+}
+function pidFile(lock) {
+  return path3.join(lock, "pid");
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function withFileLock(filePath, fn) {
+  const lock = lockDir(filePath);
+  const deadline = Date.now() + TIMEOUT_MS;
+  await fsp2.mkdir(path3.dirname(lock), { recursive: true });
+  while (true) {
+    try {
+      await fsp2.mkdir(lock);
+      try {
+        await fsp2.writeFile(pidFile(lock), String(process.pid));
+      } catch {
+      }
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      if (await isLockStaleAsync(lock)) {
+        try {
+          await fsp2.rm(lock, { recursive: true, force: true });
+        } catch {
+        }
+        continue;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(`File lock timeout after ${TIMEOUT_MS}ms: ${lock}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      await fsp2.rm(lock, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function isLockStaleAsync(lock) {
+  try {
+    const raw = await fsp2.readFile(pidFile(lock), "utf-8");
+    const pid = parseInt(raw.trim(), 10);
+    if (!isNaN(pid) && pid > 0) {
+      return !isPidAlive(pid);
+    }
+  } catch {
+  }
+  try {
+    const stat = await fsp2.stat(lock);
+    return Date.now() - stat.mtimeMs > STALE_AGE_MS;
+  } catch {
+    return true;
+  }
+}
+var STALE_AGE_MS, TIMEOUT_MS, POLL_MS;
+var init_file_lock = __esm({
+  "src/utils/file-lock.ts"() {
+    "use strict";
+    STALE_AGE_MS = 3e4;
+    TIMEOUT_MS = 1e4;
+    POLL_MS = 15;
+  }
+});
+
+// src/utils/fs.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import crypto from "crypto";
+async function writeJsonFile(filePath, data) {
+  const dir = path4.dirname(filePath);
+  await fs4.mkdir(dir, { recursive: true });
+  const tmpFile = path4.join(
+    dir,
+    `.open-walnut-${crypto.randomBytes(8).toString("hex")}.tmp`
+  );
+  try {
+    await fs4.writeFile(tmpFile, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    await fs4.rename(tmpFile, filePath);
+  } catch (err) {
+    await fs4.rm(tmpFile, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+async function readJsonFile(filePath, fallback) {
+  let content;
+  try {
+    content = await fs4.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return fallback;
+    }
+    log.web.warn("non-ENOENT error reading JSON file", { filePath, error: err instanceof Error ? err.message : String(err) });
+    return fallback;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (parseErr) {
+    if (content.trim().length === 0) {
+      return fallback;
+    }
+    throw new Error(
+      `Failed to parse ${filePath}: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`
+    );
+  }
+}
+async function ensureDir(dirPath) {
+  await fs4.mkdir(dirPath, { recursive: true });
+}
+var init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+    init_logging();
+    init_file_lock();
+  }
+});
+
+// src/core/types.ts
+var VALID_PRIORITIES, SESSION_MODELS, SESSION_MODEL_CLI_MAP, VALID_SESSION_MODEL_IDS, SESSION_EFFORT_IDS, VALID_SESSION_EFFORT_IDS, SESSION_MODES, SESSION_MODE_IDS, VALID_SESSION_MODE_IDS, SESSION_MODE_CLI_MAP, SESSION_MODE_LABELS;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    VALID_PRIORITIES = ["immediate", "important", "backlog", "none"];
+    SESSION_MODELS = [
+      { id: "opus", label: "Opus", description: "Most capable", cliModel: "opus", family: "opus", is1m: false },
+      { id: "opus-1m", label: "Opus 1M", description: "1M context window", cliModel: "opus[1m]", family: "opus", is1m: true },
+      { id: "sonnet", label: "Sonnet", description: "Balanced", cliModel: "sonnet", family: "sonnet", is1m: false },
+      { id: "sonnet-1m", label: "Sonnet 1M", description: "1M context window", cliModel: "sonnet[1m]", family: "sonnet", is1m: true },
+      { id: "haiku", label: "Haiku", description: "Fastest", cliModel: "haiku", family: "haiku", is1m: false },
+      { id: "fable", label: "Fable", description: "Fast & capable", cliModel: "fable", family: "fable", is1m: false },
+      { id: "fable-1m", label: "Fable 1M", description: "1M context window", cliModel: "fable[1m]", family: "fable", is1m: true }
+    ];
+    SESSION_MODEL_CLI_MAP = Object.fromEntries(SESSION_MODELS.map((m) => [m.id, m.cliModel]));
+    VALID_SESSION_MODEL_IDS = new Set(SESSION_MODELS.map((m) => m.id));
+    SESSION_EFFORT_IDS = ["low", "medium", "high", "xhigh", "max"];
+    VALID_SESSION_EFFORT_IDS = new Set(SESSION_EFFORT_IDS);
+    SESSION_MODES = [
+      { id: "plan", cli: "plan", label: "Plan", description: "Explore and plan only \u2014 no edits or commands" },
+      { id: "default", cli: "default", label: "Default", description: "Ask before anything sensitive" },
+      { id: "dontAsk", cli: "dontAsk", label: "Don't Ask", description: "Never prompt \u2014 deny whatever is not pre-approved" },
+      { id: "accept", cli: "acceptEdits", label: "Accept", description: "Auto-accept file edits, still ask for the rest" },
+      { id: "auto", cli: "auto", label: "Auto", description: "Classify each call and auto-allow the safe ones" },
+      { id: "bypass", cli: "bypassPermissions", label: "Bypass", description: "Full trust \u2014 never ask, allow everything" }
+    ];
+    SESSION_MODE_IDS = SESSION_MODES.map((m) => m.id);
+    VALID_SESSION_MODE_IDS = new Set(SESSION_MODE_IDS);
+    SESSION_MODE_CLI_MAP = Object.fromEntries(SESSION_MODES.map((m) => [m.id, m.cli]));
+    SESSION_MODE_LABELS = Object.fromEntries(SESSION_MODES.map((m) => [m.id, m.label]));
+  }
+});
+
+// src/agent/providers/model-catalog.ts
+var MODEL_CATALOG;
+var init_model_catalog = __esm({
+  "src/agent/providers/model-catalog.ts"() {
+    "use strict";
+    MODEL_CATALOG = {
+      // ── AWS Bedrock (Claude via cross-region inference) ──
+      // Models with 1M variants use model_id to map back to the same API model ID.
+      // The API has no -1m model; 1M capability is activated via the context-1m beta header.
+      // model_id therefore redirects the -1m catalog entry to the real API endpoint.
+      bedrock: [
+        // Opus 5: 1M context is native and the only size — no -1m variant, no beta header.
+        {
+          id: "global.anthropic.claude-opus-5",
+          provider: "bedrock",
+          label: "Opus 5",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true, native_1m: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-8",
+          provider: "bedrock",
+          label: "Opus 4.8",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-8-1m",
+          provider: "bedrock",
+          model_id: "global.anthropic.claude-opus-4-8",
+          label: "Opus 4.8 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-7",
+          provider: "bedrock",
+          label: "Opus 4.7",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-7-1m",
+          provider: "bedrock",
+          model_id: "global.anthropic.claude-opus-4-7",
+          label: "Opus 4.7 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-6-v1",
+          provider: "bedrock",
+          label: "Opus 4.6",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-opus-4-6-v1-1m",
+          provider: "bedrock",
+          model_id: "global.anthropic.claude-opus-4-6-v1",
+          label: "Opus 4.6 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-sonnet-4-6",
+          provider: "bedrock",
+          label: "Sonnet 4.6",
+          max_tokens: 64e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "global.anthropic.claude-sonnet-4-6-1m",
+          provider: "bedrock",
+          model_id: "global.anthropic.claude-sonnet-4-6",
+          label: "Sonnet 4.6 (1M)",
+          max_tokens: 64e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "us.anthropic.claude-haiku-4-5-20251001-v1:0",
+          provider: "bedrock",
+          label: "Haiku 4.5",
+          max_tokens: 64e3,
+          context_window: 2e5
+        }
+        // No extended thinking — Haiku 4.5 doesn't support it
+      ],
+      // ── Anthropic Direct API ──
+      anthropic: [
+        // Opus 5: 1M context is native and the only size — no -1m variant, no beta header.
+        {
+          id: "claude-opus-5",
+          provider: "anthropic",
+          label: "Opus 5",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true, native_1m: true }
+        },
+        {
+          id: "claude-opus-4-8",
+          provider: "anthropic",
+          label: "Opus 4.8",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-opus-4-8-1m",
+          provider: "anthropic",
+          model_id: "claude-opus-4-8",
+          label: "Opus 4.8 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-opus-4-7",
+          provider: "anthropic",
+          label: "Opus 4.7",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-opus-4-7-1m",
+          provider: "anthropic",
+          model_id: "claude-opus-4-7",
+          label: "Opus 4.7 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-opus-4-6",
+          provider: "anthropic",
+          label: "Opus 4.6",
+          max_tokens: 128e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-opus-4-6-1m",
+          provider: "anthropic",
+          model_id: "claude-opus-4-6",
+          label: "Opus 4.6 (1M)",
+          max_tokens: 128e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-sonnet-4-6",
+          provider: "anthropic",
+          label: "Sonnet 4.6",
+          max_tokens: 64e3,
+          context_window: 2e5,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-sonnet-4-6-1m",
+          provider: "anthropic",
+          model_id: "claude-sonnet-4-6",
+          label: "Sonnet 4.6 (1M)",
+          max_tokens: 64e3,
+          context_window: 1e6,
+          compat: { thinking_format: "anthropic", supports_adaptive: true }
+        },
+        {
+          id: "claude-haiku-4-5",
+          provider: "anthropic",
+          label: "Haiku 4.5",
+          max_tokens: 64e3,
+          context_window: 2e5
+        }
+        // No extended thinking — Haiku 4.5 doesn't support it
+      ],
+      // ── OpenAI ──
+      openai: [
+        {
+          id: "gpt-5.4",
+          provider: "openai",
+          label: "GPT-5.4",
+          max_tokens: 128e3,
+          context_window: 105e4
+        },
+        {
+          id: "gpt-5-mini-2025-08-07",
+          provider: "openai",
+          label: "GPT-5 Mini",
+          max_tokens: 128e3,
+          context_window: 4e5
+        },
+        {
+          id: "gpt-5-nano-2025-08-07",
+          provider: "openai",
+          label: "GPT-5 Nano",
+          max_tokens: 128e3,
+          context_window: 4e5
+        }
+      ],
+      // ── Google Gemini ──
+      gemini: [
+        {
+          id: "gemini-3.1-pro-preview",
+          provider: "gemini",
+          label: "Gemini 3.1 Pro",
+          max_tokens: 65536,
+          context_window: 1e6
+        },
+        {
+          id: "gemini-3-flash-preview",
+          provider: "gemini",
+          label: "Gemini 3 Flash",
+          max_tokens: 65536,
+          context_window: 1e6
+        },
+        {
+          id: "gemini-3.1-flash-lite-preview",
+          provider: "gemini",
+          label: "Gemini 3.1 Flash Lite",
+          max_tokens: 65536,
+          context_window: 1e6
+        }
+      ],
+      // ── OpenRouter (aggregator — sorted by release date, newest first) ──
+      openrouter: [
+        // -- Anthropic --
+        {
+          id: "anthropic/claude-opus-5",
+          provider: "openrouter",
+          label: "Claude Opus 5",
+          max_tokens: 128e3,
+          context_window: 1e6
+        },
+        {
+          id: "anthropic/claude-opus-5-fast",
+          provider: "openrouter",
+          label: "Claude Opus 5 (Fast)",
+          max_tokens: 128e3,
+          context_window: 1e6
+        },
+        {
+          id: "anthropic/claude-opus-4.6",
+          provider: "openrouter",
+          label: "Claude Opus 4.6",
+          max_tokens: 128e3,
+          context_window: 1e6
+        },
+        {
+          id: "anthropic/claude-sonnet-4.6",
+          provider: "openrouter",
+          label: "Claude Sonnet 4.6",
+          max_tokens: 64e3,
+          context_window: 1e6
+        },
+        // -- OpenAI --
+        {
+          id: "openai/gpt-5.2",
+          provider: "openrouter",
+          label: "GPT-5.2",
+          max_tokens: 128e3,
+          context_window: 4e5
+        },
+        {
+          id: "openai/gpt-5.2-pro",
+          provider: "openrouter",
+          label: "GPT-5.2 Pro",
+          max_tokens: 128e3,
+          context_window: 4e5
+        },
+        {
+          id: "openai/gpt-5.2-chat",
+          provider: "openrouter",
+          label: "GPT-5.2 Chat",
+          max_tokens: 128e3,
+          context_window: 128e3
+        },
+        // -- Google --
+        {
+          id: "google/gemini-3.1-pro-preview",
+          provider: "openrouter",
+          label: "Gemini 3.1 Pro",
+          max_tokens: 65536,
+          context_window: 1048576
+        },
+        {
+          id: "google/gemini-3-flash-preview",
+          provider: "openrouter",
+          label: "Gemini 3 Flash",
+          max_tokens: 65536,
+          context_window: 1048576
+        },
+        // -- Qwen --
+        {
+          id: "qwen/qwen3.5-plus-02-15",
+          provider: "openrouter",
+          label: "Qwen 3.5 Plus",
+          max_tokens: 128e3,
+          context_window: 1e6
+        },
+        {
+          id: "qwen/qwen3.5-397b-a17b",
+          provider: "openrouter",
+          label: "Qwen 3.5 397B",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        {
+          id: "qwen/qwen3-max-thinking",
+          provider: "openrouter",
+          label: "Qwen3 Max Thinking",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        {
+          id: "qwen/qwen3-coder-next",
+          provider: "openrouter",
+          label: "Qwen3 Coder Next",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        // -- MiniMax --
+        {
+          id: "minimax/minimax-m2.5",
+          provider: "openrouter",
+          label: "MiniMax M2.5",
+          max_tokens: 128e3,
+          context_window: 196608
+        },
+        {
+          id: "minimax/minimax-m2.1",
+          provider: "openrouter",
+          label: "MiniMax M2.1",
+          max_tokens: 128e3,
+          context_window: 196608
+        },
+        {
+          id: "minimax/minimax-m2-her",
+          provider: "openrouter",
+          label: "MiniMax M2 Her",
+          max_tokens: 128e3,
+          context_window: 65536
+        },
+        // -- Z.ai (GLM) --
+        {
+          id: "z-ai/glm-5",
+          provider: "openrouter",
+          label: "GLM 5",
+          max_tokens: 128e3,
+          context_window: 202752
+        },
+        {
+          id: "z-ai/glm-4.7",
+          provider: "openrouter",
+          label: "GLM 4.7",
+          max_tokens: 128e3,
+          context_window: 202752
+        },
+        {
+          id: "z-ai/glm-4.7-flash",
+          provider: "openrouter",
+          label: "GLM 4.7 Flash",
+          max_tokens: 128e3,
+          context_window: 202752
+        },
+        // -- Moonshot / Kimi --
+        {
+          id: "moonshotai/kimi-k2.5",
+          provider: "openrouter",
+          label: "Kimi K2.5",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        // -- AionLabs --
+        {
+          id: "aion-labs/aion-2.0",
+          provider: "openrouter",
+          label: "Aion 2.0",
+          max_tokens: 128e3,
+          context_window: 131072
+        },
+        // -- StepFun --
+        {
+          id: "stepfun/step-3.5-flash",
+          provider: "openrouter",
+          label: "Step 3.5 Flash",
+          max_tokens: 128e3,
+          context_window: 256e3
+        },
+        {
+          id: "stepfun/step-3.5-flash:free",
+          provider: "openrouter",
+          label: "Step 3.5 Flash (free)",
+          max_tokens: 128e3,
+          context_window: 256e3
+        },
+        // -- ByteDance Seed --
+        {
+          id: "bytedance-seed/seed-1.6",
+          provider: "openrouter",
+          label: "Seed 1.6",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        {
+          id: "bytedance-seed/seed-1.6-flash",
+          provider: "openrouter",
+          label: "Seed 1.6 Flash",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        // -- Xiaomi --
+        {
+          id: "xiaomi/mimo-v2-flash",
+          provider: "openrouter",
+          label: "MiMo V2 Flash",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        // -- NVIDIA --
+        {
+          id: "nvidia/nemotron-3-nano-30b-a3b",
+          provider: "openrouter",
+          label: "Nemotron 3 Nano 30B",
+          max_tokens: 128e3,
+          context_window: 262144
+        },
+        {
+          id: "nvidia/nemotron-3-nano-30b-a3b:free",
+          provider: "openrouter",
+          label: "Nemotron 3 Nano 30B (free)",
+          max_tokens: 128e3,
+          context_window: 256e3
+        },
+        // -- Writer --
+        {
+          id: "writer/palmyra-x5",
+          provider: "openrouter",
+          label: "Palmyra X5",
+          max_tokens: 128e3,
+          context_window: 104e4
+        },
+        // -- Upstage --
+        {
+          id: "upstage/solar-pro-3",
+          provider: "openrouter",
+          label: "Solar Pro 3",
+          max_tokens: 128e3,
+          context_window: 128e3
+        },
+        // -- Mistral --
+        {
+          id: "mistralai/mistral-small-creative",
+          provider: "openrouter",
+          label: "Mistral Small Creative",
+          max_tokens: 128e3,
+          context_window: 32768
+        },
+        // -- AllenAI --
+        {
+          id: "allenai/olmo-3.1-32b-instruct",
+          provider: "openrouter",
+          label: "OLMo 3.1 32B Instruct",
+          max_tokens: 128e3,
+          context_window: 65536
+        },
+        {
+          id: "allenai/olmo-3.1-32b-think",
+          provider: "openrouter",
+          label: "OLMo 3.1 32B Think",
+          max_tokens: 128e3,
+          context_window: 65536
+        },
+        {
+          id: "allenai/molmo-2-8b",
+          provider: "openrouter",
+          label: "Molmo2 8B",
+          max_tokens: 128e3,
+          context_window: 36864
+        },
+        // -- Arcee --
+        {
+          id: "arcee-ai/trinity-large-preview:free",
+          provider: "openrouter",
+          label: "Trinity Large Preview (free)",
+          max_tokens: 128e3,
+          context_window: 131e3
+        }
+      ],
+      // ── Ollama (local) — empty baseline, user adds their installed models ──
+      ollama: [],
+      // ── Claude Code subscription (local `claude -p`, text-only) ──
+      // The CLI picks the actual model from the subscription; these are short
+      // aliases the adapter forwards as --model (a bare alias resolves server-side).
+      // 'default' means "let the subscription decide" (adapter sends no --model).
+      claude_cli: [
+        { id: "default", provider: "claude_cli", label: "Subscription default", context_window: 2e5 },
+        { id: "opus", provider: "claude_cli", label: "Opus (subscription)", context_window: 2e5 },
+        { id: "sonnet", provider: "claude_cli", label: "Sonnet (subscription)", context_window: 2e5 },
+        { id: "haiku", provider: "claude_cli", label: "Haiku (subscription)", context_window: 2e5 }
+      ]
+    };
+  }
+});
+
+// src/core/ssh-config-scanner.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+import os2 from "os";
+function isGitServerHost(h) {
+  if (h.user === "git") return true;
+  const gitPrefix = /^(git|github|gitlab|bitbucket|codecommit|ssh\.github)\./i;
+  return gitPrefix.test(h.alias) || gitPrefix.test(h.hostname);
+}
+function shortLabelForFqdn(hostname) {
+  const first = hostname.split(".")[0];
+  if (first.length <= 24) return first;
+  const parts = first.split("-");
+  if (parts.length >= 3) {
+    return `${parts[0]}-${parts[1]}\u2026${parts[parts.length - 1]}`;
+  }
+  return `${first.slice(0, 12)}\u2026${first.slice(-8)}`;
+}
+async function scanSshConfig(configPath) {
+  const sshConfigPath = configPath ?? path5.join(os2.homedir(), ".ssh", "config");
+  let mtimeMs2;
+  try {
+    mtimeMs2 = (await fs5.stat(sshConfigPath)).mtimeMs;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  const cached = scanCache.get(sshConfigPath);
+  if (cached && cached.mtimeMs === mtimeMs2) return cached.result;
+  const result = await parseSshConfigFile(sshConfigPath);
+  scanCache.set(sshConfigPath, { mtimeMs: mtimeMs2, result });
+  return result;
+}
+async function parseSshConfigFile(sshConfigPath) {
+  const discovered = /* @__PURE__ */ new Map();
+  try {
+    const content = await fs5.readFile(sshConfigPath, "utf-8");
+    const lines = content.split("\n");
+    let currentHost = null;
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      if (line.match(/^Host\s+/i)) {
+        if (currentHost && currentHost.hostname) {
+          discovered.set(currentHost.alias, currentHost);
+        }
+        const hostMatch = line.match(/^Host\s+(\S+)/i);
+        if (hostMatch) {
+          const alias = hostMatch[1];
+          if (alias.includes("*") || alias.includes("?")) {
+            currentHost = null;
+            continue;
+          }
+          currentHost = { alias, hostname: alias };
+        }
+        continue;
+      }
+      if (!currentHost) continue;
+      const hostnameMatch = line.match(/^HostName\s+(\S+)/i);
+      if (hostnameMatch) {
+        currentHost.hostname = hostnameMatch[1];
+        continue;
+      }
+      const userMatch = line.match(/^User\s+(\S+)/i);
+      if (userMatch) {
+        currentHost.user = userMatch[1];
+        continue;
+      }
+      const portMatch = line.match(/^Port\s+(\d+)/i);
+      if (portMatch) {
+        currentHost.port = Number.parseInt(portMatch[1], 10);
+        continue;
+      }
+    }
+    if (currentHost && currentHost.hostname) {
+      discovered.set(currentHost.alias, currentHost);
+    }
+    for (const [alias, h] of discovered) {
+      if (isGitServerHost(h)) discovered.delete(alias);
+    }
+    const byHostname = /* @__PURE__ */ new Map();
+    for (const h of discovered.values()) {
+      const key = h.hostname.toLowerCase();
+      const existing = byHostname.get(key);
+      if (!existing) {
+        byHostname.set(key, h);
+        continue;
+      }
+      const existingIsShortAlias = existing.alias !== existing.hostname;
+      const candidateIsShortAlias = h.alias !== h.hostname;
+      if (candidateIsShortAlias && !existingIsShortAlias) byHostname.set(key, h);
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const h of byHostname.values()) {
+      if (h.alias === h.hostname && !h.label) h.label = shortLabelForFqdn(h.hostname);
+      result.set(h.alias, h);
+    }
+    log.session.info("ssh-config-scanner: discovered hosts", {
+      count: result.size,
+      dropped: discovered.size - result.size
+    });
+    return result;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      log.session.debug("ssh-config-scanner: no ~/.ssh/config found");
+    } else {
+      log.session.warn("ssh-config-scanner: failed to parse SSH config", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return discovered;
+  }
+}
+var scanCache;
+var init_ssh_config_scanner = __esm({
+  "src/core/ssh-config-scanner.ts"() {
+    "use strict";
+    init_logging();
+    scanCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/config-manager.ts
+import fs6 from "fs/promises";
+import yaml from "js-yaml";
+function migrateConfigToProjectOnly(config) {
+  let changed = false;
+  const defaults = config.defaults;
+  if (defaults && "category" in defaults) {
+    delete defaults.category;
+    changed = true;
+  }
+  if ("local" in config) {
+    delete config.local;
+    changed = true;
+  }
+  const favorites = config.favorites;
+  if (favorites && "categories" in favorites) {
+    delete favorites.categories;
+    changed = true;
+  }
+  const ordering = config.ordering;
+  if (ordering && ("categories" in ordering || !Array.isArray(ordering.projects))) {
+    const catOrder = Array.isArray(ordering.categories) ? ordering.categories : [];
+    const nested = ordering.projects;
+    const flat = [];
+    const seen = /* @__PURE__ */ new Set();
+    const push = (raw) => {
+      const name = typeof raw === "string" ? raw.trim() : "";
+      if (!name) return;
+      const key = name.toLowerCase();
+      if (seen.has(key)) return;
+      seen.add(key);
+      flat.push(name);
+    };
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      const byCategory = nested;
+      const ordered = [
+        ...catOrder.map((c) => typeof c === "string" ? c : ""),
+        ...Object.keys(byCategory).filter(
+          (k) => !catOrder.some((c) => typeof c === "string" && c.toLowerCase() === k.toLowerCase())
+        )
+      ];
+      for (const cat of ordered) {
+        const key = Object.keys(byCategory).find((k) => k.toLowerCase() === cat.toLowerCase());
+        if (!key) continue;
+        const list = byCategory[key];
+        if (Array.isArray(list)) for (const p of list) push(p);
+      }
+    } else if (Array.isArray(nested)) {
+      for (const p of nested) push(p);
+    }
+    delete ordering.categories;
+    ordering.projects = flat;
+    changed = true;
+  }
+  const plugins = config.plugins;
+  for (const entry of Object.values(plugins ?? {})) {
+    if (!entry || typeof entry !== "object") continue;
+    const plugin = entry;
+    if ("category" in plugin) {
+      if (plugin.project === void 0 && typeof plugin.category === "string") {
+        plugin.project = plugin.category;
+      }
+      delete plugin.category;
+      changed = true;
+    }
+    if ("categories" in plugin) {
+      delete plugin.categories;
+      changed = true;
+    }
+  }
+  return changed;
+}
+async function readRawConfigContent() {
+  try {
+    return await fs6.readFile(CONFIG_FILE, "utf-8");
+  } catch (primaryErr) {
+    let backup;
+    try {
+      backup = await fs6.readFile(CONFIG_BACKUP_FILE, "utf-8");
+    } catch {
+      return null;
+    }
+    if (!backup.trim()) return null;
+    log.session.error("config-manager: config.yaml missing/unreadable \u2014 recovering from config.yaml.bak", {
+      error: primaryErr instanceof Error ? primaryErr.message : String(primaryErr),
+      backup: CONFIG_BACKUP_FILE
+    });
+    try {
+      await fs6.writeFile(CONFIG_FILE, backup, "utf-8");
+    } catch {
+    }
+    return backup;
+  }
+}
+async function writeConfigWithBackup(content) {
+  await fs6.writeFile(CONFIG_FILE, content, "utf-8");
+  try {
+    await fs6.writeFile(CONFIG_BACKUP_FILE, content, "utf-8");
+  } catch (err) {
+    log.session.warn("config-manager: failed to update config backup", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function getConfig() {
+  try {
+    const content = await readRawConfigContent();
+    if (content === null) throw new Error("no config file and no backup");
+    const parsed = yaml.load(content);
+    const config = { ...DEFAULT_CONFIG, ...parsed };
+    migrateConfigToProjectOnly(config);
+    if (config.defaults?.priority && !VALID_PRIORITIES.includes(config.defaults.priority)) {
+      const p = config.defaults.priority;
+      if (p === "high") config.defaults.priority = "immediate";
+      else if (p === "medium" || p === "low") config.defaults.priority = "backlog";
+      else config.defaults.priority = "none";
+    }
+    if (!config.agent?.available_models) {
+      config.agent = { ...config.agent, available_models: (MODEL_CATALOG.bedrock ?? []).map((m) => m.id) };
+    }
+    if (!config.agent?.main_model) {
+      config.agent = { ...config.agent, main_model: (MODEL_CATALOG.bedrock ?? [])[0]?.id };
+    }
+    await mergeSshDiscoveredHosts(config);
+    return config;
+  } catch (err) {
+    const firstRun = err instanceof Error && err.message === "no config file and no backup";
+    const detail = { error: err instanceof Error ? err.message : String(err), configFile: CONFIG_FILE };
+    if (firstRun) log.session.info("config-manager: no config.yaml and no backup \u2014 first run, using defaults", detail);
+    else log.session.error("config-manager: config.yaml UNREADABLE and backup did not cover it \u2014 falling back to DEFAULTS. Machine-local settings (hosts/plugins/stt/provider) are missing until this is fixed.", detail);
+    const defaultModels = (MODEL_CATALOG.bedrock ?? []).map((m) => m.id);
+    return { ...DEFAULT_CONFIG, agent: { available_models: defaultModels, main_model: defaultModels[0] } };
+  }
+}
+async function mergeSshDiscoveredHosts(config) {
+  const discovered = await scanSshConfig();
+  if (discovered.size === 0) return;
+  if (!config.hosts) {
+    config.hosts = {};
+  }
+  const knownHostnames = new Set(
+    Object.values(config.hosts).map((h) => h.hostname.toLowerCase())
+  );
+  for (const [alias, host] of discovered) {
+    if (config.hosts[alias] || knownHostnames.has(host.hostname.toLowerCase())) {
+      continue;
+    }
+    config.hosts[alias] = {
+      hostname: host.hostname,
+      user: host.user,
+      port: host.port,
+      label: host.label,
+      enabled: true,
+      discovered: true
+    };
+    knownHostnames.add(host.hostname.toLowerCase());
+  }
+}
+function withWriteLock(fn) {
+  const prev = writeLock;
+  let resolve;
+  writeLock = new Promise((r) => {
+    resolve = r;
+  });
+  return prev.then(fn).finally(() => resolve());
+}
+async function updateConfig(partial) {
+  return withWriteLock(async () => {
+    let existing = {};
+    try {
+      const content2 = await readRawConfigContent();
+      existing = content2 === null ? {} : yaml.load(content2) ?? {};
+    } catch (err) {
+      log.session.warn("config-manager: existing config unreadable, starting from empty", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    const merged = { ...existing };
+    for (const [key, value] of Object.entries(partial)) {
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+    let content = yaml.dump(merged, { indent: 2, lineWidth: 120 });
+    content = content.replace(
+      /^(\s+)available_models:/m,
+      "$1# Available models for the agent form dropdown.\n$1# Edit this list to add or remove models.\n$1available_models:"
+    );
+    await writeConfigWithBackup(content);
+  });
+}
+async function migrateConfigFileToProjectOnly() {
+  return withWriteLock(async () => {
+    let parsed;
+    try {
+      const content2 = await readRawConfigContent();
+      if (content2 === null) return false;
+      parsed = yaml.load(content2) ?? {};
+    } catch (err) {
+      log.session.warn("config-manager: skipping project-only migration, config unreadable", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+    if (!migrateConfigToProjectOnly(parsed)) return false;
+    let content = yaml.dump(parsed, { indent: 2, lineWidth: 120 });
+    content = content.replace(
+      /^(\s+)available_models:/m,
+      "$1# Available models for the agent form dropdown.\n$1# Edit this list to add or remove models.\n$1available_models:"
+    );
+    await writeConfigWithBackup(content);
+    log.session.info("config-manager: migrated config.yaml to the project-only model");
+    return true;
+  });
+}
+async function seedConfigDefaults() {
+  await migrateConfigFileToProjectOnly();
+  const config = await getConfig();
+  let needsWrite = false;
+  try {
+    const raw = await fs6.readFile(CONFIG_FILE, "utf-8");
+    if (!raw.includes("available_models")) {
+      needsWrite = true;
+    }
+  } catch (err) {
+    log.session.debug("config-manager: no config file found, will write defaults", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    needsWrite = true;
+  }
+  if (needsWrite) {
+    await updateConfig({
+      agent: config.agent,
+      version: config.version,
+      user: config.user,
+      defaults: config.defaults,
+      provider: config.provider
+    });
+  }
+}
+var DEFAULT_CONFIG, CONFIG_BACKUP_FILE, writeLock;
+var init_config_manager = __esm({
+  "src/core/config-manager.ts"() {
+    "use strict";
+    init_logging();
+    init_constants();
+    init_types();
+    init_model_catalog();
+    init_ssh_config_scanner();
+    DEFAULT_CONFIG = {
+      version: 1,
+      user: {},
+      // New tasks default to Inbox (no project) and stay local, so quick-add is
+      // instant and never silently routed to an external sync target.
+      // `platform: 'local'` makes the source explicit. Existing users keep whatever
+      // `defaults` is already on disk (getConfig spreads parsed over DEFAULT_CONFIG),
+      // so this never re-routes an established setup.
+      defaults: { priority: "none", platform: "local" },
+      provider: { type: "claude-code" }
+    };
+    CONFIG_BACKUP_FILE = `${CONFIG_FILE}.bak`;
+    writeLock = Promise.resolve();
+  }
+});
+
+// src/core/phase.ts
+function deriveStatusFromPhase(phase) {
+  return PHASE_TO_STATUS[phase] ?? "todo";
+}
+var PHASE_TO_STATUS, PHASE_ORDER, VALID_PHASES;
+var init_phase = __esm({
+  "src/core/phase.ts"() {
+    "use strict";
+    init_logging();
+    PHASE_TO_STATUS = {
+      TODO: "todo",
+      IN_PROGRESS: "in_progress",
+      AGENT_COMPLETE: "in_progress",
+      AWAIT_HUMAN_ACTION: "in_progress",
+      HUMAN_VERIFIED: "in_progress",
+      POST_WORK_COMPLETED: "in_progress",
+      COMPLETE: "done"
+    };
+    PHASE_ORDER = [
+      "TODO",
+      "IN_PROGRESS",
+      "AGENT_COMPLETE",
+      "AWAIT_HUMAN_ACTION",
+      "HUMAN_VERIFIED",
+      "POST_WORK_COMPLETED",
+      "COMPLETE"
+    ];
+    VALID_PHASES = new Set(PHASE_ORDER);
+  }
+});
+
+// src/integrations/ms-todo/phase.ts
+function phaseToMsStatus(phase) {
+  return PHASE_TO_MS_STATUS[phase] ?? "notStarted";
+}
+function phaseFromMsStatus(msStatus) {
+  return MS_STATUS_TO_DEFAULT_PHASE[msStatus] ?? "TODO";
+}
+var PHASE_TO_MS_STATUS, MS_STATUS_TO_DEFAULT_PHASE;
+var init_phase2 = __esm({
+  "src/integrations/ms-todo/phase.ts"() {
+    "use strict";
+    PHASE_TO_MS_STATUS = {
+      TODO: "notStarted",
+      IN_PROGRESS: "inProgress",
+      AGENT_COMPLETE: "inProgress",
+      AWAIT_HUMAN_ACTION: "inProgress",
+      HUMAN_VERIFIED: "inProgress",
+      POST_WORK_COMPLETED: "inProgress",
+      COMPLETE: "completed"
+    };
+    MS_STATUS_TO_DEFAULT_PHASE = {
+      notStarted: "TODO",
+      inProgress: "IN_PROGRESS",
+      completed: "COMPLETE"
+    };
+  }
+});
+
+// src/utils/format.ts
+import crypto2 from "crypto";
+function parseProjectFromListName(listDisplayName) {
+  const sep = " / ";
+  const raw = (listDisplayName ?? "").trim();
+  const idx = raw.indexOf(sep);
+  if (idx === -1) return titleCase(raw);
+  return titleCase(raw.slice(idx + sep.length).trim());
+}
+function isRetiredQuickStartGroup(name) {
+  return (name ?? "").trim().toLowerCase() === "quick start";
+}
+function isLegacyInboxGroup(name) {
+  return (name ?? "").trim().toLowerCase() === "inbox";
+}
+function routePulledListToProject(listDisplayName) {
+  const raw = (listDisplayName ?? "").trim();
+  if (!raw) return "";
+  if (isLegacyInboxGroup(raw)) return "";
+  const project = parseProjectFromListName(raw);
+  if (isRetiredQuickStartGroup(project)) return "";
+  return project;
+}
+function titleCase(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var init_format = __esm({
+  "src/utils/format.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/file-ops.ts
+import crypto3 from "crypto";
+import fsp3 from "fs/promises";
+import path6 from "path";
+var MAX_READ_SIZE;
+var init_file_ops = __esm({
+  "src/utils/file-ops.ts"() {
+    "use strict";
+    init_file_lock();
+    MAX_READ_SIZE = 10 * 1024 * 1024;
+  }
+});
+
+// src/core/memory-file.ts
+import fs7 from "fs";
+import path7 from "path";
+function resolveMemoryPath(agentId) {
+  if (!agentId || agentId === "general") return MEMORY_FILE;
+  return path7.join(agentMemoryDir(agentId), "MEMORY.md");
+}
+function ensureMemoryFile(agentId) {
+  const filePath = resolveMemoryPath(agentId);
+  if (fs7.existsSync(filePath)) return;
+  fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+  fs7.writeFileSync(filePath, DEFAULT_TEMPLATE, "utf-8");
+}
+var DEFAULT_TEMPLATE;
+var init_memory_file = __esm({
+  "src/core/memory-file.ts"() {
+    "use strict";
+    init_logging();
+    init_constants();
+    init_file_ops();
+    DEFAULT_TEMPLATE = `---
+name: Global Memory
+description: >
+  Curated knowledge and preferences. Updated by the agent as it learns.
+---
+`;
+  }
+});
+
+// src/core/tmp-sweep.ts
+import fsp4 from "fs/promises";
+import path8 from "path";
+function sweepDirs() {
+  return [
+    WALNUT_HOME,
+    SYNC_DIR,
+    path8.join(WALNUT_HOME, "sessions"),
+    path8.join(WALNUT_HOME, "sessions", "transcripts"),
+    TASKS_DIR,
+    path8.join(TASKS_DIR, "outbox"),
+    CONVERSATIONS_DIR,
+    MEMORY_DIR,
+    DAILY_DIR,
+    // Projection cache (Phase 3) — gitignored, but a crashed rename still
+    // leaves an orphan the read path never cleans up.
+    PROJECTION_CACHE_DIR,
+    TRANSCRIPT_CACHE_DIR,
+    // Offline task-op queue (Phase 4) — same story: gitignored, but a torn
+    // write leaves a .tmp the flush loop skips forever.
+    TASK_QUEUE_DIR
+  ];
+}
+async function sweepOrphanAtomicTmpFiles() {
+  const removed = [];
+  const cutoff = Date.now() - MIN_AGE_MS;
+  for (const dir of sweepDirs()) {
+    try {
+      const entries = await fsp4.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !ORPHAN_RE.test(entry.name)) continue;
+        const full = path8.join(dir, entry.name);
+        try {
+          const st = await fsp4.stat(full);
+          if (st.mtimeMs > cutoff) continue;
+          await fsp4.unlink(full);
+          removed.push(full);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (removed.length > 0) {
+    log.web.info("swept orphaned atomic-write temp files", {
+      count: removed.length,
+      files: removed.slice(0, 10)
+    });
+  }
+  return removed;
+}
+var ORPHAN_RE, MIN_AGE_MS;
+var init_tmp_sweep = __esm({
+  "src/core/tmp-sweep.ts"() {
+    "use strict";
+    init_constants();
+    init_logging();
+    ORPHAN_RE = /^\.open-walnut-[0-9a-f]+\.tmp$/;
+    MIN_AGE_MS = 60 * 60 * 1e3;
+  }
+});
+
+// src/core/init.ts
+import fsp5 from "fs/promises";
+import fs8 from "fs";
+async function migrateLegacyMemoryFile() {
+  try {
+    if (fs8.existsSync(LEGACY_MEMORY_FILE) && !fs8.existsSync(MEMORY_FILE)) {
+      await fsp5.rename(LEGACY_MEMORY_FILE, MEMORY_FILE);
+      log.memory.info("Migrated MEMORY.md into memory/ folder", { from: LEGACY_MEMORY_FILE, to: MEMORY_FILE });
+    }
+  } catch (err) {
+    log.memory.warn("MEMORY.md migration failed (will retry next start)", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+async function initDirectories() {
+  await ensureDir(WALNUT_HOME);
+  await ensureDir(TASKS_DIR);
+  await ensureDir(ARCHIVE_DIR);
+  await ensureDir(MEMORY_DIR);
+  await ensureDir(SESSIONS_DIR);
+  await ensureDir(SYNC_DIR);
+  await ensureDir(DAILY_DIR);
+  await ensureDir(REPOS_MEMORY_DIR);
+  await ensureDir(COMPACTION_DIR);
+  await ensureDir(NOTES_DIR);
+  await ensureDir(REPOSITORIES_DIR);
+  await ensureDir(TIMELINE_DIR);
+  await ensureDir(TMP_DIR);
+  await ensureDir(RECORDINGS_DIR);
+  await ensureDir(CONFIG_SHARE_DIR);
+  await ensureDir(COMMANDS_DIR);
+  await ensureDir(GLOBAL_SKILLS_DIR);
+  await ensureDir(SESSION_STREAMS_DIR);
+  await ensureDir(IMAGES_DIR);
+  await ensureDir(REMOTE_IMAGES_DIR);
+  await migrateLegacyMemoryFile();
+  ensureMemoryFile();
+  await seedConfigDefaults();
+  void sweepOrphanAtomicTmpFiles();
+}
+var init_init = __esm({
+  "src/core/init.ts"() {
+    "use strict";
+    init_fs();
+    init_constants();
+    init_memory_file();
+    init_config_manager();
+    init_tmp_sweep();
+    init_logging();
+  }
+});
+
+// src/core/event-types.ts
+var init_event_types = __esm({
+  "src/core/event-types.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/event-bus.ts
+import { randomBytes } from "crypto";
+var EventNames, EVENT_HISTORY_SIZE, eventHistory, KEY_BUS_EVENTS, EventBus, bus;
+var init_event_bus = __esm({
+  "src/core/event-bus.ts"() {
+    "use strict";
+    init_logging();
+    init_event_types();
+    EventNames = {
+      // Task events
+      TASK_CREATED: "task:created",
+      TASK_UPDATED: "task:updated",
+      TASK_COMPLETED: "task:completed",
+      TASK_STARRED: "task:starred",
+      TASK_DELETED: "task:deleted",
+      TASK_REORDERED: "task:reordered",
+      TASK_UNBLOCKED: "task:unblocked",
+      TASK_GROUPS_CHANGED: "task:groups-changed",
+      // Calendar (external calendar events cache refreshed / event written)
+      CALENDAR_UPDATED: "calendar:updated",
+      // Inline subagent streaming
+      AGENT_SUBAGENT_STREAM: "agent:subagent-stream",
+      // Agent events (chat streaming)
+      AGENT_TEXT_DELTA: "agent:text-delta",
+      AGENT_TOOL_ACTIVITY: "agent:tool-activity",
+      AGENT_TOOL_CALL: "agent:tool-call",
+      AGENT_TOOL_RESULT: "agent:tool-result",
+      AGENT_THINKING: "agent:thinking",
+      AGENT_RESPONSE: "agent:response",
+      AGENT_ERROR: "agent:error",
+      // Session events
+      SESSION_START: "session:start",
+      SESSION_SEND: "session:send",
+      SESSION_INTERRUPT: "session:interrupt",
+      SESSION_STARTED: "session:started",
+      SESSION_ENDED: "session:ended",
+      SESSION_DELETED: "session:deleted",
+      SESSION_CONTENT_UPDATED: "session:content-updated",
+      SESSION_RESULT: "session:result",
+      SESSION_ERROR: "session:error",
+      // Session streaming events (from --output-format stream-json)
+      SESSION_TEXT_DELTA: "session:text-delta",
+      SESSION_THINKING_DELTA: "session:thinking-delta",
+      SESSION_TOOL_USE: "session:tool-use",
+      SESSION_TOOL_RESULT: "session:tool-result",
+      SESSION_UNKNOWN_EVENT: "session:unknown-event",
+      SESSION_STATUS_CHANGED: "session:status-changed",
+      SESSION_MESSAGES_DELIVERED: "session:messages-delivered",
+      SESSION_BATCH_COMPLETED: "session:batch-completed",
+      SESSION_BATCH_FAILED: "session:batch-failed",
+      SESSION_MESSAGE_QUEUED: "session:message-queued",
+      SESSION_SYSTEM_EVENT: "session:system-event",
+      SESSION_BACKGROUND_TASKS: "session:background-tasks",
+      SESSION_USAGE_UPDATE: "session:usage-update",
+      SESSION_SETTINGS_APPLIED: "session:settings-applied",
+      SESSION_MODEL_CATALOG: "session:model-catalog",
+      SESSION_PERMISSION_REQUEST: "session:permission-request",
+      SESSION_PERMISSION_RESOLVED: "session:permission-resolved",
+      // Side question ("/btw") — native Claude Code side_question round-trip results.
+      // The drawer subscribes to these to update without polling.
+      SESSION_SIDE_QUESTION_DONE: "session:side-question-done",
+      SESSION_SIDE_QUESTION_ERROR: "session:side-question-error",
+      // Team events (Claude Code Teams — parallel agents)
+      SESSION_TEAM_INFO: "session:team-info",
+      SESSION_TEAM_AGENT_DELTA: "session:team-agent-delta",
+      // Chat history events
+      CHAT_HISTORY_UPDATED: "chat:history-updated",
+      CHAT_COMPACTING: "chat:compacting",
+      CHAT_COMPACTED: "chat:compacted",
+      // Conversation events (multi-conversation per agent)
+      CONVERSATION_CREATED: "conversation:created",
+      CONVERSATION_DELETED: "conversation:deleted",
+      CONVERSATION_UPDATED: "conversation:updated",
+      // rename / pin / active-change
+      // Cron events
+      CRON_JOB_ADDED: "cron:job-added",
+      CRON_JOB_UPDATED: "cron:job-updated",
+      CRON_JOB_REMOVED: "cron:job-removed",
+      CRON_JOB_STARTED: "cron:job-started",
+      CRON_JOB_FINISHED: "cron:job-finished",
+      CRON_NOTIFICATION: "cron:notification",
+      // Subagent events
+      SUBAGENT_START: "subagent:start",
+      SUBAGENT_SEND: "subagent:send",
+      SUBAGENT_STARTED: "subagent:started",
+      SUBAGENT_RESULT: "subagent:result",
+      SUBAGENT_ERROR: "subagent:error",
+      // Sync events
+      SYNC_PULLED: "sync:pulled",
+      SYNC_CONFLICT_RESOLVED: "sync:conflict-resolved",
+      // Project registry events
+      PROJECT_CREATED: "project:created",
+      // Notes events
+      NOTES_UPDATED: "notes:updated",
+      NOTES_TREE_CHANGED: "notes:tree-changed",
+      // Config events
+      CONFIG_CHANGED: "config:changed",
+      // Audio capture events
+      AUDIO_STARTED: "audio:started",
+      AUDIO_STOPPED: "audio:stopped",
+      AUDIO_CHUNK_SAVED: "audio:chunk-saved",
+      AUDIO_ERROR: "audio:error",
+      AUDIO_TRANSCRIPTION_COMPLETE: "audio:transcription-complete",
+      // System health events
+      SYSTEM_HEALTH: "system:health",
+      // Mobile client incidents (a freeze/crash line arrived in an uploaded iOS log)
+      CLIENT_INCIDENT: "client:incident",
+      // Cloud-companion setup job progress (never carries the pairing code)
+      CLOUD_SETUP_UPDATE: "cloud-setup:update"
+    };
+    EVENT_HISTORY_SIZE = 200;
+    eventHistory = [];
+    KEY_BUS_EVENTS = /* @__PURE__ */ new Set([
+      "session:start",
+      "session:send",
+      "session:started",
+      "session:ended",
+      "session:deleted",
+      "session:content-updated",
+      "session:result",
+      "session:error",
+      "session:status-changed",
+      "subagent:start",
+      "subagent:result",
+      "subagent:error",
+      "task:created",
+      "task:updated",
+      "task:completed",
+      "task:deleted",
+      "task:unblocked"
+    ]);
+    EventBus = class {
+      subscribers = /* @__PURE__ */ new Map();
+      /**
+       * Register a named subscriber.
+       * Events are delivered only when the subscriber's name is in the event's destinations
+       * (or destinations includes "*"), unless `global: true` is set — then the subscriber
+       * receives ALL events regardless of destinations.
+       */
+      subscribe(name, handler, filter) {
+        if (filter && typeof filter === "object" && ("global" in filter || "interest" in filter || "filter" in filter)) {
+          this.subscribers.set(name, { name, handler, filter: filter.filter, global: filter.global, interest: filter.interest });
+        } else {
+          this.subscribers.set(name, { name, handler, filter });
+        }
+      }
+      /**
+       * Remove a subscriber by name.
+       */
+      unsubscribe(name) {
+        this.subscribers.delete(name);
+      }
+      emit(name, data, destinations, options) {
+        const event = {
+          name,
+          data,
+          destinations,
+          urgency: options?.urgency ?? "normal",
+          timestamp: Date.now(),
+          source: options?.source ?? "unknown",
+          traceId: randomBytes(4).toString("hex"),
+          ...options?.reemit ? { reemit: true } : {}
+        };
+        eventHistory.push(event);
+        if (eventHistory.length > EVENT_HISTORY_SIZE) {
+          eventHistory.shift();
+        }
+        log.bus.debug(`emit ${name}`, { traceId: event.traceId, destinations, source: options?.source });
+        if (KEY_BUS_EVENTS.has(name)) {
+          log.bus.info(`emit ${name}`, { traceId: event.traceId, destinations, source: options?.source });
+        }
+        for (const [, subscriber] of this.subscribers) {
+          if (subscriber.global && event.reemit) continue;
+          if (!subscriber.global && !destinations.includes("*") && !destinations.includes(subscriber.name)) {
+            continue;
+          }
+          if (subscriber.global && subscriber.interest && !subscriber.interest.some((p) => name.startsWith(p))) {
+            continue;
+          }
+          if (subscriber.filter && !subscriber.filter(event)) {
+            continue;
+          }
+          try {
+            log.bus.debug("event delivered", { name, subscriber: subscriber.name, traceId: event.traceId });
+            const result = subscriber.handler(event);
+            if (result && typeof result.then === "function") {
+              result.catch((err) => {
+                log.bus.error(`subscriber "${subscriber.name}" threw on event "${name}" (async)`, {
+                  eventName: name,
+                  traceId: event.traceId,
+                  error: err instanceof Error ? err.message : String(err),
+                  stack: err instanceof Error ? err.stack : void 0
+                });
+              });
+            }
+          } catch (err) {
+            log.bus.error(`subscriber "${subscriber.name}" threw on event "${name}"`, {
+              eventName: name,
+              traceId: event.traceId,
+              error: err instanceof Error ? err.message : String(err),
+              stack: err instanceof Error ? err.stack : void 0
+            });
+          }
+        }
+      }
+      /**
+       * Check if a subscriber is registered.
+       */
+      has(name) {
+        return this.subscribers.has(name);
+      }
+      /**
+       * Remove all subscribers.
+       */
+      clear() {
+        this.subscribers.clear();
+      }
+    };
+    bus = new EventBus();
+  }
+});
+
+// src/core/integration-registry.ts
+var noopLocalSync, IntegrationRegistry, registry;
+var init_integration_registry = __esm({
+  "src/core/integration-registry.ts"() {
+    "use strict";
+    noopLocalSync = {
+      createTask: async () => null,
+      deleteTask: async () => {
+      },
+      updateTitle: async () => {
+      },
+      updateDescription: async () => {
+      },
+      updateSummary: async () => {
+      },
+      updateNote: async () => {
+      },
+      updateConversationLog: async () => {
+      },
+      updatePriority: async () => {
+      },
+      updatePhase: async () => {
+      },
+      updateDueDate: async () => {
+      },
+      updateStar: async () => {
+      },
+      updateProject: async () => {
+      },
+      updateDependencies: async () => {
+      },
+      associateSubtask: async () => {
+      },
+      disassociateSubtask: async () => {
+      },
+      pushTask: async () => ({ serverTimestamp: (/* @__PURE__ */ new Date()).toISOString() }),
+      syncPoll: async () => {
+      }
+    };
+    IntegrationRegistry = class {
+      plugins = /* @__PURE__ */ new Map();
+      /** Register a plugin. Throws if duplicate ID. */
+      register(id, plugin) {
+        if (this.plugins.has(id)) {
+          throw new Error(`Plugin "${id}" is already registered.`);
+        }
+        this.plugins.set(id, plugin);
+      }
+      /** Get a plugin by ID. Returns undefined if not found. */
+      get(id) {
+        return this.plugins.get(id);
+      }
+      /** Get all registered plugins. */
+      getAll() {
+        return [...this.plugins.values()];
+      }
+      /** Check if a plugin is registered. */
+      has(id) {
+        return this.plugins.has(id);
+      }
+      /**
+       * Find the plugin that claims ownership of a project.
+       * Iterates claims by priority (highest first). First match wins.
+       * Always returns something — 'local' plugin is the universal fallback (priority -1).
+       *
+       * Inbox (the empty project) is structurally unclaimable, so callers never ask
+       * about it — it is always 'local'.
+       */
+      async getForProject(project) {
+        const claimable = [...this.plugins.values()].filter((p) => p.claim).sort((a, b) => b.claim.priority - a.claim.priority);
+        for (const plugin of claimable) {
+          const claimed = await plugin.claim.fn(project);
+          if (claimed) return plugin;
+        }
+        const local = this.plugins.get("local");
+        if (local) return local;
+        throw new Error("No plugin registered for project and no local fallback found.");
+      }
+      /** Remove all plugins (useful for testing). Re-registers the local fallback. */
+      clear() {
+        this.plugins.clear();
+        this.ensureLocalFallback();
+      }
+      /** Ensure the local fallback plugin is registered. Called at init and after clear(). */
+      ensureLocalFallback() {
+        if (this.plugins.has("local")) return;
+        this.plugins.set("local", {
+          id: "local",
+          name: "Local (fallback)",
+          config: {},
+          sync: noopLocalSync,
+          claim: { fn: (() => true), priority: -1 },
+          migrations: [],
+          httpRoutes: []
+        });
+      }
+    };
+    registry = new IntegrationRegistry();
+    registry.ensureLocalFallback();
+  }
+});
+
+// src/core/task-db.ts
+import Database from "better-sqlite3";
+import fs9 from "fs";
+import path9 from "path";
+import yaml2 from "js-yaml";
+function getDb() {
+  if (db) return db;
+  if (initAttempted) throw initError;
+  initAttempted = true;
+  try {
+    fs9.mkdirSync(path9.dirname(TASK_DB_PATH), { recursive: true });
+    const handle = new Database(TASK_DB_PATH);
+    handle.pragma("journal_mode = WAL");
+    handle.pragma("busy_timeout = 5000");
+    handle.pragma("wal_autocheckpoint = 1000");
+    handle.pragma("synchronous = NORMAL");
+    handle.pragma("foreign_keys = ON");
+    handle.exec(SCHEMA_SQL);
+    runOneTimeMigrations(handle);
+    let checkpoint = null;
+    try {
+      checkpoint = handle.pragma("wal_checkpoint(TRUNCATE)");
+    } catch (err) {
+      log.task.warn("task-db: WAL checkpoint on open failed", { err: String(err) });
+    }
+    db = handle;
+    log.task.info("task-db opened", { path: TASK_DB_PATH });
+    log.task.info("task-db: WAL checkpoint on open", { result: checkpoint });
+    return db;
+  } catch (err) {
+    initError = err;
+    log.task.error("task-db open failed", { path: TASK_DB_PATH, err: String(err) });
+    throw err;
+  }
+}
+function transaction(fn) {
+  const handle = getDb();
+  if (!handle) {
+    throw new Error("task-db: transaction() called before database was successfully opened");
+  }
+  const tx = handle.transaction(fn);
+  return tx(handle);
+}
+function rowToTask(row) {
+  let task = {};
+  if (row.payload != null && row.payload !== "") {
+    try {
+      const parsed = JSON.parse(row.payload);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        task = { ...parsed };
+      }
+    } catch (err) {
+      log.task.warn("rowToTask: payload JSON parse failed", { id: row.id, err: String(err) });
+    }
+  }
+  for (const col of EXPLICIT_TASK_COLUMNS) {
+    const val = row[col];
+    if (val === void 0 || val === null) continue;
+    if (JSON_COLUMNS.has(col)) {
+      if (val === "") continue;
+      try {
+        task[col] = JSON.parse(val);
+      } catch (err) {
+        log.task.warn("rowToTask: JSON column parse failed", { id: row.id, col, err: String(err) });
+      }
+    } else if (col === "pinned") {
+      task.pinned = val === 1 || val === true;
+    } else {
+      task[col] = val;
+    }
+  }
+  if (row._synced_at != null && row._synced_at !== "") {
+    task._syncedAt = row._synced_at;
+  }
+  if (typeof task.project !== "string") task.project = "";
+  if (typeof task.session_ids === "undefined") task.session_ids = [];
+  if (typeof task.description === "undefined") task.description = "";
+  if (typeof task.summary === "undefined") task.summary = "";
+  if (typeof task.note === "undefined") task.note = "";
+  return task;
+}
+function taskToRow(task) {
+  const row = {};
+  for (const col of EXPLICIT_TASK_COLUMNS) {
+    if (col === "_synced_at") continue;
+    if (!(col in task)) continue;
+    const val = task[col];
+    if (val === void 0) continue;
+    if (JSON_COLUMNS.has(col)) {
+      row[col] = val === null ? null : JSON.stringify(val);
+    } else if (col === "pinned") {
+      row.pinned = val ? 1 : 0;
+    } else {
+      row[col] = val;
+    }
+  }
+  if ("_syncedAt" in task) {
+    row._synced_at = task._syncedAt ?? null;
+  }
+  const payload = {};
+  let hasPayload = false;
+  for (const key of Object.keys(task)) {
+    if (EXPLICIT_TASK_KEYS.has(key)) continue;
+    if (RETIRED_TASK_KEYS.has(key)) continue;
+    const val = task[key];
+    if (val === void 0) continue;
+    payload[key] = val;
+    hasPayload = true;
+  }
+  if (hasPayload) {
+    row.payload = JSON.stringify(payload);
+  } else if ("payload" in task) {
+    row.payload = null;
+  }
+  return row;
+}
+function runOneTimeMigrations(handle) {
+  const current = handle.pragma("user_version", { simple: true });
+  if (current >= SCHEMA_VERSION) return;
+  if (current < 2) {
+    const staleIndexes = handle.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE 'idx_tasks_ext_%'"
+    ).all();
+    for (const { name } of staleIndexes) {
+      handle.exec(`DROP INDEX IF EXISTS "${name}";`);
+    }
+    handle.exec(`DROP TABLE IF EXISTS task_projects;`);
+  }
+  if (current < 3) {
+    const cols = handle.prepare(`PRAGMA table_info(task_groups)`).all();
+    if (!cols.some((c) => c.name === "hidden")) {
+      handle.exec(`ALTER TABLE task_groups ADD COLUMN hidden INTEGER NOT NULL DEFAULT 0;`);
+    }
+  }
+  if (current < 4) {
+    const cols = handle.prepare(`PRAGMA table_info(tasks)`).all();
+    if (!cols.some((c) => c.name === "start_date")) {
+      handle.exec(`ALTER TABLE tasks ADD COLUMN start_date TEXT;`);
+    }
+  }
+  if (current < 5) {
+    migrateToProjectOnly(handle);
+  }
+  if (current < 6) {
+    migrateReadMarkerToUnread(handle);
+  }
+  handle.pragma("user_version = " + SCHEMA_VERSION);
+}
+function legacyListName(category, project) {
+  if (!category || !project || category.toLowerCase() === project.toLowerCase()) {
+    return category || project;
+  }
+  return `${category} / ${project}`;
+}
+function pickMajoritySource(weights, projectName) {
+  const ranked = [...weights.entries()].filter(([src, n]) => src && src !== "local" && n > 0).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
+  if (ranked.length === 0) return "local";
+  if (ranked.length === 1) return ranked[0][0];
+  if (ranked[0][1] > ranked[1][1]) {
+    log.task.warn("task-db: project merged categories from several providers, majority wins", {
+      project: projectName,
+      source: ranked[0][0],
+      weights: Object.fromEntries(ranked)
+    });
+    return ranked[0][0];
+  }
+  log.task.warn("task-db: project merged categories with tied sources, using local", {
+    project: projectName,
+    weights: Object.fromEntries(ranked)
+  });
+  return "local";
+}
+function parseYamlObject(text) {
+  if (!text || !text.trim()) return null;
+  try {
+    const parsed = yaml2.load(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch (err) {
+    log.task.warn("task-db v5: metadata YAML parse failed", { err: String(err) });
+  }
+  return null;
+}
+function mergeFirstWins(target, src, context) {
+  for (const [key, value] of Object.entries(src)) {
+    if (key in target) {
+      if (JSON.stringify(target[key]) !== JSON.stringify(value)) {
+        log.task.warn("task-db v5: metadata conflict, keeping first value", { context, key });
+      }
+      continue;
+    }
+    target[key] = value;
+  }
+}
+function promoteLegacyGroup(category, project) {
+  const cat = (category ?? "").trim();
+  const proj = (project ?? "").trim();
+  if (proj.toLowerCase() === "quick start") return "";
+  if (!proj || proj.toLowerCase() === cat.toLowerCase()) {
+    if (!cat || cat.toLowerCase() === "inbox") return "";
+    return cat;
+  }
+  return proj;
+}
+function migrateToProjectOnly(handle) {
+  handle.exec(TASK_PROJECTS_DDL);
+  const cols = handle.prepare(`PRAGMA table_info(tasks)`).all();
+  if (!cols.some((c) => c.name === "category")) {
+    return;
+  }
+  try {
+    handle.pragma("wal_checkpoint(TRUNCATE)");
+    if (!fs9.existsSync(TASK_DB_PRE_V5_BACKUP_PATH)) {
+      fs9.copyFileSync(TASK_DB_PATH, TASK_DB_PRE_V5_BACKUP_PATH);
+      log.task.info("task-db v5: wrote pre-migration backup", { path: TASK_DB_PRE_V5_BACKUP_PATH });
+    }
+  } catch (err) {
+    log.task.warn("task-db v5: backup failed (continuing)", {
+      path: TASK_DB_PRE_V5_BACKUP_PATH,
+      err: String(err)
+    });
+  }
+  const summary = handle.transaction(() => {
+    const sentinels = handle.prepare(
+      `SELECT category, project, title, description FROM tasks
+          WHERE title IN ('.metadata_project', '.metadata_category')`
+    ).all();
+    const catMeta = /* @__PURE__ */ new Map();
+    const projMeta = /* @__PURE__ */ new Map();
+    const sentinelPairs = [];
+    for (const row of sentinels) {
+      const cat = (row.category ?? "").trim().toLowerCase();
+      const settings = parseYamlObject(row.description);
+      if (row.title === ".metadata_category") {
+        if (!settings) continue;
+        const bucket2 = catMeta.get(cat) ?? {};
+        mergeFirstWins(bucket2, settings, `category:${cat}`);
+        catMeta.set(cat, bucket2);
+        continue;
+      }
+      sentinelPairs.push({ category: row.category, project: row.project });
+      if (!settings) continue;
+      const key = `${cat}\0${(row.project ?? "").trim().toLowerCase()}`;
+      const bucket = projMeta.get(key) ?? {};
+      mergeFirstWins(bucket, settings, `project:${key}`);
+      projMeta.set(key, bucket);
+    }
+    handle.prepare(`DELETE FROM tasks WHERE title IN ('.metadata_project', '.metadata_category')`).run();
+    const groups = handle.prepare(`SELECT category, project, COUNT(*) AS n FROM tasks GROUP BY category, project`).all().map((r) => ({
+      category: r.category,
+      project: r.project,
+      taskCount: r.n,
+      target: promoteLegacyGroup(r.category ?? "", r.project ?? ""),
+      final: ""
+    }));
+    for (const pair of sentinelPairs) {
+      const exists = groups.some((g) => g.category === pair.category && g.project === pair.project);
+      if (exists) continue;
+      groups.push({
+        category: pair.category,
+        project: pair.project,
+        taskCount: 0,
+        target: promoteLegacyGroup(pair.category ?? "", pair.project ?? ""),
+        final: ""
+      });
+    }
+    const spellings = /* @__PURE__ */ new Map();
+    for (const g of groups) {
+      if (!g.target) continue;
+      const lower = g.target.toLowerCase();
+      const bySpelling = spellings.get(lower) ?? /* @__PURE__ */ new Map();
+      bySpelling.set(g.target, (bySpelling.get(g.target) ?? 0) + g.taskCount);
+      spellings.set(lower, bySpelling);
+    }
+    const canonical = /* @__PURE__ */ new Map();
+    for (const [lower, bySpelling] of spellings) {
+      const best = [...bySpelling.entries()].sort(
+        (a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+      )[0][0];
+      canonical.set(lower, best);
+    }
+    for (const g of groups) {
+      g.final = g.target ? canonical.get(g.target.toLowerCase()) ?? g.target : "";
+    }
+    const updateGroup = handle.prepare(
+      `UPDATE tasks SET project = @project WHERE category IS @category AND project IS @old`
+    );
+    for (const g of groups) {
+      if ((g.project ?? "") === g.final) continue;
+      updateGroup.run({ project: g.final, category: g.category, old: g.project });
+    }
+    let legacyCatSources = /* @__PURE__ */ new Map();
+    let catOrder = [];
+    try {
+      const rows = handle.prepare(
+        `SELECT name, source FROM task_categories
+            ORDER BY (order_index IS NULL), order_index, name`
+      ).all();
+      catOrder = rows.map((r) => r.name);
+      legacyCatSources = new Map(rows.map((r) => [r.name.trim().toLowerCase(), r.source || "local"]));
+    } catch {
+    }
+    const contributors = /* @__PURE__ */ new Map();
+    for (const g of groups) {
+      if (!g.final) continue;
+      const key = g.final.toLowerCase();
+      const list = contributors.get(key) ?? [];
+      list.push(g);
+      contributors.set(key, list);
+    }
+    const orderedKeys = [];
+    const seen = /* @__PURE__ */ new Set();
+    const catsInOrder = [
+      ...catOrder,
+      ...[...new Set(groups.map((g) => (g.category ?? "").trim()))].filter((c) => !catOrder.some((k) => k.trim().toLowerCase() === c.toLowerCase())).sort()
+    ];
+    for (const cat of catsInOrder) {
+      const names = [
+        ...new Set(
+          groups.filter((g) => g.final && (g.category ?? "").trim().toLowerCase() === cat.trim().toLowerCase()).map((g) => g.final)
+        )
+      ].sort();
+      for (const name of names) {
+        const key = name.toLowerCase();
+        if (seen.has(key)) continue;
+        seen.add(key);
+        orderedKeys.push(key);
+      }
+    }
+    for (const key of [...contributors.keys()].sort()) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        orderedKeys.push(key);
+      }
+    }
+    const insertProject = handle.prepare(
+      `INSERT INTO task_projects (name, source, order_index, metadata)
+       VALUES (@name, @source, @order_index, @metadata)
+       ON CONFLICT(name) DO NOTHING`
+    );
+    const selectMinority = handle.prepare(
+      `SELECT id, source FROM tasks WHERE project = @name COLLATE NOCASE AND source IS NOT @source`
+    );
+    const normalizeMinority = handle.prepare(
+      `UPDATE tasks SET source = @source, ext = NULL, sync_error = NULL, updated_at = @now,
+         payload = CASE WHEN payload IS NOT NULL AND json_valid(payload)
+                        THEN json_remove(payload, '$.external_url') ELSE payload END
+        WHERE id = @id`
+    );
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    let normalizedMinorityTotal = 0;
+    const perProject = [];
+    orderedKeys.forEach((key, index) => {
+      const groupsForProject = contributors.get(key);
+      if (!groupsForProject || groupsForProject.length === 0) return;
+      const name = groupsForProject[0].final;
+      const taskCount = groupsForProject.reduce((sum, g) => sum + g.taskCount, 0);
+      const providerWeights = /* @__PURE__ */ new Map();
+      for (const g of groupsForProject) {
+        const src = legacyCatSources.get((g.category ?? "").trim().toLowerCase()) ?? "local";
+        if (!src || src === "local") continue;
+        providerWeights.set(src, (providerWeights.get(src) ?? 0) + g.taskCount);
+      }
+      const source = pickMajoritySource(providerWeights, name);
+      const base = {};
+      const overlay = {};
+      for (const g of groupsForProject) {
+        const cat = (g.category ?? "").trim().toLowerCase();
+        const fromCat = catMeta.get(cat);
+        if (fromCat) mergeFirstWins(base, fromCat, `${name}<-category:${cat}`);
+        const fromProj = projMeta.get(`${cat}\0${(g.project ?? "").trim().toLowerCase()}`);
+        if (fromProj) mergeFirstWins(overlay, fromProj, `${name}<-project:${cat}/${g.project ?? ""}`);
+      }
+      const metadata = { ...base, ...overlay };
+      const legacyCats = [
+        ...new Set(groupsForProject.map((g) => (g.category ?? "").trim()).filter(Boolean))
+      ].sort();
+      if (legacyCats.length === 1) metadata.legacy_category = legacyCats[0];
+      else if (legacyCats.length > 1) metadata.legacy_category = legacyCats;
+      if (source === "ms-todo") {
+        const owned = groupsForProject.filter((g) => (legacyCatSources.get((g.category ?? "").trim().toLowerCase()) ?? "local") === source).sort((a, b) => b.taskCount - a.taskCount);
+        const pick = owned[0];
+        if (pick) {
+          const oldList = legacyListName((pick.category ?? "").trim(), (pick.project ?? "").trim());
+          if (oldList && oldList !== name) metadata.remote_list = oldList;
+          if (owned.length > 1) {
+            log.task.warn("task-db v5: ambiguous remote list for merged project", {
+              project: name,
+              picked: oldList,
+              candidates: owned.length
+            });
+          }
+        }
+      }
+      insertProject.run({
+        name,
+        source,
+        order_index: index,
+        metadata: Object.keys(metadata).length > 0 ? JSON.stringify(metadata) : null
+      });
+      const minority = selectMinority.all({ name, source });
+      const minorityBySource = {};
+      for (const row of minority) {
+        normalizeMinority.run({ id: row.id, source, now: nowIso });
+        const from = row.source ?? "local";
+        minorityBySource[from] = (minorityBySource[from] ?? 0) + 1;
+      }
+      if (minority.length > 0) {
+        log.task.warn("task-db v5: normalized minority-source tasks onto the project claim", {
+          project: name,
+          source,
+          tasks: minority.length,
+          from: minorityBySource
+        });
+        normalizedMinorityTotal += minority.length;
+      }
+      perProject.push({
+        project: name,
+        source,
+        tasks: taskCount,
+        from: groupsForProject.map((g) => `${g.category ?? ""}/${g.project ?? ""}`),
+        remote_list: metadata.remote_list,
+        ...minority.length > 0 ? { normalized_minority: minority.length, normalized_from: minorityBySource } : {}
+      });
+    });
+    const inboxCount = groups.filter((g) => !g.final).reduce((sum, g) => sum + g.taskCount, 0);
+    const inboxProviderRows = handle.prepare(
+      `SELECT id, source FROM tasks
+          WHERE (project IS NULL OR project = '') AND source IS NOT NULL AND source != 'local'`
+    ).all();
+    const inboxProviderBySource = {};
+    if (inboxProviderRows.length > 0) {
+      const toLocal = handle.prepare(
+        `UPDATE tasks SET source = 'local', ext = NULL, sync_error = NULL, updated_at = @now,
+           payload = CASE WHEN payload IS NOT NULL AND json_valid(payload)
+                          THEN json_remove(payload, '$.external_url') ELSE payload END
+          WHERE id = @id`
+      );
+      for (const row of inboxProviderRows) {
+        toLocal.run({ id: row.id, now: nowIso });
+        inboxProviderBySource[row.source] = (inboxProviderBySource[row.source] ?? 0) + 1;
+      }
+      log.task.warn("task-db v5: reset provider-sourced Inbox tasks to local", {
+        tasks: inboxProviderRows.length,
+        from: inboxProviderBySource
+      });
+    }
+    handle.exec(`DROP INDEX IF EXISTS tasks_category_project;`);
+    handle.exec(`ALTER TABLE tasks DROP COLUMN category;`);
+    handle.exec(`DROP TABLE IF EXISTS task_categories;`);
+    return {
+      perProject,
+      inboxCount,
+      sentinels: sentinels.length,
+      normalizedMinority: normalizedMinorityTotal,
+      inboxProviderReset: inboxProviderRows.length,
+      inboxProviderResetFrom: inboxProviderBySource
+    };
+  })();
+  log.task.info("task-db v5: category removed \u2014 project is now the only grouping layer", {
+    projects: summary.perProject.length,
+    inboxTasks: summary.inboxCount,
+    sentinelsAbsorbed: summary.sentinels,
+    normalizedMinoritySourceTasks: summary.normalizedMinority,
+    inboxProviderTasksResetToLocal: summary.inboxProviderReset,
+    inboxProviderResetFrom: summary.inboxProviderResetFrom,
+    perProject: summary.perProject
+  });
+}
+function migrateReadMarkerToUnread(handle) {
+  const summary = handle.transaction(() => {
+    const carried = handle.prepare(
+      `UPDATE tasks SET payload = json_set(payload, '$.unread', json('true'))
+          WHERE payload IS NOT NULL AND json_valid(payload)
+            AND json_extract(payload, '$.needs_attention') IN (1, 'true')
+            AND json_extract(payload, '$.unread') IS NULL`
+    ).run().changes;
+    const cleared = handle.prepare(
+      `UPDATE tasks SET payload = json_remove(payload, '$.needs_attention')
+          WHERE payload IS NOT NULL AND json_valid(payload)
+            AND json_extract(payload, '$.needs_attention') IS NOT NULL`
+    ).run().changes;
+    return { carried, cleared };
+  })();
+  if (summary.cleared > 0) {
+    log.task.info("task-db v6: read marker renamed needs_attention \u2192 unread", summary);
+  }
+}
+var TASK_DB_PATH, EXPLICIT_TASK_COLUMNS, JSON_COLUMNS, EXPLICIT_TASK_KEYS, RETIRED_TASK_KEYS, db, initAttempted, initError, TASK_COLUMNS, TASK_PROJECTS_DDL, SCHEMA_SQL, SCHEMA_VERSION, TASK_DB_PRE_V5_BACKUP_PATH;
+var init_task_db = __esm({
+  "src/core/task-db.ts"() {
+    "use strict";
+    init_constants();
+    init_logging();
+    TASK_DB_PATH = path9.join(TASKS_DIR, "tasks.sqlite");
+    EXPLICIT_TASK_COLUMNS = [
+      "id",
+      "title",
+      "project",
+      "status",
+      "phase",
+      "priority",
+      "source",
+      "parent_task_id",
+      "due_date",
+      "start_date",
+      "created_at",
+      "updated_at",
+      "completed_at",
+      "sprint",
+      "focus_tier",
+      "pinned",
+      "ext",
+      "tags",
+      "depends_on",
+      "session_ids",
+      "note",
+      "summary",
+      "description",
+      "conversation_log",
+      "sync_error",
+      "_synced_at"
+    ];
+    JSON_COLUMNS = /* @__PURE__ */ new Set([
+      "ext",
+      "tags",
+      "depends_on",
+      "session_ids",
+      "conversation_log"
+    ]);
+    EXPLICIT_TASK_KEYS = /* @__PURE__ */ new Set([
+      ...EXPLICIT_TASK_COLUMNS,
+      // Task type uses camelCase `_syncedAt`; column is snake `_synced_at`.
+      "_syncedAt"
+    ]);
+    RETIRED_TASK_KEYS = /* @__PURE__ */ new Set(["category", "needs_attention"]);
+    db = null;
+    initAttempted = false;
+    initError = null;
+    TASK_COLUMNS = EXPLICIT_TASK_COLUMNS;
+    TASK_PROJECTS_DDL = `
+  CREATE TABLE IF NOT EXISTS task_projects (
+    name        TEXT PRIMARY KEY COLLATE NOCASE,
+    source      TEXT NOT NULL DEFAULT 'local',
+    order_index INTEGER,
+    metadata    TEXT
+  );
+`;
+    SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    project TEXT,
+    status TEXT,
+    phase TEXT,
+    priority TEXT,
+    source TEXT,
+    parent_task_id TEXT,
+    due_date TEXT,
+    start_date TEXT,
+    created_at TEXT,
+    updated_at TEXT,
+    completed_at TEXT,
+    sprint TEXT,
+    focus_tier TEXT,
+    pinned INTEGER DEFAULT 0,
+    ext TEXT,
+    tags TEXT,
+    depends_on TEXT,
+    session_ids TEXT,
+    note TEXT,
+    summary TEXT,
+    description TEXT,
+    conversation_log TEXT,
+    sync_error TEXT,
+    _synced_at TEXT,
+    payload TEXT
+  );
+  CREATE INDEX IF NOT EXISTS tasks_project ON tasks(project);
+  CREATE INDEX IF NOT EXISTS tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS tasks_source ON tasks(source);
+  CREATE INDEX IF NOT EXISTS tasks_updated_at ON tasks(updated_at);
+  CREATE INDEX IF NOT EXISTS tasks_parent ON tasks(parent_task_id);
+
+  -- Plugin ext-id indexes are no longer baked into SCHEMA_SQL \u2014 each plugin
+  -- declares its own ext-index spec via PluginApi.registerExtIndex, and the
+  -- loader calls ensureExtIndexes() after plugins finish loading. This keeps
+  -- core agnostic to which plugins exist and lets external plugins (loaded
+  -- from ~/.open-walnut/plugins/) bring their own indexes without touching
+  -- core code.
+
+  ${TASK_PROJECTS_DDL}
+
+  -- Virtual task-group name registry (local-only). Maps Task.group_id (stored in
+  -- the tasks.payload blob) to a human-readable group label. Membership itself
+  -- lives on the tasks (tasks.group_id); this table only holds the names.
+  CREATE TABLE IF NOT EXISTS task_groups (
+    id TEXT PRIMARY KEY,
+    label TEXT NOT NULL,
+    hidden INTEGER NOT NULL DEFAULT 0
+  );
+
+  -- User-defined focus tiers (local-only). Ids are ct_* strings referenced by
+  -- tasks.focus_tier; order_index preserves the user's Settings ordering.
+  CREATE TABLE IF NOT EXISTS custom_tiers (
+    id TEXT PRIMARY KEY,
+    label TEXT NOT NULL,
+    order_index INTEGER
+  );
+`;
+    SCHEMA_VERSION = 6;
+    TASK_DB_PRE_V5_BACKUP_PATH = `${TASK_DB_PATH}.pre-v5.backup`;
+  }
+});
+
+// src/core/task-db-migration.ts
+import fs10 from "fs";
+import path10 from "path";
+import yaml3 from "js-yaml";
+async function runMigrationIfNeeded() {
+  const db2 = getDb();
+  if (!db2) {
+    return { migrated: false, count: 0 };
+  }
+  const existing = db2.prepare("SELECT COUNT(*) AS n FROM tasks").get();
+  if (existing.n > 0) {
+    return { migrated: false, count: existing.n };
+  }
+  if (!fs10.existsSync(TASKS_FILE)) {
+    return { migrated: false, count: 0 };
+  }
+  const store = await readJsonFile(TASKS_FILE, { version: 1, tasks: [] });
+  const rawTasks = Array.isArray(store.tasks) ? store.tasks : [];
+  const legacyCategories = store.categories ?? {};
+  const tasks = rawTasks.filter(
+    (t) => t?.title !== ".metadata_project" && t?.title !== ".metadata_category"
+  );
+  const sentinels = rawTasks.filter(
+    (t) => t?.title === ".metadata_project" || t?.title === ".metadata_category"
+  );
+  const targetOf = (t) => promoteLegacyGroup(t.category ?? "", t.project ?? "");
+  const spellingCounts = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    const target = targetOf(t);
+    if (!target) continue;
+    const lower = target.toLowerCase();
+    const bucket = spellingCounts.get(lower) ?? /* @__PURE__ */ new Map();
+    bucket.set(target, (bucket.get(target) ?? 0) + 1);
+    spellingCounts.set(lower, bucket);
+  }
+  const canonical = /* @__PURE__ */ new Map();
+  for (const [lower, bucket] of spellingCounts) {
+    canonical.set(
+      lower,
+      [...bucket.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))[0][0]
+    );
+  }
+  const finalProjectOf = (t) => {
+    const target = targetOf(t);
+    return target ? canonical.get(target.toLowerCase()) ?? target : "";
+  };
+  const projectRows = /* @__PURE__ */ new Map();
+  const categorySource = (category) => {
+    const key = Object.keys(legacyCategories).find((k) => k.toLowerCase() === category.trim().toLowerCase());
+    return key ? String(legacyCategories[key]?.source ?? "local") : "local";
+  };
+  for (const t of tasks) {
+    const name = finalProjectOf(t);
+    if (!name) continue;
+    const row = projectRows.get(name.toLowerCase()) ?? { name, source: "local", metadata: {}, weights: /* @__PURE__ */ new Map(), ownedGroups: /* @__PURE__ */ new Map() };
+    const legacyCat = (t.category ?? "").trim();
+    const src = categorySource(legacyCat);
+    if (src !== "local") {
+      row.weights.set(src, (row.weights.get(src) ?? 0) + 1);
+      const legacyProj = (t.project ?? "").trim();
+      const groupKey = `${legacyCat.toLowerCase()}/${legacyProj.toLowerCase()}`;
+      const group = row.ownedGroups.get(groupKey) ?? { category: legacyCat, project: legacyProj, count: 0 };
+      group.count += 1;
+      row.ownedGroups.set(groupKey, group);
+    }
+    if (legacyCat) {
+      const existing2 = row.metadata.legacy_category;
+      if (existing2 === void 0) row.metadata.legacy_category = legacyCat;
+      else if (Array.isArray(existing2)) {
+        if (!existing2.includes(legacyCat)) existing2.push(legacyCat);
+      } else if (existing2 !== legacyCat) {
+        row.metadata.legacy_category = [existing2, legacyCat].sort();
+      }
+    }
+    projectRows.set(name.toLowerCase(), row);
+  }
+  for (const row of projectRows.values()) {
+    row.source = pickMajoritySource(row.weights, row.name);
+    if (row.source !== "ms-todo") continue;
+    const owned = [...row.ownedGroups.values()].filter((g) => categorySource(g.category) === "ms-todo").sort((a, b) => b.count - a.count || (a.project < b.project ? -1 : 1));
+    const pick = owned[0];
+    if (!pick) continue;
+    const oldList = legacyListName(pick.category, pick.project);
+    if (oldList && oldList.toLowerCase() !== row.name.toLowerCase()) {
+      row.metadata.remote_list = oldList;
+    }
+    if (owned.length > 1) {
+      log.task.warn("task-db migration: ambiguous remote list for merged project", {
+        project: row.name,
+        picked: oldList,
+        candidates: owned.length
+      });
+    }
+  }
+  for (const sentinel of sentinels) {
+    const name = finalProjectOf(sentinel);
+    if (!name) continue;
+    const row = projectRows.get(name.toLowerCase());
+    if (!row) continue;
+    let settings;
+    try {
+      settings = yaml3.load(sentinel.description ?? "");
+    } catch {
+      settings = null;
+    }
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) continue;
+    const overwrite = sentinel.title === ".metadata_project";
+    for (const [key, value] of Object.entries(settings)) {
+      if (overwrite || !(key in row.metadata)) row.metadata[key] = value;
+    }
+  }
+  const taskInsertCols = [...TASK_COLUMNS, "payload"];
+  const taskInsertSql = "INSERT INTO tasks (" + taskInsertCols.join(", ") + ") VALUES (" + taskInsertCols.map((c) => "@" + c).join(", ") + ")";
+  const projectInsertSql = "INSERT INTO task_projects (name, source, order_index, metadata) VALUES (@name, @source, @order_index, @metadata) ON CONFLICT(name) DO NOTHING";
+  const sourceNormalized = [];
+  transaction((h) => {
+    const insertTask = h.prepare(taskInsertSql);
+    const insertProject = h.prepare(projectInsertSql);
+    [...projectRows.values()].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).forEach((row, index) => {
+      insertProject.run({
+        name: row.name,
+        source: row.source,
+        order_index: index,
+        metadata: Object.keys(row.metadata).length > 0 ? JSON.stringify(row.metadata) : null
+      });
+    });
+    for (const task of tasks) {
+      if (!task || typeof task !== "object" || typeof task.id !== "string") {
+        log.task.warn("task-db migration: skipping malformed task", {
+          sample: String(task?.id ?? "<no id>")
+        });
+        continue;
+      }
+      if (task.title?.trim().startsWith(".metadata")) continue;
+      const { category: _legacyCategory, ...rest } = task;
+      const project = finalProjectOf(task);
+      const registryRow = project ? projectRows.get(project.toLowerCase()) : void 0;
+      const authoritativeSource = project ? registryRow?.source ?? task.source : "local";
+      const normalized = {};
+      if (task.source !== authoritativeSource) {
+        normalized.source = authoritativeSource;
+        normalized.ext = void 0;
+        normalized.external_url = void 0;
+        normalized.sync_error = void 0;
+        sourceNormalized.push({ id: task.id, from: task.source, to: authoritativeSource, project });
+      }
+      const partial = taskToRow({ ...rest, project, ...normalized });
+      if (normalized.source !== void 0) partial.ext = null;
+      const bound = {};
+      for (const col of taskInsertCols) {
+        bound[col] = partial[col] === void 0 ? null : partial[col];
+      }
+      try {
+        insertTask.run(bound);
+      } catch (err) {
+        log.task.warn("task-db migration: failed to insert task, skipping", {
+          id: task.id,
+          err: String(err)
+        });
+      }
+    }
+  });
+  if (sourceNormalized.length > 0) {
+    log.task.warn("task-db migration: normalized task sources onto the project claim", {
+      tasks: sourceNormalized.length,
+      sample: sourceNormalized.slice(0, 20)
+    });
+  }
+  const after = db2.prepare("SELECT COUNT(*) AS n FROM tasks").get();
+  const count = after.n;
+  const backupPath = path10.join(path10.dirname(TASKS_FILE), "tasks.json.migrated-from-json.backup");
+  try {
+    fs10.copyFileSync(TASKS_FILE, backupPath);
+  } catch (err) {
+    log.task.warn("task-db migration: backup copy failed (non-fatal)", {
+      path: backupPath,
+      err: String(err)
+    });
+  }
+  log.task.info("task-db: migrated tasks from tasks.json", {
+    count,
+    projectCount: projectRows.size
+  });
+  return { migrated: true, count };
+}
+var init_task_db_migration = __esm({
+  "src/core/task-db-migration.ts"() {
+    "use strict";
+    init_constants();
+    init_logging();
+    init_fs();
+    init_task_db();
+  }
+});
+
+// src/core/memory-dir-migration.ts
+import fs11 from "fs";
+import fsp6 from "fs/promises";
+import path11 from "path";
+function bodyOf(content) {
+  const fm = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  return fm ? content.slice(fm[0].length) : content;
+}
+function mergeMemoryContents(base, legacy, legacyLabel) {
+  const legacyBody = bodyOf(legacy).trim();
+  if (!legacyBody) return base;
+  const head = base.endsWith("\n") ? base : `${base}
+`;
+  return `${head}
+## Merged from ${legacyLabel} (legacy)
+
+${legacyBody}
+`;
+}
+function mtimeMs(file) {
+  try {
+    return fs11.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function findCandidates(root) {
+  const out = [];
+  let level1;
+  try {
+    level1 = fs11.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const cat of level1) {
+    if (!cat.isDirectory()) continue;
+    const catDir = path11.join(root, cat.name);
+    if (fs11.existsSync(path11.join(catDir, MEMORY_FILE_NAME))) continue;
+    let level2;
+    try {
+      level2 = fs11.readdirSync(catDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const proj of level2) {
+      if (!proj.isDirectory()) continue;
+      const sourceDir = path11.join(catDir, proj.name);
+      if (!fs11.existsSync(path11.join(sourceDir, MEMORY_FILE_NAME))) continue;
+      out.push({ category: cat.name, project: proj.name, sourceDir });
+    }
+  }
+  return out;
+}
+async function drainDir(from, to) {
+  let entries;
+  try {
+    entries = await fsp6.readdir(from);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const target = path11.join(to, name);
+    if (fs11.existsSync(target)) continue;
+    await fsp6.rename(path11.join(from, name), target).catch((err) => {
+      log.memory.warn("memory-dir migration: entry move failed", {
+        from: path11.join(from, name),
+        to: target,
+        error: String(err)
+      });
+    });
+  }
+  await fsp6.rmdir(from).catch(() => {
+  });
+}
+async function migrateProjectMemoryDirs() {
+  const result = { ran: false, moved: 0, merged: 0 };
+  try {
+    if (!fs11.existsSync(PROJECTS_MEMORY_DIR)) return result;
+    if (fs11.existsSync(MEMORY_DIR_MIGRATION_MARKER)) return result;
+    result.ran = true;
+    const candidates = findCandidates(PROJECTS_MEMORY_DIR);
+    const touchedCategories = new Set(candidates.map((c) => c.category));
+    for (const c of candidates) {
+      const targetDir = path11.join(PROJECTS_MEMORY_DIR, c.project);
+      const label = `${c.category}/${c.project}`;
+      try {
+        if (!fs11.existsSync(targetDir)) {
+          await fsp6.rename(c.sourceDir, targetDir);
+          result.moved += 1;
+          continue;
+        }
+        const sourceMem = path11.join(c.sourceDir, MEMORY_FILE_NAME);
+        const targetMem = path11.join(targetDir, MEMORY_FILE_NAME);
+        if (!fs11.existsSync(targetMem)) {
+          await fsp6.rename(sourceMem, targetMem);
+          await drainDir(c.sourceDir, targetDir);
+          result.moved += 1;
+          continue;
+        }
+        const sourceContent = await fsp6.readFile(sourceMem, "utf-8");
+        const targetContent = await fsp6.readFile(targetMem, "utf-8");
+        const sourceNewer = mtimeMs(sourceMem) > mtimeMs(targetMem);
+        const mergedContent = sourceNewer ? mergeMemoryContents(sourceContent, targetContent, c.project) : mergeMemoryContents(targetContent, sourceContent, label);
+        await fsp6.writeFile(targetMem, mergedContent, "utf-8");
+        await fsp6.rm(sourceMem, { force: true });
+        await drainDir(c.sourceDir, targetDir);
+        result.merged += 1;
+      } catch (err) {
+        log.memory.warn("memory-dir migration: candidate failed (skipped)", {
+          candidate: label,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    for (const cat of touchedCategories) {
+      await fsp6.rmdir(path11.join(PROJECTS_MEMORY_DIR, cat)).catch(() => {
+      });
+    }
+    await fsp6.writeFile(
+      MEMORY_DIR_MIGRATION_MARKER,
+      `migrated ${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+      "utf-8"
+    );
+    if (result.moved > 0 || result.merged > 0) {
+      log.memory.info("memory-dir migration: flattened project memory to one level", {
+        moved: result.moved,
+        merged: result.merged
+      });
+    }
+  } catch (err) {
+    log.memory.warn("memory-dir migration failed (will retry next start)", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return result;
+}
+var MEMORY_DIR_MIGRATION_MARKER, MEMORY_FILE_NAME;
+var init_memory_dir_migration = __esm({
+  "src/core/memory-dir-migration.ts"() {
+    "use strict";
+    init_constants();
+    init_logging();
+    MEMORY_DIR_MIGRATION_MARKER = path11.join(PROJECTS_MEMORY_DIR, ".migrated-project-only");
+    MEMORY_FILE_NAME = "MEMORY.md";
+  }
+});
+
+// src/core/ext-index-registry.ts
+function getExtIndexSpec(source) {
+  return specs.get(source);
+}
+var specs;
+var init_ext_index_registry = __esm({
+  "src/core/ext-index-registry.ts"() {
+    "use strict";
+    specs = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/task-manager.ts
+import fsSync from "fs";
+function invalidateTaskStoreCache() {
+  taskStoreCache = null;
+  taskStoreCacheDataVersion = null;
+}
+function readDataVersion(handle) {
+  try {
+    return handle.pragma("data_version", { simple: true });
+  } catch {
+    return null;
+  }
+}
+function withWriteLock2(fn) {
+  const prev = writeLock2;
+  let resolve;
+  writeLock2 = new Promise((r) => {
+    resolve = r;
+  });
+  return prev.then(() => withFileLock(TASKS_FILE, async () => {
+    writeLockDepth += 1;
+    try {
+      return await fn();
+    } finally {
+      writeLockDepth -= 1;
+    }
+  })).finally(() => {
+    invalidateTaskStoreCache();
+    resolve();
+  });
+}
+function withWriteLockIfFree(fn) {
+  return writeLockDepth > 0 ? fn() : withWriteLock2(fn);
+}
+async function ensureInit() {
+  if (!initialized) {
+    await initDirectories();
+    getDb();
+    await runMigrationIfNeeded();
+    await migrateProjectMemoryDirs();
+    await seedProjectsFromConfig();
+    initialized = true;
+  }
+}
+async function seedProjectsFromConfig() {
+  const config = await getConfig();
+  return withWriteLockIfFree(async () => {
+    const db2 = getDb();
+    const desired = [];
+    let added = 0;
+    transaction((handle) => {
+      const existingRows = handle.prepare("SELECT name FROM task_projects").all();
+      const existing = new Set(existingRows.map((r) => r.name.trim().toLowerCase()));
+      const seen = /* @__PURE__ */ new Set();
+      const addIfNew = (rawName, source) => {
+        const name = (rawName ?? "").trim();
+        if (!name) return;
+        try {
+          assertValidProjectName(name);
+        } catch (err) {
+          log.task.warn("seedProjectsFromConfig: skipping invalid project name", {
+            name,
+            source,
+            err: String(err)
+          });
+          return;
+        }
+        const key = name.toLowerCase();
+        if (seen.has(key) || existing.has(key)) return;
+        seen.add(key);
+        desired.push({ name, source });
+      };
+      const plugins = config.plugins ?? {};
+      for (const [pluginId, cfg] of Object.entries(plugins)) {
+        const reserved = cfg.project;
+        if (typeof reserved === "string" && reserved) addIfNew(reserved, pluginId);
+      }
+      const taskRows = handle.prepare("SELECT project, source, COUNT(*) AS n FROM tasks WHERE project IS NOT NULL AND project != '' GROUP BY project, source ORDER BY n DESC").all();
+      for (const row of taskRows) {
+        addIfNew(row.project, row.source ?? "local");
+      }
+      if (desired.length === 0) return;
+      const nextOrder = handle.prepare("SELECT COALESCE(MAX(order_index), -1) + 1 AS next FROM task_projects").get().next;
+      const stmt = handle.prepare(
+        "INSERT INTO task_projects (name, source, order_index) VALUES (?, ?, ?) ON CONFLICT(name) DO NOTHING"
+      );
+      let idx = nextOrder;
+      for (const { name, source } of desired) {
+        stmt.run(name, source, idx);
+        idx += 1;
+        added += 1;
+      }
+    });
+    void db2;
+    if (added === 0) return;
+    invalidateTaskStoreCache();
+    log.task.info("seeded task_projects", { added });
+  });
+}
+function parseProjectMetadataJson(raw, project) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch (err) {
+    log.task.warn("task_projects: metadata JSON parse failed", { project, err: String(err) });
+  }
+  return void 0;
+}
+async function readStore() {
+  await ensureInit();
+  if (STORE_CACHE_ENABLED && taskStoreCache !== null) {
+    const current = readDataVersion(getDb());
+    if (current !== null && current === taskStoreCacheDataVersion) {
+      return cloneTaskStore(taskStoreCache);
+    }
+    log.task.warn("task store cache dropped: external process wrote the DB", {
+      cachedDataVersion: taskStoreCacheDataVersion,
+      currentDataVersion: current
+    });
+    invalidateTaskStoreCache();
+  }
+  const db2 = getDb();
+  const taskRows = db2.prepare("SELECT * FROM tasks").all();
+  const tasks = taskRows.map(rowToTask);
+  const projectRows = db2.prepare("SELECT name, source, order_index, metadata FROM task_projects ORDER BY (order_index IS NULL), order_index ASC, name ASC").all();
+  const projects = {};
+  for (const row of projectRows) {
+    const metadata = parseProjectMetadataJson(row.metadata, row.name);
+    projects[row.name] = {
+      source: row.source,
+      ...row.order_index != null ? { order_index: row.order_index } : {},
+      ...metadata ? { metadata } : {}
+    };
+  }
+  const groupRows = db2.prepare("SELECT id, label, hidden FROM task_groups").all();
+  const taskGroups = {};
+  for (const row of groupRows) {
+    taskGroups[row.id] = { label: row.label, ...row.hidden ? { hidden: true } : {} };
+  }
+  const tierRows = db2.prepare("SELECT id, label FROM custom_tiers ORDER BY order_index ASC").all();
+  const customTiers = tierRows.map((row) => ({ id: row.id, label: row.label }));
+  const store = {
+    tasks,
+    ...Object.keys(projects).length > 0 ? { projects } : {},
+    ...Object.keys(taskGroups).length > 0 ? { task_groups: taskGroups } : {},
+    ...customTiers.length > 0 ? { custom_tiers: customTiers } : {}
+  };
+  if (STORE_CACHE_ENABLED) {
+    taskStoreCache = store;
+    taskStoreCacheDataVersion = readDataVersion(db2);
+    return cloneTaskStore(store);
+  }
+  return store;
+}
+function cloneTaskStore(store) {
+  return {
+    ...store,
+    tasks: store.tasks.map((t) => ({ ...t })),
+    // Registry rows carry a nested metadata object; clone it too so a caller
+    // mutating settings can't reach into the cached snapshot.
+    ...store.projects ? {
+      projects: Object.fromEntries(
+        Object.entries(store.projects).map(([name, rec]) => [
+          name,
+          { ...rec, ...rec.metadata ? { metadata: { ...rec.metadata } } : {} }
+        ])
+      )
+    } : {},
+    ...store.task_groups ? { task_groups: { ...store.task_groups } } : {},
+    ...store.custom_tiers ? { custom_tiers: store.custom_tiers.map((t) => ({ ...t })) } : {}
+  };
+}
+async function remoteListNameFor(project) {
+  const name = (project ?? "").trim();
+  if (!name) return "";
+  const metadata = await getProjectMetadata(name);
+  const alias = metadata?.remote_list;
+  return typeof alias === "string" && alias.trim() ? alias : name;
+}
+async function getStoreProjects() {
+  const store = await readStore();
+  return store.projects ?? {};
+}
+async function getProjectRecord(project) {
+  const name = (project ?? "").trim();
+  if (!name) return null;
+  const projects = await getStoreProjects();
+  const key = Object.keys(projects).find((k) => k.toLowerCase() === name.toLowerCase());
+  return key ? { name: key, ...projects[key] } : null;
+}
+function assertValidProjectName(name) {
+  const trimmed = (name ?? "").trim();
+  if (!trimmed) {
+    throw new InvalidProjectNameError(
+      "Project name must be a non-empty string. To clear a project, move its tasks to Inbox.",
+      trimmed
+    );
+  }
+  if (trimmed.includes("/") || trimmed.includes("\\")) {
+    throw new InvalidProjectNameError(
+      `Invalid project name "${name}": path separators ('/', '\\') are not allowed \u2014 a project name becomes a directory segment.`,
+      trimmed
+    );
+  }
+  if (trimmed.includes("..")) {
+    throw new InvalidProjectNameError(
+      `Invalid project name "${name}": '..' is not allowed \u2014 a project name becomes a directory segment.`,
+      trimmed
+    );
+  }
+  if (trimmed.includes("\0")) {
+    throw new InvalidProjectNameError(
+      `Invalid project name "${name}": it contains a NUL character.`,
+      trimmed
+    );
+  }
+  if (trimmed.startsWith(".")) {
+    throw new InvalidProjectNameError(
+      `Invalid project name "${name}": it cannot start with '.' (hidden directory / retired .metadata namespace).`,
+      trimmed
+    );
+  }
+  return trimmed;
+}
+function ensureProjectRowLocked(name, source) {
+  const trimmed = (name ?? "").trim();
+  if (!trimmed) return { name: "", source: "local", created: false };
+  const db2 = getDb();
+  const rows = db2.prepare("SELECT name, source FROM task_projects").all();
+  const lower = trimmed.toLowerCase();
+  const existing = rows.find((r) => r.name.trim().toLowerCase() === lower);
+  if (existing) {
+    return { name: existing.name, source: existing.source, created: false };
+  }
+  const nextOrder = db2.prepare("SELECT COALESCE(MAX(order_index), -1) + 1 AS next FROM task_projects").get().next;
+  db2.prepare(
+    "INSERT INTO task_projects (name, source, order_index) VALUES (?, ?, ?) ON CONFLICT(name) DO NOTHING"
+  ).run(trimmed, source, nextOrder);
+  log.task.info("project created", { project: trimmed, source });
+  return { name: trimmed, source, created: true };
+}
+function emitProjectCreated(name, source) {
+  bus.emit(
+    EventNames.PROJECT_CREATED,
+    { name, source },
+    ["web-ui", "main-agent"],
+    { source: "task-manager" }
+  );
+}
+async function ensureProject(name, source = "local") {
+  if (!(name ?? "").trim()) return { name: "", source: "local", created: false };
+  const trimmed = assertValidProjectName(name);
+  await ensureInit();
+  const result = await withWriteLock2(async () => ensureProjectRowLocked(trimmed, source));
+  if (result.created) emitProjectCreated(result.name, result.source);
+  return result;
+}
+async function getProjectMetadata(project) {
+  const record = await getProjectRecord(project);
+  if (!record?.metadata || Object.keys(record.metadata).length === 0) return null;
+  return record.metadata;
+}
+async function setProjectMetadata(project, settings) {
+  const raw = (project ?? "").trim();
+  if (!raw) throw new Error("Inbox has no project settings \u2014 pass a project name.");
+  const { name } = await ensureProject(raw);
+  return withWriteLock2(async () => {
+    const db2 = getDb();
+    const row = db2.prepare("SELECT name, metadata FROM task_projects WHERE name = ?").get(name);
+    if (!row) throw new Error(`Project "${name}" not found`);
+    const existing = parseProjectMetadataJson(row.metadata, row.name) ?? {};
+    const merged = { ...existing, ...settings };
+    db2.prepare("UPDATE task_projects SET metadata = ? WHERE name = ?").run(
+      Object.keys(merged).length > 0 ? JSON.stringify(merged) : null,
+      row.name
+    );
+    return merged;
+  });
+}
+function getFindByExtIdStmt(source, jsonPath) {
+  const cacheKey = `${source}|${jsonPath}`;
+  const cached = findByExtIdStmts.get(cacheKey);
+  if (cached) return cached;
+  const db2 = getDb();
+  const sourceLiteral = source.replace(/'/g, "''");
+  const pathLiteral = jsonPath.replace(/'/g, "''");
+  const sql = `SELECT * FROM tasks WHERE source = '${sourceLiteral}' AND json_extract(ext, '${pathLiteral}') = ? LIMIT 1`;
+  const stmt = db2.prepare(sql);
+  findByExtIdStmts.set(cacheKey, stmt);
+  return stmt;
+}
+async function findTaskByExtId(source, extId) {
+  if (!extId) return void 0;
+  await ensureInit();
+  const spec = getExtIndexSpec(source);
+  if (!spec) return void 0;
+  for (const p of spec.paths) {
+    const row = getFindByExtIdStmt(source, p.json).get(extId);
+    if (row) return rowToTask(row);
+  }
+  return void 0;
+}
+var initialized, STORE_CACHE_ENABLED, taskStoreCache, taskStoreCacheDataVersion, writeLock2, writeLockDepth, VALID_PRIORITIES_SET, InvalidProjectNameError, findByExtIdStmts;
+var init_task_manager = __esm({
+  "src/core/task-manager.ts"() {
+    "use strict";
+    init_constants();
+    init_file_lock();
+    init_logging();
+    init_format();
+    init_init();
+    init_config_manager();
+    init_event_bus();
+    init_types();
+    init_phase();
+    init_integration_registry();
+    init_task_db();
+    init_task_db_migration();
+    init_memory_dir_migration();
+    init_ext_index_registry();
+    initialized = false;
+    STORE_CACHE_ENABLED = process.env.WALNUT_STORE_CACHE !== "0";
+    taskStoreCache = null;
+    taskStoreCacheDataVersion = null;
+    writeLock2 = Promise.resolve();
+    writeLockDepth = 0;
+    VALID_PRIORITIES_SET = new Set(VALID_PRIORITIES);
+    InvalidProjectNameError = class extends Error {
+      project;
+      constructor(message, project) {
+        super(message);
+        this.name = "InvalidProjectNameError";
+        this.project = project;
+      }
+    };
+    findByExtIdStmts = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/integrations/microsoft-todo.ts
+var microsoft_todo_exports = {};
+__export(microsoft_todo_exports, {
+  authenticate: () => authenticate,
+  autoPushTask: () => autoPushTask,
+  clearListIdCache: () => clearListIdCache,
+  createList: () => createList,
+  deleteChecklistItem: () => deleteChecklistItem,
+  deleteList: () => deleteList,
+  deleteListForProject: () => deleteListForProject,
+  deleteMsTodoTask: () => deleteMsTodoTask,
+  deltaPull: () => deltaPull,
+  fetchChecklistItems: () => fetchChecklistItems,
+  fullPullAllTasks: () => fullPullAllTasks,
+  getAccessToken: () => getAccessToken,
+  getMsTodoSyncStatus: () => getMsTodoSyncStatus,
+  getTaskLists: () => getTaskLists,
+  graphRequest: () => graphRequest,
+  mapToLocal: () => mapToLocal,
+  mapToRemote: () => mapToRemote,
+  parseMsTodoBody: () => parseMsTodoBody,
+  pullTasks: () => pullTasks,
+  pushChecklistItem: () => pushChecklistItem,
+  pushTask: () => pushTask,
+  reconcilePulledTasks: () => reconcilePulledTasks,
+  registerDeletedMsIds: () => registerDeletedMsIds,
+  renameList: () => renameList,
+  renameListByName: () => renameListByName,
+  resolveListIdForTask: () => resolveListIdForTask,
+  syncTasks: () => syncTasks
+});
+import * as msal from "@azure/msal-node";
+import https from "https";
+import path12 from "path";
+function getMsTodoConfig(config) {
+  return config.plugins?.["ms-todo"];
+}
+function msExt(task) {
+  return task.ext?.["ms-todo"];
+}
+function getMsTodoId(task) {
+  return msExt(task)?.id;
+}
+function getMsTodoList(task) {
+  return msExt(task)?.list_id;
+}
+async function createMsalClient() {
+  const config = await getConfig();
+  const clientId = getMsTodoConfig(config)?.client_id;
+  if (!clientId) {
+    throw new Error(
+      "Microsoft To-Do client_id not configured. Add ms_todo.client_id to ~/.open-walnut/config.yaml"
+    );
+  }
+  const msalConfig = {
+    auth: {
+      clientId,
+      authority: "https://login.microsoftonline.com/consumers"
+    }
+  };
+  const app = new msal.PublicClientApplication(msalConfig);
+  const cached = await readJsonFile(TOKENS_FILE, null);
+  if (cached?.msalCache) {
+    app.getTokenCache().deserialize(cached.msalCache);
+  }
+  return app;
+}
+async function saveTokenCache(app, accessToken, expiresOn) {
+  const cache = {
+    accessToken,
+    expiresAt: (expiresOn ?? new Date(Date.now() + 3600 * 1e3)).toISOString(),
+    msalCache: app.getTokenCache().serialize()
+  };
+  await writeJsonFile(TOKENS_FILE, cache);
+}
+async function authenticate(onDeviceCode) {
+  const app = await createMsalClient();
+  const result = await app.acquireTokenByDeviceCode({
+    scopes: SCOPES,
+    deviceCodeCallback: (response) => {
+      onDeviceCode({
+        userCode: response.userCode,
+        verificationUri: response.verificationUri,
+        message: response.message
+      });
+    }
+  });
+  if (!result) {
+    throw new Error("Authentication failed: no token received");
+  }
+  await saveTokenCache(app, result.accessToken, result.expiresOn);
+  const lists = await fetchTaskLists(result.accessToken);
+  const account = result.account?.username ?? "unknown";
+  return { account, lists };
+}
+async function getAccessToken() {
+  const app = await createMsalClient();
+  const accounts = await app.getTokenCache().getAllAccounts();
+  if (accounts.length > 0) {
+    try {
+      const result = await app.acquireTokenSilent({
+        scopes: SCOPES,
+        account: accounts[0]
+      });
+      if (result) {
+        await saveTokenCache(app, result.accessToken, result.expiresOn);
+        return result.accessToken;
+      }
+    } catch {
+    }
+  }
+  const cached = await readJsonFile(TOKENS_FILE, null);
+  if (cached && new Date(cached.expiresAt) > /* @__PURE__ */ new Date()) {
+    return cached.accessToken;
+  }
+  throw new Error(
+    'Not authenticated with Microsoft To-Do. Run "open-walnut auth" to sign in.'
+  );
+}
+function graphRequest(token, method, urlPath, body) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlPath.startsWith("http") ? urlPath : `${GRAPH_BASE}${urlPath}`);
+    const postData = body ? JSON.stringify(body) : void 0;
+    const options = {
+      hostname: url.hostname,
+      path: url.pathname + url.search,
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        ...postData ? { "Content-Length": Buffer.byteLength(postData) } : {}
+      }
+    };
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          if (!data) {
+            resolve({});
+            return;
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (parseErr) {
+            reject(new Error(`Graph API ${method} ${urlPath}: invalid JSON response`));
+          }
+        } else {
+          reject(new Error(`Graph API ${method} ${urlPath} returned ${res.statusCode}: ${data}`));
+        }
+      });
+    });
+    req.setTimeout(3e4, () => {
+      req.destroy(new Error(`Graph API ${method} ${urlPath} timed out after 30s`));
+    });
+    req.on("error", reject);
+    if (postData) req.write(postData);
+    req.end();
+  });
+}
+async function fetchTaskLists(token) {
+  const response = await graphRequest(
+    token,
+    "GET",
+    "/me/todo/lists"
+  );
+  return response.value;
+}
+async function fetchChecklistItems(token, listId, taskId) {
+  const response = await graphRequest(
+    token,
+    "GET",
+    `/me/todo/lists/${listId}/tasks/${taskId}/checklistItems`
+  );
+  return response.value;
+}
+async function pushChecklistItem(token, listId, taskId, item) {
+  if (item.id) {
+    await graphRequest(
+      token,
+      "PATCH",
+      `/me/todo/lists/${listId}/tasks/${taskId}/checklistItems/${item.id}`,
+      { displayName: item.displayName, isChecked: item.isChecked }
+    );
+    return item.id;
+  } else {
+    const created = await graphRequest(
+      token,
+      "POST",
+      `/me/todo/lists/${listId}/tasks/${taskId}/checklistItems`,
+      { displayName: item.displayName, isChecked: item.isChecked }
+    );
+    return created.id;
+  }
+}
+async function deleteChecklistItem(token, listId, taskId, itemId) {
+  await graphRequest(
+    token,
+    "DELETE",
+    `/me/todo/lists/${listId}/tasks/${taskId}/checklistItems/${itemId}`
+  );
+}
+async function getTaskLists() {
+  const token = await getAccessToken();
+  return fetchTaskLists(token);
+}
+async function createList(displayName) {
+  const token = await getAccessToken();
+  return graphRequest(token, "POST", "/me/todo/lists", { displayName });
+}
+async function renameList(listId, newName) {
+  const token = await getAccessToken();
+  const result = await graphRequest(token, "PATCH", `/me/todo/lists/${listId}`, { displayName: newName });
+  clearListIdCache();
+  return result;
+}
+async function deleteList(listId) {
+  const token = await getAccessToken();
+  await graphRequest(token, "DELETE", `/me/todo/lists/${listId}`);
+  clearListIdCache();
+}
+async function deleteMsTodoTask(listId, taskId) {
+  const token = await getAccessToken();
+  await graphRequest(token, "DELETE", `/me/todo/lists/${listId}/tasks/${taskId}`);
+}
+async function renameListByName(oldName, newName) {
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const match = lists.find(
+    (l) => l.displayName.toLowerCase() === oldName.toLowerCase()
+  );
+  if (!match) {
+    throw new Error(`No remote list found with name "${oldName}"`);
+  }
+  return renameList(match.id, newName);
+}
+async function deleteListForProject(args) {
+  const listName = (args.remoteList ?? args.project).trim();
+  for (const task of args.tasks) {
+    await registerDeletedMsIds(task);
+  }
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const match = lists.find((l) => l.displayName.toLowerCase() === listName.toLowerCase());
+  if (match) {
+    await deleteList(match.id);
+    const deltaState = await readJsonFile(DELTA_FILE, {
+      deltaLinks: {},
+      listNames: {},
+      lastSync: ""
+    });
+    if (deltaState.deltaLinks[match.id] !== void 0 || deltaState.listNames[match.id] !== void 0) {
+      delete deltaState.deltaLinks[match.id];
+      delete deltaState.listNames[match.id];
+      await writeJsonFile(DELTA_FILE, deltaState);
+    }
+    log.web.info("ms-todo: deleted remote list for project", {
+      project: args.project,
+      list: listName,
+      listId: match.id,
+      tombstoned: args.tasks.length
+    });
+  } else {
+    log.web.info("ms-todo: remote list already absent on cascade delete", {
+      project: args.project,
+      list: listName
+    });
+  }
+}
+function clearListIdCache() {
+  listIdCache.clear();
+}
+async function resolveListIdForTask(task) {
+  const listName = await remoteListNameFor(task.project || "");
+  return resolveListId(listName);
+}
+async function resolveListId(listName) {
+  const config = await getConfig();
+  const mapping = getMsTodoConfig(config)?.list_mapping ?? {};
+  if (mapping[listName]) {
+    return mapping[listName];
+  }
+  const cacheKey = listName.toLowerCase();
+  const cached = listIdCache.get(cacheKey);
+  if (cached) return cached;
+  const inflight = listIdInflight.get(cacheKey);
+  if (inflight) return inflight;
+  const promise = resolveListIdImpl(listName, cacheKey);
+  listIdInflight.set(cacheKey, promise);
+  try {
+    return await promise;
+  } finally {
+    listIdInflight.delete(cacheKey);
+  }
+}
+async function resolveListIdImpl(listName, cacheKey) {
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const match = lists.find(
+    (l) => l.displayName.toLowerCase() === cacheKey
+  );
+  if (match) {
+    listIdCache.set(cacheKey, match.id);
+    return match.id;
+  }
+  if (listName) {
+    const created = await createList(listName);
+    listIdCache.set(cacheKey, created.id);
+    return created.id;
+  }
+  const defaultList = lists.find(
+    (l) => l.displayName === "Tasks" || l.displayName === "Aufgaben"
+  );
+  if (defaultList) {
+    listIdCache.set(cacheKey, defaultList.id);
+    return defaultList.id;
+  }
+  if (lists.length > 0) {
+    listIdCache.set(cacheKey, lists[0].id);
+    return lists[0].id;
+  }
+  throw new Error("No task lists found in Microsoft To-Do");
+}
+function composeMsTodoBody(description, summary, note, phase, parentTaskId, conversationLog, unread, dependsOn) {
+  const headers = [];
+  if (phase) headers.push(`Phase: ${phase}`);
+  if (parentTaskId) headers.push(`Parent: ${parentTaskId.slice(0, 8)}`);
+  if (unread !== void 0) headers.push(`Attention: ${unread}`);
+  if (dependsOn?.length) headers.push(`DependsOn: ${dependsOn.map((id) => id.slice(0, 8)).join(",")}`);
+  const prefix = headers.length > 0 ? headers.join("\n") + "\n\n" : "";
+  const sections = [];
+  if (description) sections.push(description);
+  const sub = [];
+  if (summary) sub.push(`## Summary
+${summary}`);
+  if (note) sub.push(`## Notes
+${note}`);
+  if (conversationLog) sub.push(`## Conversation Log
+${conversationLog}`);
+  if (sub.length > 0) {
+    sections.push(sub.join("\n\n"));
+  }
+  if (sections.length === 0) return prefix.trimEnd();
+  return prefix + sections.join("\n\n---\n\n");
+}
+function parseMsTodoBody(body) {
+  if (!body || !body.trim()) return { description: "", summary: "", note: "" };
+  let phase;
+  let parentTaskId;
+  let unread;
+  let dependsOn;
+  let bodyToParse = body;
+  const headerPattern = /^(Phase|Parent|Attention|DependsOn):\s*(\S+)\s*(?:\n|$)/;
+  let match;
+  while (match = bodyToParse.match(headerPattern)) {
+    const [fullMatch, key, value] = match;
+    if (key === "Phase" && VALID_PHASES.has(value)) {
+      phase = value;
+    } else if (key === "Parent") {
+      parentTaskId = value;
+    } else if (key === "Attention") {
+      unread = value === "true";
+    } else if (key === "DependsOn") {
+      dependsOn = value.split(",").filter(Boolean);
+    }
+    bodyToParse = bodyToParse.slice(fullMatch.length);
+  }
+  bodyToParse = bodyToParse.replace(/^\n/, "");
+  const hrParts = bodyToParse.split(/\n\n---\n\n/);
+  if (hrParts.length >= 2) {
+    const description = hrParts[0].trim();
+    const rest = hrParts.slice(1).join("\n\n---\n\n");
+    const { summary, note, conversation_log } = parseSections(rest);
+    return { description, summary, note, conversation_log, phase, parent_task_id: parentTaskId, ...unread !== void 0 ? { unread } : {}, ...dependsOn ? { depends_on: dependsOn } : {} };
+  }
+  const hasSections = /^## (Summary|Notes|Conversation Log)\b/m.test(bodyToParse);
+  if (hasSections) {
+    const { summary, note, conversation_log } = parseSections(bodyToParse);
+    return { description: "", summary, note, conversation_log, phase, parent_task_id: parentTaskId, ...unread !== void 0 ? { unread } : {}, ...dependsOn ? { depends_on: dependsOn } : {} };
+  }
+  return { description: "", summary: "", note: bodyToParse.trim(), phase, parent_task_id: parentTaskId, ...unread !== void 0 ? { unread } : {}, ...dependsOn ? { depends_on: dependsOn } : {} };
+}
+function parseSections(text) {
+  let summary = "";
+  let note = "";
+  let conversationLog = "";
+  const summaryMatch = text.match(/## Summary\n([\s\S]*?)(?=\n## (?:Notes|Conversation Log)\b|$)/);
+  if (summaryMatch) summary = summaryMatch[1].trim();
+  const noteMatch = text.match(/## Notes\n([\s\S]*?)(?=\n## Conversation Log\b|$)/);
+  if (noteMatch) note = noteMatch[1].trim();
+  const logMatch = text.match(/## Conversation Log\n([\s\S]*?)$/);
+  if (logMatch) conversationLog = logMatch[1].trim();
+  if (!summary && !note && !conversationLog && text.trim()) {
+    note = text.trim();
+  }
+  return { summary, note, ...conversationLog ? { conversation_log: conversationLog } : {} };
+}
+function mapToRemote(task) {
+  const msTask = {
+    title: task.title,
+    status: phaseToMsStatus(task.phase) ?? "notStarted",
+    importance: PRIORITY_TO_IMPORTANCE[task.priority] ?? "normal"
+  };
+  const bodyContent = composeMsTodoBody(task.description, task.summary, task.note, task.phase, task.parent_task_id, task.conversation_log, task.unread, task.depends_on);
+  if (bodyContent) {
+    msTask.body = {
+      content: bodyContent,
+      contentType: "text"
+    };
+  }
+  if (task.due_date) {
+    const datePart = task.due_date.split("T")[0];
+    msTask.dueDateTime = {
+      dateTime: datePart + "T00:00:00.0000000",
+      timeZone: "UTC"
+    };
+  }
+  if (task.start_date) {
+    const datePart = task.start_date.split("T")[0];
+    msTask.startDateTime = {
+      dateTime: datePart + "T00:00:00.0000000",
+      timeZone: "UTC"
+    };
+  }
+  if (task.phase === "COMPLETE" && task.completed_at) {
+    msTask.completedDateTime = {
+      dateTime: task.completed_at,
+      timeZone: "UTC"
+    };
+  }
+  return msTask;
+}
+function mapToLocal(msTask, listDisplayName) {
+  const project = routePulledListToProject(listDisplayName);
+  const parsed = msTask.body?.content ? parseMsTodoBody(msTask.body.content) : void 0;
+  let phase;
+  if (msTask.status === "completed") {
+    phase = "COMPLETE";
+  } else if (msTask.status === "notStarted" && parsed?.phase && parsed.phase !== "TODO") {
+    phase = "TODO";
+  } else {
+    phase = parsed?.phase ?? phaseFromMsStatus(msTask.status);
+  }
+  const local = {
+    title: msTask.title,
+    status: deriveStatusFromPhase(phase),
+    phase,
+    priority: IMPORTANCE_TO_PRIORITY[msTask.importance] ?? "none",
+    ext: { "ms-todo": { id: msTask.id } },
+    project
+  };
+  if (parsed) {
+    local.description = parsed.description;
+    local.summary = parsed.summary;
+    local.note = parsed.note;
+    if (parsed.conversation_log) local.conversation_log = parsed.conversation_log;
+    if (parsed.parent_task_id) local.parent_task_id = parsed.parent_task_id;
+    if (parsed.unread !== void 0) local.unread = parsed.unread;
+    if (parsed.depends_on) local.depends_on = parsed.depends_on;
+  }
+  if (msTask.dueDateTime?.dateTime) {
+    local.due_date = msTask.dueDateTime.dateTime.split("T")[0];
+  }
+  if (msTask.startDateTime?.dateTime) {
+    local.start_date = msTask.startDateTime.dateTime.split("T")[0];
+  }
+  if (msTask.completedDateTime?.dateTime) {
+    local.completed_at = new Date(msTask.completedDateTime.dateTime).toISOString();
+  }
+  return local;
+}
+function isStoreUnavailableError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /task-db is not open/i.test(msg) || /before database was successfully opened/i.test(msg) || /bindings file/i.test(msg) || // better-sqlite3 native module missing
+  /SQLITE_CANTOPEN/i.test(msg) || /reading 'prepare'/.test(msg);
+}
+async function ensureProjectForList(listDisplayName) {
+  const parsed = routePulledListToProject(listDisplayName);
+  if (!parsed) {
+    log.web.debug("ms-todo: list name maps to Inbox / no project, skipping", { list: listDisplayName });
+    return null;
+  }
+  try {
+    const { name, source } = await ensureProject(parsed, "ms-todo");
+    if (source !== "ms-todo") {
+      log.web.debug("ms-todo: project claimed by another source, skipping list", {
+        project: name,
+        source,
+        list: listDisplayName
+      });
+      return null;
+    }
+    if (listDisplayName.toLowerCase() === name.toLowerCase()) return name;
+    const existing = (await getProjectRecord(name))?.metadata?.remote_list;
+    if (typeof existing === "string" && existing.trim()) {
+      if (existing !== listDisplayName) {
+        log.web.debug("ms-todo: project already aliased to another remote list", {
+          project: name,
+          alias: existing,
+          list: listDisplayName
+        });
+      }
+      return name;
+    }
+    await setProjectMetadata(name, { remote_list: listDisplayName });
+    return name;
+  } catch (err) {
+    if (isStoreUnavailableError(err)) {
+      log.web.debug("ms-todo: project registry update skipped (no task store)", {
+        list: listDisplayName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return parsed;
+    }
+    log.web.error("ms-todo: project registry update failed, skipping list", {
+      list: listDisplayName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+async function syncProjectAliasAfterRename(listDisplayName) {
+  const parsed = routePulledListToProject(listDisplayName);
+  if (!parsed) return null;
+  try {
+    const { name, source } = await ensureProject(parsed, "ms-todo");
+    if (source !== "ms-todo") return null;
+    const current = (await getProjectRecord(name))?.metadata?.remote_list;
+    if (typeof current !== "string" || current.toLowerCase() !== listDisplayName.toLowerCase()) {
+      await setProjectMetadata(name, { remote_list: listDisplayName });
+    }
+    return name;
+  } catch (err) {
+    if (isStoreUnavailableError(err)) {
+      log.web.debug("ms-todo: project alias update skipped (no task store)", {
+        list: listDisplayName,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return parsed;
+    }
+    log.web.error("ms-todo: project alias update failed, skipping list", {
+      list: listDisplayName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+async function pushTask(task) {
+  const taskProject = task.project || "";
+  if (!taskProject) {
+    throw new Error(
+      `pushTask: refusing to push task "${task.title}" to MS Todo \u2014 it has no project (Inbox tasks are local-only)`
+    );
+  }
+  try {
+    const record = await getProjectRecord(taskProject);
+    if (record && record.source !== "ms-todo") {
+      throw new Error(
+        `pushTask: refusing to push task "${task.title}" to MS Todo \u2014 project "${taskProject}" is registered as ${record.source}`
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("pushTask: refusing")) throw err;
+    if (!isStoreUnavailableError(err)) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.web.error("ms-todo: project registry read failed, refusing push", {
+        taskId: task.id,
+        project: taskProject,
+        error: message
+      });
+      throw new Error(
+        `pushTask: refusing to push task "${task.title}" to MS Todo \u2014 project registry unreadable (${message})`
+      );
+    }
+  }
+  const token = await getAccessToken();
+  const listId = await resolveListIdForTask(task);
+  const msBody = mapToRemote(task);
+  let msTaskId;
+  let serverTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let actualListId = listId;
+  const existingMsTodoId = getMsTodoId(task);
+  const existingMsTodoList = getMsTodoList(task);
+  if (existingMsTodoId) {
+    const oldListId = existingMsTodoList;
+    if (oldListId && oldListId !== listId) {
+      try {
+        await graphRequest(
+          token,
+          "DELETE",
+          `/me/todo/lists/${oldListId}/tasks/${existingMsTodoId}`
+        );
+      } catch (err) {
+        log.web.warn("MS To-Do: failed to delete task from old list during migration", {
+          taskId: task.id,
+          oldListId,
+          msTaskId: existingMsTodoId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+      log.web.info("ms-todo POST create", {
+        taskId: task.id,
+        title: task.title,
+        project: task.project,
+        oldListId,
+        newListId: listId,
+        oldMsTodoId: existingMsTodoId,
+        reason: "list_migration"
+      });
+      const created = await graphRequest(
+        token,
+        "POST",
+        `/me/todo/lists/${listId}/tasks`,
+        msBody
+      );
+      msTaskId = created.id;
+      serverTimestamp = created.lastModifiedDateTime;
+      log.web.info("ms-todo ext.id assigned", {
+        taskId: task.id,
+        oldId: existingMsTodoId,
+        newId: msTaskId,
+        reason: "list_migration"
+      });
+      const prevIds = (msExt(task)?.previous_ids ?? []).slice();
+      if (!prevIds.includes(existingMsTodoId)) prevIds.push(existingMsTodoId);
+      if (prevIds.length > 10) prevIds.splice(0, prevIds.length - 10);
+      if (!task.ext) task.ext = {};
+      if (!task.ext["ms-todo"]) task.ext["ms-todo"] = {};
+      task.ext["ms-todo"].previous_ids = prevIds;
+    } else {
+      try {
+        const patchBody = { ...msBody };
+        if (!task.due_date) patchBody.dueDateTime = null;
+        if (!task.start_date) patchBody.startDateTime = null;
+        const patched = await graphRequest(
+          token,
+          "PATCH",
+          `/me/todo/lists/${listId}/tasks/${existingMsTodoId}`,
+          patchBody
+        );
+        msTaskId = existingMsTodoId;
+        serverTimestamp = patched.lastModifiedDateTime;
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const httpStatus = err?.status;
+        log.web.warn("ms-todo PATCH failed (will retry next tick with same ext.id)", {
+          taskId: task.id,
+          existingMsTodoId,
+          listId,
+          httpStatus,
+          error: errMsg
+        });
+        throw err;
+      }
+    }
+  } else {
+    log.web.info("ms-todo POST create", {
+      taskId: task.id,
+      title: task.title,
+      project: task.project,
+      listId,
+      reason: "first_create"
+    });
+    const created = await graphRequest(
+      token,
+      "POST",
+      `/me/todo/lists/${listId}/tasks`,
+      msBody
+    );
+    msTaskId = created.id;
+    serverTimestamp = created.lastModifiedDateTime;
+    log.web.info("ms-todo ext.id assigned", {
+      taskId: task.id,
+      newId: msTaskId,
+      reason: "first_create"
+    });
+  }
+  if (!task.ext) task.ext = {};
+  if (!task.ext["ms-todo"]) task.ext["ms-todo"] = {};
+  task.ext["ms-todo"].id = msTaskId;
+  task.ext["ms-todo"].list_id = actualListId;
+  return { msTaskId, serverTimestamp };
+}
+async function pullTasks(listId) {
+  const token = await getAccessToken();
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  const existingDelta = deltaState.deltaLinks[listId];
+  let allTasks = [];
+  let nextLink;
+  let deltaLink;
+  const initialUrl = existingDelta ?? `/me/todo/lists/${listId}/tasks/delta`;
+  let response;
+  try {
+    response = await graphRequest(
+      token,
+      "GET",
+      initialUrl
+    );
+  } catch (err) {
+    if (existingDelta && err instanceof Error && err.message.includes(" 410")) {
+      log.web.info("MS To-Do delta link expired, performing full resync", { listId });
+      delete deltaState.deltaLinks[listId];
+      await writeJsonFile(DELTA_FILE, deltaState);
+      response = await graphRequest(
+        token,
+        "GET",
+        `/me/todo/lists/${listId}/tasks/delta`
+      );
+    } else {
+      throw err;
+    }
+  }
+  allTasks.push(...response.value);
+  nextLink = response["@odata.nextLink"];
+  deltaLink = response["@odata.deltaLink"];
+  while (nextLink) {
+    response = await graphRequest(
+      token,
+      "GET",
+      nextLink
+    );
+    allTasks.push(...response.value);
+    nextLink = response["@odata.nextLink"];
+    deltaLink = response["@odata.deltaLink"];
+  }
+  if (deltaLink) {
+    deltaState.deltaLinks[listId] = deltaLink;
+    deltaState.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+    await writeJsonFile(DELTA_FILE, deltaState);
+  }
+  return { tasks: allTasks, deltaLink };
+}
+async function fullPullAllTasks() {
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const result = [];
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  const deletedMsIds = new Set(deltaState.deletedMsIds ?? []);
+  for (const list of lists) {
+    let allTasks = [];
+    let response = await graphRequest(
+      token,
+      "GET",
+      `/me/todo/lists/${list.id}/tasks`
+    );
+    allTasks.push(...response.value);
+    let nextLink = response["@odata.nextLink"];
+    while (nextLink) {
+      response = await graphRequest(token, "GET", nextLink);
+      allTasks.push(...response.value);
+      nextLink = response["@odata.nextLink"];
+    }
+    if (allTasks.length === 0) continue;
+    const listProject = await ensureProjectForList(list.displayName);
+    if (listProject === null) continue;
+    for (const msTask of allTasks) {
+      if (deletedMsIds.has(msTask.id)) continue;
+      const fields = mapToLocal(msTask, list.displayName);
+      fields.project = listProject;
+      if (fields.ext?.["ms-todo"]) {
+        fields.ext["ms-todo"].list_id = list.id;
+      }
+      result.push({
+        remoteId: msTask.id,
+        title: msTask.title,
+        remoteUpdatedAt: msTask.lastModifiedDateTime,
+        fields
+      });
+    }
+  }
+  return result;
+}
+async function getMsTodoSyncStatus() {
+  const config = await getConfig();
+  const configured = !!getMsTodoConfig(config)?.client_id;
+  if (!configured) {
+    return { configured: false, authenticated: false, lastSync: null, deltaLinksCount: 0 };
+  }
+  let authenticated = false;
+  try {
+    await getAccessToken();
+    authenticated = true;
+  } catch {
+  }
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  return {
+    configured,
+    authenticated,
+    lastSync: deltaState.lastSync || null,
+    deltaLinksCount: Object.keys(deltaState.deltaLinks).length
+  };
+}
+async function registerDeletedMsIds(task) {
+  const msId = getMsTodoId(task);
+  const prev = msExt(task)?.previous_ids;
+  const idsToRegister = [msId, ...prev ?? []].filter(Boolean);
+  if (idsToRegister.length === 0) return;
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  const existing = new Set(deltaState.deletedMsIds ?? []);
+  for (const id of idsToRegister) existing.add(id);
+  const arr = [...existing];
+  deltaState.deletedMsIds = arr.length > 500 ? arr.slice(arr.length - 500) : arr;
+  await writeJsonFile(DELTA_FILE, deltaState);
+}
+async function autoPushTask(task) {
+  const key = task.id;
+  const existing = msPushInflight.get(key);
+  if (existing) return existing;
+  const promise = pushTask(task).catch(() => null).finally(() => msPushInflight.delete(key));
+  msPushInflight.set(key, promise);
+  return promise;
+}
+async function reconcilePulledTasks(msTasks, list, updateLocalTask, addLocalTask, token, deletedMsIds, previousIdsMap) {
+  let count = 0;
+  if (msTasks.length === 0) return 0;
+  const listProject = await ensureProjectForList(list.displayName);
+  if (listProject === null) {
+    log.web.debug("reconcilePulledTasks: skipped list (no importable project)", {
+      listName: list.displayName,
+      tasks: msTasks.length
+    });
+    return 0;
+  }
+  for (const msTask of msTasks) {
+    if (!msTask.title || msTask.title.trim() === "") continue;
+    if (deletedMsIds?.has(msTask.id)) continue;
+    const existing = await findTaskByExtId("ms-todo", msTask.id) ?? previousIdsMap?.get(msTask.id);
+    if (existing) {
+      const remoteUpdated = new Date(msTask.lastModifiedDateTime).getTime();
+      const syncedAt = existing._syncedAt ? new Date(existing._syncedAt).getTime() : 0;
+      if (remoteUpdated > syncedAt) {
+        const updates = mapToLocal(msTask, list.displayName);
+        updates.project = listProject;
+        await updateLocalTask(existing.id, updates);
+        count++;
+      }
+    } else {
+      const partial = mapToLocal(msTask, list.displayName);
+      try {
+        await addLocalTask({
+          title: partial.title ?? msTask.title,
+          status: partial.status ?? "todo",
+          phase: partial.phase ?? "TODO",
+          priority: partial.priority ?? "none",
+          project: listProject,
+          source: "ms-todo",
+          session_ids: [],
+          ext: { "ms-todo": { id: msTask.id, list_id: list.id } },
+          created_at: msTask.createdDateTime,
+          updated_at: msTask.lastModifiedDateTime,
+          due_date: partial.due_date,
+          start_date: partial.start_date,
+          ...partial.parent_task_id ? { parent_task_id: partial.parent_task_id } : {},
+          description: partial.description ?? "",
+          summary: partial.summary ?? "",
+          note: partial.note ?? "",
+          ...partial.conversation_log ? { conversation_log: partial.conversation_log } : {}
+        });
+        count++;
+      } catch (err) {
+        log.web.debug("reconcilePulledTasks: skipped creating task", {
+          title: msTask.title,
+          listName: list.displayName,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  return count;
+}
+function buildMsTodoPreviousIdsMap(localTasks) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of localTasks) {
+    if (t.source !== "ms-todo") continue;
+    const prevIds = msExt(t)?.previous_ids;
+    if (!prevIds || prevIds.length === 0) continue;
+    for (const oldId of prevIds) {
+      if (!map.has(oldId)) map.set(oldId, t);
+    }
+  }
+  return map;
+}
+async function deltaPull(localTasks, updateLocalTask, addLocalTask) {
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const msLocalTasks = localTasks.filter((t) => t.source === "ms-todo");
+  const previousIdsMap = buildMsTodoPreviousIdsMap(msLocalTasks);
+  let hasChanges = false;
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  const storedNames = deltaState.listNames ?? {};
+  const projectByListId = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    const oldName = storedNames[list.id];
+    if (oldName && oldName !== list.displayName) {
+      const project = await syncProjectAliasAfterRename(list.displayName);
+      projectByListId.set(list.id, project);
+      if (project === null) continue;
+      for (const task of msLocalTasks) {
+        if (getMsTodoList(task) === list.id && (task.project || "").toLowerCase() !== project.toLowerCase()) {
+          await updateLocalTask(task.id, { project });
+          hasChanges = true;
+        }
+      }
+    }
+  }
+  const newListNames = {};
+  for (const list of lists) {
+    newListNames[list.id] = list.displayName;
+  }
+  deltaState.listNames = newListNames;
+  await writeJsonFile(DELTA_FILE, deltaState);
+  const listNameById = new Map(lists.map((l) => [l.id, l.displayName]));
+  for (const task of msLocalTasks) {
+    const taskListId = getMsTodoList(task);
+    if (!taskListId) continue;
+    const currentListName = listNameById.get(taskListId);
+    if (!currentListName) {
+      if (task.phase !== "COMPLETE") {
+        await updateLocalTask(task.id, { phase: "COMPLETE" });
+        hasChanges = true;
+      }
+      continue;
+    }
+    let project = projectByListId.get(taskListId);
+    if (project === void 0) {
+      project = await ensureProjectForList(currentListName);
+      projectByListId.set(taskListId, project);
+    }
+    if (project === null) continue;
+    if ((task.project || "").toLowerCase() !== project.toLowerCase()) {
+      await updateLocalTask(task.id, { project });
+      hasChanges = true;
+    }
+  }
+  const deletedMsIds = new Set(deltaState.deletedMsIds ?? []);
+  for (const list of lists) {
+    const { tasks: msTasks } = await pullTasks(list.id);
+    if (msTasks.length === 0) continue;
+    const count = await reconcilePulledTasks(msTasks, list, updateLocalTask, addLocalTask, token, deletedMsIds, previousIdsMap);
+    if (count > 0) hasChanges = true;
+  }
+  return hasChanges;
+}
+async function syncTasks(localTasks, updateLocalTask, addLocalTask) {
+  const result = { pushed: 0, pulled: 0, errors: [] };
+  const token = await getAccessToken();
+  const lists = await fetchTaskLists(token);
+  const msLocalTasks = localTasks.filter((t) => t.source === "ms-todo");
+  const previousIdsMap = buildMsTodoPreviousIdsMap(msLocalTasks);
+  const listByName = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    listByName.set(list.displayName.toLowerCase(), list.id);
+  }
+  const defaultListId = lists[0]?.id;
+  for (const task of msLocalTasks) {
+    if (!getMsTodoId(task)) {
+      try {
+        const { msTaskId } = await pushTask(task);
+        const taskListName = await remoteListNameFor(task.project || "");
+        const listId = listByName.get(taskListName.toLowerCase()) ?? defaultListId;
+        await updateLocalTask(task.id, {
+          ext: { "ms-todo": { id: msTaskId, list_id: listId } }
+        });
+        result.pushed++;
+      } catch (err) {
+        result.errors.push(`Push failed for "${task.title}": ${err}`);
+      }
+    }
+  }
+  const deltaState = await readJsonFile(DELTA_FILE, {
+    deltaLinks: {},
+    listNames: {},
+    lastSync: ""
+  });
+  const deletedMsIds = new Set(deltaState.deletedMsIds ?? []);
+  for (const list of lists) {
+    try {
+      const { tasks: msTasks } = await pullTasks(list.id);
+      const count = await reconcilePulledTasks(msTasks, list, updateLocalTask, addLocalTask, token, deletedMsIds, previousIdsMap);
+      result.pulled += count;
+    } catch (err) {
+      result.errors.push(`Pull failed for list "${list.displayName}": ${err}`);
+    }
+  }
+  return result;
+}
+var TOKENS_FILE, DELTA_FILE, GRAPH_BASE, SCOPES, PRIORITY_TO_IMPORTANCE, IMPORTANCE_TO_PRIORITY, listIdCache, listIdInflight, msPushInflight;
+var init_microsoft_todo = __esm({
+  "src/integrations/microsoft-todo.ts"() {
+    "use strict";
+    init_constants();
+    init_fs();
+    init_config_manager();
+    init_logging();
+    init_phase();
+    init_phase2();
+    init_format();
+    init_task_manager();
+    TOKENS_FILE = path12.join(SYNC_DIR, "ms-todo-tokens.json");
+    DELTA_FILE = path12.join(SYNC_DIR, "ms-todo-delta.json");
+    GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+    SCOPES = ["Tasks.ReadWrite"];
+    PRIORITY_TO_IMPORTANCE = {
+      immediate: "high",
+      important: "normal",
+      backlog: "low",
+      none: "normal"
+    };
+    IMPORTANCE_TO_PRIORITY = {
+      high: "immediate",
+      low: "backlog",
+      normal: "none"
+    };
+    listIdCache = /* @__PURE__ */ new Map();
+    listIdInflight = /* @__PURE__ */ new Map();
+    msPushInflight = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/integrations/ms-todo/index.ts
+function register(api) {
+  const sync = {
+    async createTask(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      const result = await autoPushTask2(task);
+      if (result) {
+        return { "ms-todo": { id: result.msTaskId, list_id: task.ext?.["ms-todo"]?.list_id } };
+      }
+      return null;
+    },
+    async deleteTask(task) {
+      const { deleteMsTodoTask: deleteMsTodoTask2, registerDeletedMsIds: registerDeletedMsIds2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await registerDeletedMsIds2(task);
+      const msId = task.ext?.["ms-todo"]?.id;
+      const listId = task.ext?.["ms-todo"]?.list_id;
+      if (!msId || !listId) return;
+      try {
+        await deleteMsTodoTask2(listId, msId);
+      } catch {
+      }
+    },
+    async updateTitle(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateDescription(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateSummary(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateNote(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateConversationLog(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updatePriority(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updatePhase(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateDueDate(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateStar(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    /**
+     * A single task moved between projects → re-push it, which resolves the target
+     * list (creating one if the project has no remote list yet) and migrates the
+     * remote twin into it.
+     *
+     * NOTE: this is NOT the project-rename path. Renaming a project renames the
+     * remote LIST once (core's renameProject → renameListByName, keyed on the
+     * `remote_list` alias); calling this hook per task instead would resolve the
+     * new name, find no list, and CREATE one — forking the user's list in two.
+     * It stays the fallback for when that container rename fails, and the surviving
+     * alias makes that fallback land in the existing list rather than a new one.
+     */
+    async updateProject(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async updateDependencies(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await autoPushTask2(task);
+    },
+    async pushTask(task) {
+      const { pushTask: msPushTask } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      const result = await msPushTask(task);
+      return {
+        serverTimestamp: result.serverTimestamp,
+        ext: { "ms-todo": { id: result.msTaskId, list_id: task.ext?.["ms-todo"]?.list_id } }
+      };
+    },
+    async associateSubtask(_parent, _child) {
+    },
+    async disassociateSubtask(_parent, _child) {
+    },
+    async syncPoll(ctx) {
+      const { deltaPull: deltaPull2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      const tasks = ctx.getTasks();
+      await deltaPull2(
+        tasks,
+        async (id, updates) => {
+          await ctx.updateTask(id, updates);
+        },
+        async (taskData) => {
+          const t = await ctx.addTask(taskData);
+          return t;
+        }
+      );
+    },
+    async renameProjectRemote({ oldRemoteName, newName }) {
+      const { renameListByName: renameListByName2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await renameListByName2(oldRemoteName, newName);
+    },
+    async deleteProjectRemote(args) {
+      const { deleteListForProject: deleteListForProject2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      await deleteListForProject2(args);
+      return { outcome: "container-deleted" };
+    },
+    async fullPull() {
+      const { fullPullAllTasks: fullPullAllTasks2 } = await Promise.resolve().then(() => (init_microsoft_todo(), microsoft_todo_exports));
+      return fullPullAllTasks2();
+    },
+    extractRemoteId(task) {
+      return task.ext?.["ms-todo"]?.id;
+    }
+  };
+  api.registerSync(sync);
+  api.registerExtIndex({
+    source: "ms-todo",
+    paths: [{ key: "id", json: '$."ms-todo".id' }]
+  });
+  api.registerSourceClaim(() => {
+    return true;
+  }, { priority: 0 });
+  api.registerDisplay({
+    badge: "M",
+    badgeColor: "#0078D4",
+    externalLinkLabel: "Microsoft To-Do",
+    getExternalUrl: () => "https://to-do.microsoft.com",
+    isSynced: (task) => !!task.ext?.["ms-todo"]?.id,
+    syncTooltip: (task) => task.sync_error ? `Sync error: ${task.sync_error}` : "Synced to Microsoft To-Do"
+  });
+  api.registerAgentContext(
+    'Tasks with source "ms-todo" sync bidirectionally with Microsoft To-Do. Phase maps to 3 MS To-Do statuses: notStarted/inProgress/completed.'
+  );
+  api.registerMigration((tasks) => {
+    for (const task of tasks) {
+      const raw = task;
+      if (raw.ms_todo_id && !task.ext?.["ms-todo"]) {
+        if (!task.ext) task.ext = {};
+        task.ext["ms-todo"] = {
+          id: raw.ms_todo_id,
+          list_id: raw.ms_todo_list
+        };
+        delete raw.ms_todo_id;
+        delete raw.ms_todo_list;
+      } else if (raw.ms_todo_id) {
+        const existingId = task.ext?.["ms-todo"]?.id;
+        if (existingId && existingId !== raw.ms_todo_id) {
+          api.logger.warn("migration conflict: ms_todo_id differs from ext id", {
+            taskId: task.id,
+            legacyId: raw.ms_todo_id,
+            extId: existingId
+          });
+        }
+        delete raw.ms_todo_id;
+        delete raw.ms_todo_list;
+      }
+      const msExt2 = task.ext?.["ms-todo"];
+      if (msExt2 && typeof msExt2 === "object" && msExt2["ms-todo"] && typeof msExt2["ms-todo"] === "object") {
+        const inner = msExt2["ms-todo"];
+        task.ext["ms-todo"] = {
+          id: inner.id ?? msExt2.id,
+          list_id: inner.list_id ?? inner.list ?? msExt2.list_id ?? msExt2.list
+        };
+      }
+      const msExtNorm = task.ext?.["ms-todo"];
+      if (msExtNorm && msExtNorm.list) {
+        if (!msExtNorm.list_id) {
+          msExtNorm.list_id = msExtNorm.list;
+        }
+        delete msExtNorm.list;
+      }
+    }
+    return tasks;
+  });
+}
+export {
+  register as default
+};
+//# sourceMappingURL=index.js.map