open-walnut 0.3.0

package/dist/integrations/jira/index.js

@@ -0,0 +1,4200 @@
+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/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/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/utils/format.ts
+import crypto2 from "crypto";
+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/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 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 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 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;
+}
+function pluginPrimaryExtPath(source) {
+  const spec = getExtIndexSpec(source);
+  if (!spec || spec.paths.length === 0) {
+    throw new Error(
+      `listUnsyncedTasks/listSyncErrorTasks: no ext-index registered for source "${source}". The plugin must call PluginApi.registerExtIndex during load.`
+    );
+  }
+  return spec.paths[0].json;
+}
+async function listUnsyncedTasks(pluginId) {
+  await ensureInit();
+  const extPath = pluginPrimaryExtPath(pluginId);
+  const db2 = getDb();
+  const pathLiteral = extPath.replace(/'/g, "''");
+  const sql = `SELECT * FROM tasks WHERE source = ? AND status != 'done'
+    AND (ext IS NULL OR json_extract(ext, '${pathLiteral}') IS NULL)`;
+  const rows = db2.prepare(sql).all(pluginId);
+  return rows.map(rowToTask);
+}
+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/jira/jira-client.ts
+import https from "https";
+import http from "http";
+import { URL } from "url";
+var MAX_RETRIES, INITIAL_BACKOFF_MS, JiraClient;
+var init_jira_client = __esm({
+  "src/integrations/jira/jira-client.ts"() {
+    "use strict";
+    init_logging();
+    MAX_RETRIES = 3;
+    INITIAL_BACKOFF_MS = 1e3;
+    JiraClient = class {
+      baseUrl;
+      authHeader;
+      logger = createSubsystemLogger("jira");
+      constructor(config) {
+        this.baseUrl = config.base_url.replace(/\/+$/, "");
+        if (config.auth.type === "api-token") {
+          if (!config.auth.email) throw new Error("Jira API token auth requires email");
+          const credentials = Buffer.from(`${config.auth.email}:${config.auth.token}`).toString("base64");
+          this.authHeader = `Basic ${credentials}`;
+        } else {
+          this.authHeader = `Bearer ${config.auth.token}`;
+        }
+      }
+      // ── Issue CRUD ──
+      async getIssue(issueIdOrKey) {
+        return this.request(
+          "GET",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}`
+        );
+      }
+      async searchIssues(jql, opts) {
+        const params = new URLSearchParams({
+          jql,
+          maxResults: String(opts?.maxResults ?? 100),
+          startAt: String(opts?.startAt ?? 0)
+        });
+        if (opts?.fields) params.set("fields", opts.fields.join(","));
+        return this.request("GET", `/rest/api/3/search?${params}`);
+      }
+      async createIssue(input) {
+        return this.request("POST", "/rest/api/3/issue", input);
+      }
+      async updateIssue(issueIdOrKey, input) {
+        await this.request(
+          "PUT",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}`,
+          input
+        );
+      }
+      // ── Comments ──
+      async addComment(issueIdOrKey, body) {
+        return this.request(
+          "POST",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}/comment`,
+          { body }
+        );
+      }
+      async updateComment(issueIdOrKey, commentId, body) {
+        return this.request(
+          "PUT",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}/comment/${commentId}`,
+          { body }
+        );
+      }
+      // ── Transitions (workflow) ──
+      async getTransitions(issueIdOrKey) {
+        return this.request(
+          "GET",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}/transitions`
+        );
+      }
+      async doTransition(issueIdOrKey, transitionId) {
+        await this.request(
+          "POST",
+          `/rest/api/3/issue/${encodeURIComponent(issueIdOrKey)}/transitions`,
+          { transition: { id: transitionId } }
+        );
+      }
+      // ── Discovery ──
+      async getMyself() {
+        return this.request("GET", "/rest/api/3/myself");
+      }
+      // ── HTTP transport ──
+      async request(method, path13, body) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            return await this.doRequest(method, path13, body);
+          } catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            const status = err.statusCode;
+            if (status !== 429 && (!status || status < 500)) {
+              throw lastError;
+            }
+            if (attempt < MAX_RETRIES) {
+              const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt);
+              this.logger.debug("Jira API retrying", { method, path: path13, attempt: attempt + 1, backoff });
+              await new Promise((r) => setTimeout(r, backoff));
+            }
+          }
+        }
+        throw lastError ?? new Error("Jira request failed");
+      }
+      doRequest(method, path13, body) {
+        return new Promise((resolve, reject) => {
+          const url = new URL(path13, this.baseUrl);
+          const isHttps = url.protocol === "https:";
+          const transport = isHttps ? https : http;
+          const bodyStr = body ? JSON.stringify(body) : void 0;
+          const options = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            method,
+            headers: {
+              "Authorization": this.authHeader,
+              "Accept": "application/json",
+              ...bodyStr ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(bodyStr) } : {}
+            }
+          };
+          const req = transport.request(options, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+              const raw = Buffer.concat(chunks).toString("utf-8");
+              const status = res.statusCode ?? 0;
+              if (status >= 200 && status < 300) {
+                if (!raw.trim()) {
+                  resolve(void 0);
+                  return;
+                }
+                try {
+                  resolve(JSON.parse(raw));
+                } catch {
+                  resolve(raw);
+                }
+                return;
+              }
+              const err = new Error(`Jira API ${method} ${path13} \u2192 ${status}: ${raw.slice(0, 500)}`);
+              err.statusCode = status;
+              reject(err);
+            });
+          });
+          req.on("error", reject);
+          req.setTimeout(3e4, () => {
+            req.destroy(new Error(`Jira API ${method} ${path13} timed out after 30s`));
+          });
+          if (bodyStr) req.write(bodyStr);
+          req.end();
+        });
+      }
+    };
+  }
+});
+
+// src/integrations/jira/workflow.ts
+function phaseFromJiraStatus(statusName, statusCategoryKey) {
+  const nameKey = Object.keys(JIRA_STATUS_TO_PHASE).find(
+    (k) => k.toLowerCase() === statusName.toLowerCase()
+  );
+  if (nameKey) return JIRA_STATUS_TO_PHASE[nameKey];
+  if (statusCategoryKey) {
+    return STATUS_CATEGORY_TO_PHASE[statusCategoryKey] ?? "TODO";
+  }
+  return "TODO";
+}
+function shouldPreserveLocalPhaseJira(localPhase, jiraStatusName) {
+  const nameKey = Object.keys(JIRA_PHASE_GROUPS).find(
+    (k) => k.toLowerCase() === jiraStatusName.toLowerCase()
+  );
+  const group = nameKey ? JIRA_PHASE_GROUPS[nameKey] : void 0;
+  if (!group) return false;
+  return group.includes(localPhase);
+}
+function resolveTransition(transitions, targetStatusName) {
+  const exact = transitions.find(
+    (t) => t.to.name.toLowerCase() === targetStatusName.toLowerCase()
+  );
+  if (exact) return exact.id;
+  const targetCategory = statusNameToCategory(targetStatusName);
+  if (targetCategory) {
+    const catMatch = transitions.find(
+      (t) => t.to.statusCategory.key === targetCategory
+    );
+    if (catMatch) return catMatch.id;
+  }
+  return null;
+}
+function statusNameToCategory(statusName) {
+  const lower = statusName.toLowerCase();
+  if (["to do", "backlog", "open", "reopened"].includes(lower)) return "new";
+  if (["in progress", "in review", "in development", "code review"].includes(lower)) return "indeterminate";
+  if (["done", "closed", "resolved"].includes(lower)) return "done";
+  return null;
+}
+var PHASE_TO_JIRA_STATUS, JIRA_STATUS_TO_PHASE, JIRA_PHASE_GROUPS, STATUS_CATEGORY_TO_PHASE;
+var init_workflow = __esm({
+  "src/integrations/jira/workflow.ts"() {
+    "use strict";
+    PHASE_TO_JIRA_STATUS = {
+      TODO: "To Do",
+      IN_PROGRESS: "In Progress",
+      AGENT_COMPLETE: "In Progress",
+      AWAIT_HUMAN_ACTION: "In Progress",
+      HUMAN_VERIFIED: "In Review",
+      POST_WORK_COMPLETED: "Done",
+      COMPLETE: "Done"
+    };
+    JIRA_STATUS_TO_PHASE = {
+      "Backlog": "TODO",
+      "To Do": "TODO",
+      "Open": "TODO",
+      "Reopened": "TODO",
+      "Selected for Development": "TODO",
+      "In Progress": "IN_PROGRESS",
+      "In Development": "IN_PROGRESS",
+      "In Review": "HUMAN_VERIFIED",
+      "Code Review": "HUMAN_VERIFIED",
+      "Done": "COMPLETE",
+      "Closed": "COMPLETE",
+      "Resolved": "COMPLETE"
+    };
+    JIRA_PHASE_GROUPS = {
+      "Backlog": ["TODO"],
+      "To Do": ["TODO"],
+      "Open": ["TODO"],
+      "Reopened": ["TODO"],
+      "Selected for Development": ["TODO"],
+      "In Progress": ["IN_PROGRESS", "AGENT_COMPLETE", "AWAIT_HUMAN_ACTION"],
+      "In Development": ["IN_PROGRESS", "AGENT_COMPLETE", "AWAIT_HUMAN_ACTION"],
+      "In Review": ["HUMAN_VERIFIED"],
+      "Code Review": ["HUMAN_VERIFIED"],
+      "Done": ["POST_WORK_COMPLETED", "COMPLETE"],
+      "Closed": ["POST_WORK_COMPLETED", "COMPLETE"],
+      "Resolved": ["POST_WORK_COMPLETED", "COMPLETE"]
+    };
+    STATUS_CATEGORY_TO_PHASE = {
+      "new": "TODO",
+      "indeterminate": "IN_PROGRESS",
+      "done": "COMPLETE"
+    };
+  }
+});
+
+// src/integrations/jira/adf.ts
+function plainTextToAdf(text) {
+  if (!text.trim()) {
+    return { version: 1, type: "doc", content: [{ type: "paragraph", content: [] }] };
+  }
+  const paragraphs = text.split(/\n{2,}/);
+  return {
+    version: 1,
+    type: "doc",
+    content: paragraphs.map((p) => ({
+      type: "paragraph",
+      content: [{ type: "text", text: p.trim() }]
+    }))
+  };
+}
+function markdownToAdf(md) {
+  if (!md.trim()) {
+    return { version: 1, type: "doc", content: [{ type: "paragraph", content: [] }] };
+  }
+  const content = [];
+  const lines = md.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      const lang = line.slice(3).trim() || void 0;
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      content.push({
+        type: "codeBlock",
+        ...lang ? { attrs: { language: lang } } : {},
+        content: [{ type: "text", text: codeLines.join("\n") }]
+      });
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      content.push({
+        type: "heading",
+        attrs: { level },
+        content: [{ type: "text", text: headingMatch[2] }]
+      });
+      i++;
+      continue;
+    }
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const paragraphLines = [];
+    while (i < lines.length && lines[i].trim() && !lines[i].startsWith("```") && !lines[i].match(/^#{1,6}\s/)) {
+      paragraphLines.push(lines[i]);
+      i++;
+    }
+    if (paragraphLines.length > 0) {
+      content.push({
+        type: "paragraph",
+        content: [{ type: "text", text: paragraphLines.join("\n") }]
+      });
+    }
+  }
+  if (content.length === 0) {
+    content.push({ type: "paragraph", content: [] });
+  }
+  return { version: 1, type: "doc", content };
+}
+function adfToPlainText(adf) {
+  if (!adf?.content) return "";
+  return adf.content.map(nodeToText).filter(Boolean).join("\n\n");
+}
+function nodeToText(node) {
+  switch (node.type) {
+    case "text":
+      return node.text ?? "";
+    case "paragraph":
+      return childrenToText(node);
+    case "heading": {
+      const level = node.attrs?.level ?? 1;
+      const prefix = "#".repeat(level);
+      return `${prefix} ${childrenToText(node)}`;
+    }
+    case "codeBlock": {
+      const lang = node.attrs?.language ?? "";
+      return `\`\`\`${lang}
+${childrenToText(node)}
+\`\`\``;
+    }
+    case "hardBreak":
+      return "\n";
+    case "bulletList":
+    case "orderedList":
+      return (node.content ?? []).map((li, idx) => {
+        const prefix = node.type === "orderedList" ? `${idx + 1}. ` : "- ";
+        return `${prefix}${childrenToText(li)}`;
+      }).join("\n");
+    default:
+      return childrenToText(node);
+  }
+}
+function childrenToText(node) {
+  if (!node.content) return node.text ?? "";
+  return node.content.map(nodeToText).join("");
+}
+var init_adf = __esm({
+  "src/integrations/jira/adf.ts"() {
+    "use strict";
+  }
+});
+
+// src/integrations/jira/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  autoPushTask: () => autoPushTask,
+  deltaPull: () => deltaPull,
+  fullPullAllIssues: () => fullPullAllIssues,
+  getJiraSyncStatus: () => getJiraSyncStatus,
+  isJiraPushSuccess: () => isJiraPushSuccess,
+  mapToLocal: () => mapToLocal,
+  syncTasks: () => syncTasks
+});
+import path12 from "path";
+function getJiraConfig(config) {
+  return config.plugins?.jira;
+}
+function ext(task) {
+  return task.ext?.jira;
+}
+function mapToLocal(remote, config) {
+  const jiraConfig = getJiraConfig(config);
+  const statusName = remote.fields.status.name;
+  const statusCategoryKey = remote.fields.status.statusCategory?.key;
+  const phase = phaseFromJiraStatus(statusName, statusCategoryKey);
+  const status = deriveStatusFromPhase(phase);
+  let priority = "none";
+  if (remote.fields.priority?.name) {
+    priority = JIRA_TO_LOCAL_PRIORITY[remote.fields.priority.name] ?? "none";
+  }
+  let project = remote.fields.project.key;
+  if (jiraConfig.project_mapping) {
+    const entry = Object.entries(jiraConfig.project_mapping).find(
+      ([, jiraKey]) => jiraKey === remote.fields.project.key
+    );
+    if (entry) project = entry[0];
+  }
+  const description = adfToPlainText(remote.fields.description);
+  return {
+    title: remote.fields.summary,
+    status,
+    phase,
+    priority,
+    project,
+    source: "jira",
+    ext: {
+      jira: {
+        issue_id: remote.id,
+        issue_key: remote.key,
+        project_key: remote.fields.project.key,
+        status_name: statusName
+      }
+    },
+    external_url: `${jiraConfig.base_url}/browse/${remote.key}`,
+    description,
+    due_date: remote.fields.duedate ?? void 0,
+    created_at: remote.fields.created,
+    updated_at: remote.fields.updated
+  };
+}
+function composeCommentBody(task) {
+  const headers = [];
+  if (task.parent_task_id) headers.push(`Parent: ${task.parent_task_id.slice(0, 8)}`);
+  if (task.unread) headers.push(`Attention: true`);
+  if (task.depends_on?.length) headers.push(`DependsOn: ${task.depends_on.map((id) => id.slice(0, 8)).join(",")}`);
+  const sections = [];
+  if (task.summary) sections.push(`## Summary
+${task.summary}`);
+  if (task.note) sections.push(`## Notes
+${task.note}`);
+  if (task.conversation_log) sections.push(`## Conversation Log
+${task.conversation_log}`);
+  const body = sections.join("\n\n");
+  if (headers.length > 0 && body) return headers.join("\n") + "\n\n" + body;
+  if (headers.length > 0) return headers.join("\n");
+  return body;
+}
+function isJiraPushSuccess(r) {
+  return "jiraIssueId" in r;
+}
+async function autoPushTask(task) {
+  try {
+    const config = await getConfig();
+    const jiraConfig = getJiraConfig(config);
+    if (!jiraConfig?.base_url) {
+      return { error: "Jira base_url not configured" };
+    }
+    const client = new JiraClient(jiraConfig);
+    const je = ext(task);
+    const issueKey = je?.issue_key;
+    const issueId = je?.issue_id;
+    const statusName = je?.status_name;
+    const commentId_raw = je?.comment_id;
+    if (issueKey) {
+      const updateInput = {
+        fields: {
+          summary: task.title,
+          description: task.description ? plainTextToAdf(task.description) : void 0,
+          priority: task.priority !== "none" ? { name: LOCAL_TO_JIRA_PRIORITY[task.priority] } : void 0,
+          duedate: task.due_date ?? null
+        }
+      };
+      await client.updateIssue(issueKey, updateInput);
+      const targetStatus = PHASE_TO_JIRA_STATUS[task.phase];
+      if (targetStatus && targetStatus.toLowerCase() !== (statusName ?? "").toLowerCase()) {
+        try {
+          const { transitions } = await client.getTransitions(issueKey);
+          const transitionId = resolveTransition(transitions, targetStatus);
+          if (transitionId) {
+            await client.doTransition(issueKey, transitionId);
+            syncLog.debug("transitioned Jira issue", { key: issueKey, to: targetStatus });
+          }
+        } catch (err) {
+          syncLog.debug("failed to transition Jira issue", {
+            key: issueKey,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      const commentBody = composeCommentBody(task);
+      let commentId = commentId_raw;
+      if (commentBody) {
+        const adfBody = markdownToAdf(commentBody);
+        if (commentId) {
+          try {
+            await client.updateComment(issueKey, commentId, adfBody);
+          } catch {
+            try {
+              const newComment = await client.addComment(issueKey, adfBody);
+              commentId = newComment.id;
+            } catch {
+            }
+          }
+        } else {
+          try {
+            const newComment = await client.addComment(issueKey, adfBody);
+            commentId = newComment.id;
+          } catch {
+          }
+        }
+      }
+      let serverTimestamp;
+      try {
+        const freshIssue = await client.getIssue(issueKey);
+        serverTimestamp = freshIssue.fields.updated;
+      } catch {
+      }
+      syncLog.info("pushed task update to Jira", { key: issueKey, title: task.title });
+      return { jiraIssueId: issueId ?? "", jiraIssueKey: issueKey, commentId, serverTimestamp };
+    } else {
+      const projectKey = resolveProjectKey(task, config);
+      const createInput = {
+        fields: {
+          project: { key: projectKey },
+          summary: task.title,
+          issuetype: { name: jiraConfig.issue_type ?? "Task" },
+          description: task.description ? plainTextToAdf(task.description) : void 0,
+          priority: task.priority !== "none" ? { name: LOCAL_TO_JIRA_PRIORITY[task.priority] } : void 0,
+          duedate: task.due_date
+        }
+      };
+      const created = await client.createIssue(createInput);
+      let commentId;
+      const commentBody = composeCommentBody(task);
+      if (commentBody) {
+        try {
+          const comment = await client.addComment(created.key, markdownToAdf(commentBody));
+          commentId = comment.id;
+        } catch {
+        }
+      }
+      let serverTimestamp;
+      try {
+        const freshIssue = await client.getIssue(created.key);
+        serverTimestamp = freshIssue.fields.updated;
+      } catch {
+      }
+      syncLog.info("created issue in Jira", { key: created.key, title: task.title });
+      return { jiraIssueId: created.id, jiraIssueKey: created.key, commentId, serverTimestamp };
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    syncLog.error("failed to push task to Jira", {
+      taskId: task.id,
+      error: message
+    });
+    return { error: message };
+  }
+}
+async function deltaPull(updateLocalTask, addLocalTask) {
+  const config = await getConfig();
+  const jiraConfig = getJiraConfig(config);
+  if (!jiraConfig?.base_url) return false;
+  const client = new JiraClient(jiraConfig);
+  const syncState = await readJsonFile(JIRA_SYNC_FILE, { lastSync: "" });
+  const jqlParts = [];
+  jqlParts.push(`project = "${jiraConfig.project_key}"`);
+  if (syncState.lastSync) {
+    const since = formatJqlDate(syncState.lastSync);
+    jqlParts.push(`updated >= "${since}"`);
+  }
+  if (jiraConfig.assignee_filter) {
+    if (jiraConfig.assignee_filter === "currentUser") {
+      jqlParts.push("assignee = currentUser()");
+    } else {
+      jqlParts.push(`assignee = "${jiraConfig.assignee_filter}"`);
+    }
+  }
+  if (jiraConfig.jql_filter) {
+    jqlParts.push(`(${jiraConfig.jql_filter})`);
+  }
+  const jql = jqlParts.join(" AND ") + " ORDER BY updated DESC";
+  const searchResult = await client.searchIssues(jql, {
+    maxResults: 100,
+    fields: [
+      "summary",
+      "description",
+      "status",
+      "priority",
+      "project",
+      "issuetype",
+      "created",
+      "updated",
+      "duedate",
+      "assignee",
+      "comment",
+      "subtasks",
+      "parent"
+    ]
+  });
+  if (searchResult.issues.length === 0) {
+    syncState.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+    await writeJsonFile(JIRA_SYNC_FILE, syncState);
+    return false;
+  }
+  let hasChanges = false;
+  for (const remote of searchResult.issues) {
+    const existing = await findTaskByExtId("jira", remote.key);
+    if (existing) {
+      const remoteUpdated = new Date(remote.fields.updated).getTime();
+      const syncedAt = existing._syncedAt ? new Date(existing._syncedAt).getTime() : 0;
+      if (remoteUpdated > syncedAt) {
+        const updates = mapToLocal(remote, config);
+        delete updates.source;
+        delete updates.note;
+        delete updates.summary;
+        delete updates.conversation_log;
+        const remoteStatusName = remote.fields.status.name;
+        if (existing.phase && updates.phase) {
+          if (shouldPreserveLocalPhaseJira(existing.phase, remoteStatusName)) {
+            delete updates.phase;
+            delete updates.status;
+          }
+        }
+        await updateLocalTask(existing.id, updates);
+        bus.emit(EventNames.TASK_UPDATED, { task: { ...existing, ...updates } }, ["web-ui"], { source: "jira-sync" });
+        hasChanges = true;
+        syncLog.debug("updated local task from Jira", { key: remote.key, title: remote.fields.summary });
+      }
+    } else {
+      const partial = mapToLocal(remote, config);
+      const now = remote.fields.created || (/* @__PURE__ */ new Date()).toISOString();
+      const newTask = await addLocalTask({
+        title: partial.title ?? remote.fields.summary,
+        status: partial.status ?? "todo",
+        phase: partial.phase ?? "TODO",
+        priority: partial.priority ?? "none",
+        // Falls back to the reserved project so a provider task never lands in
+        // Inbox, which is structurally local-only.
+        project: partial.project ?? jiraConfig.project,
+        source: "jira",
+        ext: partial.ext,
+        external_url: partial.external_url,
+        session_ids: [],
+        created_at: now,
+        updated_at: remote.fields.updated || now,
+        due_date: partial.due_date,
+        description: partial.description ?? "",
+        summary: "",
+        note: ""
+      });
+      bus.emit(EventNames.TASK_CREATED, { task: newTask }, ["web-ui"], { source: "jira-sync" });
+      hasChanges = true;
+      syncLog.debug("created local task from Jira", { key: remote.key, title: remote.fields.summary });
+    }
+  }
+  syncState.lastSync = (/* @__PURE__ */ new Date()).toISOString();
+  await writeJsonFile(JIRA_SYNC_FILE, syncState);
+  if (hasChanges) {
+    syncLog.info(`Jira sync: pulled ${searchResult.issues.length} issues`);
+  }
+  return hasChanges;
+}
+async function fullPullAllIssues() {
+  const config = await getConfig();
+  const jiraConfig = getJiraConfig(config);
+  if (!jiraConfig?.base_url) return [];
+  const client = new JiraClient(jiraConfig);
+  const jqlParts = [];
+  jqlParts.push(`project = "${jiraConfig.project_key}"`);
+  if (jiraConfig.assignee_filter) {
+    if (jiraConfig.assignee_filter === "currentUser") {
+      jqlParts.push("assignee = currentUser()");
+    } else {
+      jqlParts.push(`assignee = "${jiraConfig.assignee_filter}"`);
+    }
+  }
+  if (jiraConfig.jql_filter) {
+    jqlParts.push(`(${jiraConfig.jql_filter})`);
+  }
+  const jql = jqlParts.join(" AND ") + " ORDER BY updated DESC";
+  const jqlFields = [
+    "summary",
+    "description",
+    "status",
+    "priority",
+    "project",
+    "issuetype",
+    "created",
+    "updated",
+    "duedate",
+    "assignee",
+    "parent"
+  ];
+  const result = [];
+  let startAt = 0;
+  const maxPerPage = 100;
+  let total = Infinity;
+  while (startAt < total) {
+    const searchResult = await client.searchIssues(jql, {
+      maxResults: maxPerPage,
+      startAt,
+      fields: jqlFields
+    });
+    total = searchResult.total;
+    for (const issue of searchResult.issues) {
+      const fields = mapToLocal(issue, config);
+      result.push({
+        remoteId: issue.key,
+        title: issue.fields.summary,
+        remoteUpdatedAt: issue.fields.updated,
+        fields
+      });
+    }
+    startAt += searchResult.issues.length;
+    if (searchResult.issues.length === 0) break;
+  }
+  return result;
+}
+async function syncTasks(updateLocalTask, addLocalTask, updateTaskRaw) {
+  let pushed = 0;
+  const config = await getConfig();
+  const jiraConfig = getJiraConfig(config);
+  const unsynced = await listUnsyncedTasks("jira");
+  for (const task of unsynced) {
+    const result = await autoPushTask(task);
+    if (isJiraPushSuccess(result)) {
+      await updateTaskRaw(task.id, {
+        ext: {
+          jira: {
+            issue_id: result.jiraIssueId,
+            issue_key: result.jiraIssueKey,
+            ...result.commentId ? { comment_id: result.commentId } : {}
+          }
+        },
+        external_url: jiraConfig ? `${jiraConfig.base_url}/browse/${result.jiraIssueKey}` : ""
+      });
+      pushed++;
+    }
+  }
+  const pulled = await deltaPull(updateLocalTask, addLocalTask);
+  return { pushed, pulled };
+}
+async function getJiraSyncStatus() {
+  const config = await getConfig();
+  const jiraConfig = getJiraConfig(config);
+  if (!jiraConfig?.base_url) {
+    return { configured: false, hasCredentials: false };
+  }
+  return {
+    configured: true,
+    hasCredentials: !!jiraConfig.auth?.token,
+    baseUrl: jiraConfig.base_url,
+    projectKey: jiraConfig.project_key,
+    project: jiraConfig.project
+  };
+}
+function resolveProjectKey(task, config) {
+  const jiraConfig = getJiraConfig(config);
+  if (jiraConfig.project_mapping && task.project) {
+    const mapped = jiraConfig.project_mapping[task.project];
+    if (mapped) return mapped;
+  }
+  return jiraConfig.project_key;
+}
+function formatJqlDate(iso) {
+  const d = new Date(iso);
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  const hh = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd} ${hh}:${min}`;
+}
+var JIRA_SYNC_FILE, syncLog, LOCAL_TO_JIRA_PRIORITY, JIRA_TO_LOCAL_PRIORITY;
+var init_sync = __esm({
+  "src/integrations/jira/sync.ts"() {
+    "use strict";
+    init_constants();
+    init_fs();
+    init_config_manager();
+    init_logging();
+    init_event_bus();
+    init_phase();
+    init_task_manager();
+    init_jira_client();
+    init_workflow();
+    init_adf();
+    JIRA_SYNC_FILE = path12.join(SYNC_DIR, "jira-sync.json");
+    syncLog = createSubsystemLogger("jira");
+    LOCAL_TO_JIRA_PRIORITY = {
+      immediate: "Highest",
+      important: "High",
+      backlog: "Low",
+      none: "Medium"
+    };
+    JIRA_TO_LOCAL_PRIORITY = {
+      "Highest": "immediate",
+      "High": "important",
+      "Medium": "none",
+      "Low": "backlog",
+      "Lowest": "backlog"
+    };
+  }
+});
+
+// src/integrations/jira/index.ts
+function register(api) {
+  const config = api.config;
+  const reservedProject = config.project || "";
+  const sync = {
+    async createTask(task) {
+      const { autoPushTask: autoPushTask2, isJiraPushSuccess: isJiraPushSuccess2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      const result = await autoPushTask2(task);
+      if (isJiraPushSuccess2(result)) {
+        return {
+          jira: {
+            issue_id: result.jiraIssueId,
+            issue_key: result.jiraIssueKey,
+            comment_id: result.commentId
+          }
+        };
+      }
+      if (result.error) throw new Error(result.error);
+      return null;
+    },
+    async deleteTask(_task) {
+    },
+    async updateTitle(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateDescription(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateSummary(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateNote(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateConversationLog(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updatePriority(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updatePhase(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateDueDate(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateStar(_task) {
+    },
+    async updateProject(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async updateDependencies(task) {
+      const { autoPushTask: autoPushTask2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await autoPushTask2(task);
+    },
+    async pushTask(task) {
+      const { autoPushTask: autoPushTask2, isJiraPushSuccess: isJiraPushSuccess2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      const result = await autoPushTask2(task);
+      if (isJiraPushSuccess2(result)) {
+        return {
+          serverTimestamp: result.serverTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+          ext: {
+            jira: {
+              issue_id: result.jiraIssueId,
+              issue_key: result.jiraIssueKey,
+              comment_id: result.commentId
+            }
+          }
+        };
+      }
+      throw new Error(result.error);
+    },
+    async associateSubtask(_parent, _child) {
+    },
+    async disassociateSubtask(_parent, _child) {
+    },
+    async syncPoll(ctx) {
+      const { deltaPull: deltaPull2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      await deltaPull2(
+        async (id, updates) => {
+          await ctx.updateTask(id, updates);
+        },
+        async (taskData) => {
+          const t = await ctx.addTask(taskData);
+          return t;
+        }
+      );
+    },
+    async fullPull() {
+      const { fullPullAllIssues: fullPullAllIssues2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      return fullPullAllIssues2();
+    },
+    extractRemoteId(task) {
+      return task.ext?.jira?.issue_key;
+    }
+  };
+  api.registerSync(sync);
+  api.registerExtIndex({
+    source: "jira",
+    paths: [{ key: "issue_key", json: "$.jira.issue_key" }]
+  });
+  api.registerSourceClaim((project) => {
+    return reservedProject ? project.toLowerCase() === reservedProject.toLowerCase() : false;
+  }, { priority: 0 });
+  api.registerDisplay({
+    badge: "J",
+    badgeColor: "#0052CC",
+    externalLinkLabel: "Jira",
+    getExternalUrl: (task) => task.external_url || null,
+    isSynced: (task) => !!task.ext?.jira?.issue_key,
+    syncTooltip: (task) => task.sync_error ? `Sync error: ${task.sync_error}` : "Synced to Jira"
+  });
+  api.registerAgentContext(
+    'Tasks with source "jira" sync bidirectionally with Jira. Phase maps to Jira workflow transitions (To Do \u2192 In Progress \u2192 In Review \u2192 Done).'
+  );
+  api.registerMigration((tasks) => {
+    for (const task of tasks) {
+      const raw = task;
+      if (raw.jira_issue_id && !task.ext?.jira) {
+        if (!task.ext) task.ext = {};
+        task.ext.jira = {
+          issue_id: raw.jira_issue_id,
+          issue_key: raw.jira_issue_key,
+          project_key: raw.jira_project_key,
+          comment_id: raw.jira_comment_id,
+          status_name: raw.jira_status_name
+        };
+        delete raw.jira_issue_id;
+        delete raw.jira_issue_key;
+        delete raw.jira_project_key;
+        delete raw.jira_comment_id;
+        delete raw.jira_status_name;
+      }
+    }
+    return tasks;
+  });
+}
+export {
+  register as default
+};
+//# sourceMappingURL=index.js.map