@goondocks/myco 0.11.0 → 0.12.0

package/dist/{main-UBUZTMGV.js → main-3NTAT7ZD.js}

@@ -15,13 +15,13 @@ import {
   getEmbeddingQueueDepth,
   getUnembedded,
   markEmbedded
-} from "./chunk-CHG652UO.js";
+} from "./chunk-RGRPAKEY.js";
 import {
   getMachineId
 } from "./chunk-ENWBFX7F.js";
 import {
   createEmbeddingProvider
-} from "./chunk-MKKXCCQ5.js";
+} from "./chunk-JHLALJPB.js";
 import {
   closeOpenBatches,
   countRuns,
@@ -44,54 +44,54 @@ import {
   listTurnsByRun,
   populateBatchResponses,
   setResponseSummary
-} from "./chunk-FFQES5MC.js";
+} from "./chunk-TCGOSLW6.js";
 import {
   fullTextSearch,
   hydrateSearchResults
-} from "./chunk-W6HI4CCS.js";
+} from "./chunk-D4M2AV65.js";
 import {
   copyTaskToUser,
   deleteUserTask,
   loadAllTasks,
   validateTaskName,
   writeUserTask
-} from "./chunk-6LL2MQHP.js";
+} from "./chunk-D4ESHOOJ.js";
 import {
   AgentTaskSchema,
   registerAgent,
   resolveDefinitionsDir,
   taskFromParsed
-} from "./chunk-ZAHDA2PQ.js";
+} from "./chunk-7NBDELZB.js";
 import {
   checkLocalProvider
-} from "./chunk-C3AEZ3BZ.js";
+} from "./chunk-YRUJ5KGV.js";
 import {
   EventBuffer,
   cleanStaleBuffers,
   listBufferSessionIds
 } from "./chunk-V7XG6V6C.js";
 import "./chunk-IB76KGBY.js";
-import "./chunk-AEJS57ZK.js";
-import "./chunk-5QERXFH7.js";
-import "./chunk-FPMEIN2W.js";
+import "./chunk-J3L2RTYK.js";
+import "./chunk-SW62AX75.js";
+import "./chunk-QL2RBFIC.js";
 import {
   loadSecrets,
   readSecrets,
   writeSecret
 } from "./chunk-RJMXDUMA.js";
-import "./chunk-LYFDTF7G.js";
+import "./chunk-YRHSTVCZ.js";
 import "./chunk-SAKJMNSR.js";
 import {
   LmStudioBackend,
   OllamaBackend
-} from "./chunk-5SDH75YC.js";
+} from "./chunk-LUQBT2Y4.js";
 import {
   countSpores,
   getSpore,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-U7UUJ4FD.js";
+} from "./chunk-Q2AYS2QE.js";
 import {
   closeSession,
   countSessions,
@@ -101,7 +101,7 @@ import {
   listSessions,
   updateSession,
   upsertSession
-} from "./chunk-CUDM5YJY.js";
+} from "./chunk-JROOQQH6.js";
 import {
   backfillUnsynced,
   countPending,
@@ -110,12 +110,12 @@ import {
   markSent,
   pruneOld,
   syncRow
-} from "./chunk-XLY3REL3.js";
+} from "./chunk-4VSNNMEU.js";
 import {
   EMBEDDING_DIMENSIONS,
   SCHEMA_VERSION,
   createSchema
-} from "./chunk-WZZH3YXJ.js";
+} from "./chunk-PW5QVY44.js";
 import {
   CONFIG_FILENAME,
   MycoConfigSchema,
@@ -132,7 +132,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   resolveCliEntryPath
-} from "./chunk-YKOEMLJJ.js";
+} from "./chunk-DPJVKNNP.js";
 import {
   CONTENT_HASH_ALGORITHM,
   DAEMON_EVICT_POLL_MS,
@@ -140,6 +140,7 @@ import {
   DEAD_SESSION_MAX_PROMPTS,
   DEFAULT_AGENT_ID,
   DEFAULT_MACHINE_ID,
+  DEFAULT_RELEASE_CHANNEL,
   EMBEDDING_BATCH_SIZE,
   EXCLUDED_SPORE_STATUSES,
   FEED_DEFAULT_LIMIT,
@@ -147,7 +148,11 @@ import {
   LOG_MESSAGE_PREVIEW_CHARS,
   LOG_PROMPT_PREVIEW_CHARS,
   MS_PER_DAY,
+  MS_PER_HOUR,
   MS_PER_SECOND,
+  MYCO_GLOBAL_DIR,
+  NPM_PACKAGE_NAME,
+  NPM_REGISTRY_URL,
   POWER_ACTIVE_INTERVAL_MS,
   POWER_DEEP_SLEEP_THRESHOLD_MS,
   POWER_IDLE_THRESHOLD_MS,
@@ -158,6 +163,8 @@ import {
   PROMPT_CONTEXT_MIN_SIMILARITY,
   PROMPT_PREVIEW_CHARS,
   PROMPT_VECTOR_OVER_FETCH,
+  RELEASE_CHANNELS,
+  RESTART_RESPONSE_FLUSH_MS,
   SEARCH_RESULTS_DEFAULT_LIMIT,
   SEARCH_SIMILARITY_THRESHOLD,
   STALE_BUFFER_MAX_AGE_MS,
@@ -167,19 +174,24 @@ import {
   TEAM_HEALTH_TIMEOUT_MS,
   TEAM_SEARCH_TIMEOUT_MS,
   TEAM_SOURCE_PREFIX,
+  UPDATE_CHECK_CACHE_PATH,
+  UPDATE_CHECK_INTERVAL_HOURS,
+  UPDATE_CONFIG_PATH,
+  UPDATE_ERROR_PATH,
+  UPDATE_SCRIPT_DELAY_SECONDS,
   USER_AGENT_ID,
   USER_AGENT_NAME,
   USER_TASK_SOURCE,
   epochSeconds,
   estimateTokens
-} from "./chunk-76ZO5RGT.js";
+} from "./chunk-PIRWYDOH.js";
 import {
   LOG_KINDS,
   kindToComponent
 } from "./chunk-S6I62FAH.js";
 import {
   getPluginVersion
-} from "./chunk-JYXMRW3T.js";
+} from "./chunk-TY7A5OZ5.js";
 import {
   loadManifests
 } from "./chunk-QFMBZ72S.js";
@@ -1634,7 +1646,6 @@ import { spawn } from "child_process";
 var RestartBodySchema = external_exports.object({
   force: external_exports.boolean().optional()
 }).optional();
-var RESTART_RESPONSE_FLUSH_MS = 500;
 var RESTART_CHILD_DELAY_SECONDS = 3;
 async function handleRestart(deps, body) {
   const parsed = RestartBodySchema.safeParse(body);
@@ -1658,9 +1669,287 @@ async function handleRestart(deps, body) {
   return { body: { status: "restarting" } };
 }
 
-// src/daemon/backup.ts
+// src/daemon/update-checker.ts
+var import_yaml = __toESM(require_dist(), 1);
 import fs8 from "fs";
 import path10 from "path";
+import semver from "semver";
+var REGISTRY_FETCH_TIMEOUT_MS = 1e4;
+function isUpdateExempt() {
+  return Boolean(process.env.MYCO_CMD);
+}
+function defaultUpdateConfig() {
+  return {
+    channel: DEFAULT_RELEASE_CHANNEL,
+    check_interval_hours: UPDATE_CHECK_INTERVAL_HOURS
+  };
+}
+function readUpdateConfig() {
+  try {
+    const raw = fs8.readFileSync(UPDATE_CONFIG_PATH, "utf-8");
+    const parsed = import_yaml.default.parse(raw);
+    const channel = RELEASE_CHANNELS.includes(parsed?.channel) ? parsed.channel : DEFAULT_RELEASE_CHANNEL;
+    const check_interval_hours = typeof parsed?.check_interval_hours === "number" && parsed.check_interval_hours > 0 ? parsed.check_interval_hours : UPDATE_CHECK_INTERVAL_HOURS;
+    return { channel, check_interval_hours };
+  } catch {
+    return defaultUpdateConfig();
+  }
+}
+function writeUpdateConfig(config) {
+  fs8.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
+  fs8.writeFileSync(UPDATE_CONFIG_PATH, import_yaml.default.stringify(config), "utf-8");
+}
+function readCachedCheck() {
+  try {
+    const raw = fs8.readFileSync(UPDATE_CHECK_CACHE_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearCachedCheck() {
+  try {
+    fs8.unlinkSync(UPDATE_CHECK_CACHE_PATH);
+  } catch {
+  }
+}
+function isCacheStale(cache, intervalHours) {
+  if (cache === null) return true;
+  const checkedAt = new Date(cache.checked_at).getTime();
+  if (isNaN(checkedAt)) return true;
+  const ageMs = Date.now() - checkedAt;
+  return ageMs > intervalHours * MS_PER_HOUR;
+}
+function resolveTargetVersion(distTags, channel) {
+  const stable = distTags.latest;
+  const beta = distTags.beta ?? null;
+  if (channel === "stable" || beta === null) {
+    return stable;
+  }
+  const higher = semver.gt(beta, stable) ? beta : stable;
+  return higher;
+}
+function buildCheckResult(currentVersion, cache, config, error) {
+  const targetVersion = resolveTargetVersion(
+    { latest: cache.latest_stable, beta: cache.latest_beta ?? void 0 },
+    cache.channel
+  );
+  const update_available = semver.valid(currentVersion) !== null && semver.valid(targetVersion) !== null && semver.gt(targetVersion, currentVersion);
+  return {
+    update_available,
+    running_version: currentVersion,
+    latest_version: targetVersion,
+    latest_stable: cache.latest_stable,
+    latest_beta: cache.latest_beta,
+    channel: cache.channel,
+    check_interval_hours: config.check_interval_hours,
+    last_check: cache.checked_at,
+    error
+  };
+}
+async function checkForUpdate(currentVersion) {
+  const config = readUpdateConfig();
+  const existingCache = readCachedCheck();
+  let distTags;
+  let fetchError = null;
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: AbortSignal.timeout(REGISTRY_FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(`Registry responded with ${response.status}`);
+    }
+    const data = await response.json();
+    distTags = data["dist-tags"];
+  } catch (err) {
+    fetchError = err instanceof Error ? err.message : String(err);
+    if (existingCache !== null) {
+      return buildCheckResult(currentVersion, existingCache, config, fetchError);
+    }
+    return {
+      update_available: false,
+      running_version: currentVersion,
+      latest_version: currentVersion,
+      latest_stable: currentVersion,
+      latest_beta: null,
+      channel: config.channel,
+      check_interval_hours: config.check_interval_hours,
+      last_check: (/* @__PURE__ */ new Date()).toISOString(),
+      error: fetchError
+    };
+  }
+  const latestStable = distTags.latest;
+  const latestBeta = distTags.beta ?? null;
+  const targetVersion = resolveTargetVersion(distTags, config.channel);
+  const freshCache = {
+    checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+    current_version: currentVersion,
+    latest_stable: latestStable,
+    latest_beta: latestBeta,
+    channel: config.channel
+  };
+  try {
+    fs8.mkdirSync(path10.dirname(UPDATE_CHECK_CACHE_PATH), { recursive: true });
+    fs8.writeFileSync(UPDATE_CHECK_CACHE_PATH, JSON.stringify(freshCache, null, 2), "utf-8");
+  } catch {
+  }
+  return buildCheckResult(currentVersion, freshCache, config, null);
+}
+function statusFromCache(currentVersion, cache, config) {
+  const resolvedCache = cache !== void 0 ? cache : readCachedCheck();
+  if (resolvedCache === null) return null;
+  const resolvedConfig = config !== void 0 ? config : readUpdateConfig();
+  return buildCheckResult(currentVersion, resolvedCache, resolvedConfig, null);
+}
+
+// src/daemon/update-installer.ts
+import fs9 from "fs";
+import os7 from "os";
+import path11 from "path";
+import { spawn as spawn2 } from "child_process";
+function generateUpdateScript(params) {
+  const { targetVersion, projectRoot, vaultDir } = params;
+  const packageSpec = `${NPM_PACKAGE_NAME}@${targetVersion}`;
+  const quotedProjectRoot = JSON.stringify(projectRoot);
+  const quotedVaultDir = JSON.stringify(vaultDir);
+  const quotedErrorPath = JSON.stringify(UPDATE_ERROR_PATH);
+  const errorJson = JSON.stringify(
+    JSON.stringify({ error: `npm install failed for ${packageSpec}` })
+  );
+  return `#!/bin/sh
+set -e
+
+# Wait for daemon to exit cleanly
+sleep ${UPDATE_SCRIPT_DELAY_SECONDS}
+
+# Attempt the update
+if npm install -g ${packageSpec} 2>&1; then
+  # Sync project files (gitignore, symbiont registration)
+  myco update --project ${quotedProjectRoot} || true
+  # Clear any previous error
+  rm -f ${quotedErrorPath}
+else
+  # Write error and attempt restart with old version
+  echo ${errorJson} > ${quotedErrorPath}
+fi
+
+# Restart daemon (works whether install succeeded or failed)
+myco daemon --vault ${quotedVaultDir} &
+
+# Clean up this script
+rm -f "$0"
+`;
+}
+function spawnUpdateScript(params) {
+  fs9.mkdirSync(MYCO_GLOBAL_DIR, { recursive: true });
+  const scriptName = `myco-update-${Date.now()}.sh`;
+  const scriptPath = path11.join(os7.tmpdir(), scriptName);
+  const script = generateUpdateScript(params);
+  fs9.writeFileSync(scriptPath, script, { encoding: "utf-8", mode: 493 });
+  const child = spawn2("/bin/sh", [scriptPath], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  return scriptPath;
+}
+
+// src/daemon/api/update.ts
+var ChannelBodySchema = external_exports.object({
+  channel: external_exports.enum(RELEASE_CHANNELS)
+});
+function createUpdateHandlers(deps) {
+  const { vaultDir, projectRoot, currentVersion, scheduleShutdown } = deps;
+  async function handleUpdateStatus(_req) {
+    if (isUpdateExempt()) {
+      return { body: { exempt: true, running_version: currentVersion } };
+    }
+    const config = readUpdateConfig();
+    const cache = readCachedCheck();
+    if (isCacheStale(cache, config.check_interval_hours)) {
+      checkForUpdate(currentVersion).catch(() => {
+      });
+    }
+    const status = statusFromCache(currentVersion, cache, config);
+    if (!status) {
+      return {
+        body: {
+          exempt: false,
+          update_available: false,
+          running_version: currentVersion,
+          latest_version: currentVersion,
+          latest_stable: currentVersion,
+          latest_beta: null,
+          channel: config.channel,
+          check_interval_hours: config.check_interval_hours,
+          last_check: "",
+          error: null
+        }
+      };
+    }
+    return { body: { exempt: false, ...status } };
+  }
+  async function handleUpdateCheck(_req) {
+    if (isUpdateExempt()) {
+      return {
+        status: 400,
+        body: { error: "update_exempt", message: "Updates disabled in dev mode" }
+      };
+    }
+    const result = await checkForUpdate(currentVersion);
+    return { body: { exempt: false, ...result } };
+  }
+  async function handleUpdateApply(_req) {
+    if (isUpdateExempt()) {
+      return { status: 400, body: { error: "update_exempt" } };
+    }
+    const status = statusFromCache(currentVersion);
+    if (!status || !status.update_available) {
+      return { status: 400, body: { error: "no_update_available" } };
+    }
+    spawnUpdateScript({ targetVersion: status.latest_version, projectRoot, vaultDir });
+    scheduleShutdown();
+    return { body: { status: "applying", version: status.latest_version } };
+  }
+  async function handleUpdateChannel(req) {
+    const parsed = ChannelBodySchema.safeParse(req.body);
+    if (!parsed.success) {
+      return { status: 400, body: { error: "invalid_channel" } };
+    }
+    const { channel } = parsed.data;
+    const config = readUpdateConfig();
+    writeUpdateConfig({ ...config, channel });
+    clearCachedCheck();
+    const channelStatus = statusFromCache(currentVersion);
+    if (!channelStatus) {
+      return {
+        body: {
+          exempt: false,
+          update_available: false,
+          running_version: currentVersion,
+          latest_version: currentVersion,
+          latest_stable: currentVersion,
+          latest_beta: null,
+          channel,
+          check_interval_hours: config.check_interval_hours,
+          last_check: "",
+          error: null
+        }
+      };
+    }
+    return { body: { exempt: false, ...channelStatus } };
+  }
+  return {
+    handleUpdateStatus,
+    handleUpdateCheck,
+    handleUpdateApply,
+    handleUpdateChannel
+  };
+}
+
+// src/daemon/backup.ts
+import fs10 from "fs";
+import path12 from "path";
 var BACKUP_TABLES = [
   "sessions",
   "prompt_batches",
@@ -1686,7 +1975,7 @@ function toSqlLiteral(value) {
   return `'${escapeSql(String(value))}'`;
 }
 function createBackup(db, backupDir, machineId) {
-  fs8.mkdirSync(backupDir, { recursive: true });
+  fs10.mkdirSync(backupDir, { recursive: true });
   const lines = [];
   const timestamp = epochSeconds();
   lines.push(`${BACKUP_HEADER_TEMPLATE}: machine_id=${machineId}, created_at=${timestamp}`);
@@ -1704,22 +1993,22 @@ function createBackup(db, backupDir, machineId) {
     }
     lines.push("");
   }
-  const filePath = path10.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
-  fs8.writeFileSync(filePath, lines.join("\n"), "utf-8");
+  const filePath = path12.join(backupDir, `${machineId}${BACKUP_EXTENSION}`);
+  fs10.writeFileSync(filePath, lines.join("\n"), "utf-8");
   return filePath;
 }
 function listBackups(backupDir) {
   let entries;
   try {
-    entries = fs8.readdirSync(backupDir);
+    entries = fs10.readdirSync(backupDir);
   } catch {
     return [];
   }
   const backups = [];
   for (const entry of entries) {
     if (!entry.endsWith(BACKUP_EXTENSION)) continue;
-    const filePath = path10.join(backupDir, entry);
-    const stat = fs8.statSync(filePath);
+    const filePath = path12.join(backupDir, entry);
+    const stat = fs10.statSync(filePath);
     backups.push({
       machine_id: entry.slice(0, -BACKUP_EXTENSION.length),
       file_name: entry,
@@ -1731,7 +2020,7 @@ function listBackups(backupDir) {
 }
 var INSERT_REGEX = /^INSERT OR IGNORE INTO (\w+)\s+\(([^)]+)\)\s+VALUES\s+\((.+)\);$/;
 function parseBackupFile(backupPath) {
-  const content = fs8.readFileSync(backupPath, "utf-8");
+  const content = fs10.readFileSync(backupPath, "utf-8");
   const inserts = [];
   for (const line of content.split("\n")) {
     const match = INSERT_REGEX.exec(line);
@@ -1980,15 +2269,15 @@ var TeamSyncClient = class {
       "Content-Type": "application/json"
     };
   }
-  async request(method, path14, body) {
-    const res = await this.fetchFn(`${this.workerUrl}${path14}`, {
+  async request(method, path16, body) {
+    const res = await this.fetchFn(`${this.workerUrl}${path16}`, {
       method,
       headers: this.headers(),
       body: body !== void 0 ? JSON.stringify(body) : void 0
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Team sync request ${method} ${path14} failed: ${res.status} ${text}`);
+      throw new Error(`Team sync request ${method} ${path16} failed: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -2224,12 +2513,12 @@ async function handleGetModels(req) {
 
 // src/daemon/api/stats.ts
 import { createHash as createHash3 } from "crypto";
-import fs9 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path13 from "path";
 function computeConfigHash(vaultDir) {
   try {
-    const configPath = path11.join(vaultDir, CONFIG_FILENAME);
-    const raw = fs9.readFileSync(configPath, "utf-8");
+    const configPath = path13.join(vaultDir, CONFIG_FILENAME);
+    const raw = fs11.readFileSync(configPath, "utf-8");
     return createHash3("md5").update(raw).digest("hex");
   } catch {
     return "";
@@ -3825,7 +4114,7 @@ var SqliteRecordSource = class {
 };
 
 // src/daemon/api/agent-tasks.ts
-var import_yaml = __toESM(require_dist(), 1);
+var import_yaml2 = __toESM(require_dist(), 1);
 var HTTP_OK = 200;
 var HTTP_CREATED = 201;
 var HTTP_BAD_REQUEST = 400;
@@ -3913,7 +4202,7 @@ async function handleGetTaskYaml(req, vaultDir) {
     return { status: HTTP_NOT_FOUND, body: { error: "task_not_found", name: taskName } };
   }
   const { isBuiltin: _ib, source: _src, ...serializable } = task;
-  const yaml = (0, import_yaml.stringify)(serializable);
+  const yaml = (0, import_yaml2.stringify)(serializable);
   return { status: HTTP_OK, body: { yaml, source: task.source } };
 }
 async function handleUpdateTask(req, vaultDir) {
@@ -3933,7 +4222,7 @@ async function handleUpdateTask(req, vaultDir) {
     return { status: HTTP_BAD_REQUEST, body: { error: "missing_yaml_field" } };
   }
   try {
-    const parsed = AgentTaskSchema.parse((0, import_yaml.parse)(yamlContent));
+    const parsed = AgentTaskSchema.parse((0, import_yaml2.parse)(yamlContent));
     const task = { ...taskFromParsed(parsed), isBuiltin: false, source: USER_TASK_SOURCE };
     if (task.name !== taskName) {
       return { status: HTTP_BAD_REQUEST, body: { error: "name_mismatch", expected: taskName, got: task.name } };
@@ -4046,19 +4335,19 @@ function testCloud() {
 }
 
 // src/daemon/log-reconcile.ts
-import fs10 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path14 from "path";
 function reconcileLogBuffer(logDir, sinceTimestamp) {
   let replayed = 0;
   const files = [];
   for (let i = 3; i >= 1; i--) {
-    const rotated = path12.join(logDir, `daemon.${i}.log`);
-    if (fs10.existsSync(rotated)) files.push(rotated);
+    const rotated = path14.join(logDir, `daemon.${i}.log`);
+    if (fs12.existsSync(rotated)) files.push(rotated);
   }
-  const current = path12.join(logDir, "daemon.log");
-  if (fs10.existsSync(current)) files.push(current);
+  const current = path14.join(logDir, "daemon.log");
+  if (fs12.existsSync(current)) files.push(current);
   for (const file of files) {
-    const content = fs10.readFileSync(file, "utf-8");
+    const content = fs12.readFileSync(file, "utf-8");
     for (const line of content.split("\n")) {
       if (!line.trim()) continue;
       try {
@@ -4274,8 +4563,8 @@ async function runSessionMaintenance(deps) {
 }
 
 // src/daemon/main.ts
-import fs11 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path15 from "path";
 var AGENT_RUNS_DEFAULT_LIMIT = 50;
 var TOOL_INPUT_STORE_LIMIT = 4e3;
 var TOOL_OUTPUT_STORE_LIMIT = 2e3;
@@ -4401,10 +4690,10 @@ function handleCompact(sessionId, phase, trigger, compactSummary) {
   });
 }
 function killStaleDaemon(vaultDir, logger) {
-  const daemonJsonPath = path13.join(vaultDir, "daemon.json");
+  const daemonJsonPath = path15.join(vaultDir, "daemon.json");
   try {
-    if (!fs11.existsSync(daemonJsonPath)) return;
-    const info = JSON.parse(fs11.readFileSync(daemonJsonPath, "utf-8"));
+    if (!fs13.existsSync(daemonJsonPath)) return;
+    const info = JSON.parse(fs13.readFileSync(daemonJsonPath, "utf-8"));
     if (!info.pid) return;
     if (info.pid === process.pid) return;
     try {
@@ -4413,7 +4702,7 @@ function killStaleDaemon(vaultDir, logger) {
       logger.info(LOG_KINDS.DAEMON_START, "Killed stale daemon", { pid: info.pid });
     } catch {
     }
-    fs11.unlinkSync(daemonJsonPath);
+    fs13.unlinkSync(daemonJsonPath);
   } catch {
   }
 }
@@ -4423,7 +4712,7 @@ async function main() {
     process.stderr.write("Usage: mycod --vault <path>\n");
     process.exit(1);
   }
-  const vaultDir = path13.resolve(vaultArg);
+  const vaultDir = path15.resolve(vaultArg);
   loadSecrets(vaultDir);
   const config = loadConfig(vaultDir);
   const manifests = loadManifests();
@@ -4434,7 +4723,7 @@ async function main() {
     projectRoot,
     extensions: config.capture.artifact_extensions
   };
-  const logger = new DaemonLogger(path13.join(vaultDir, "logs"), {
+  const logger = new DaemonLogger(path15.join(vaultDir, "logs"), {
     level: config.daemon.log_level
   });
   killStaleDaemon(vaultDir, logger);
@@ -4463,13 +4752,13 @@ async function main() {
   });
   const lastLogTimestamp = getMaxTimestamp();
   if (lastLogTimestamp) {
-    const logDir = path13.join(vaultDir, "logs");
+    const logDir = path15.join(vaultDir, "logs");
     const replayedCount = reconcileLogBuffer(logDir, lastLogTimestamp);
     if (replayedCount > 0) {
       logger.info(LOG_KINDS.DAEMON_RECONCILE, `Replayed ${replayedCount} log entries from buffer`, { replayed: replayedCount });
     }
   }
-  const vectorsDbPath = path13.join(vaultDir, "vectors.db");
+  const vectorsDbPath = path15.join(vaultDir, "vectors.db");
   const vectorStore = new SqliteVecVectorStore(vectorsDbPath);
   const llmProvider = createEmbeddingProvider(config.embedding);
   const embeddingProvider = new EmbeddingProviderAdapter(llmProvider, config.embedding);
@@ -4477,7 +4766,7 @@ async function main() {
   const embeddingManager = new EmbeddingManager(vectorStore, embeddingProvider, recordSource, logger);
   logger.info(LOG_KINDS.EMBEDDING_EMBED, "EmbeddingManager initialized", { vectors_db: vectorsDbPath });
   try {
-    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-DGWP4EFB.js");
+    const { registerBuiltInAgentsAndTasks, resolveDefinitionsDir: resolveDefinitionsDir2 } = await import("./loader-BQ4X4K3F.js");
     const definitionsDir = resolveDefinitionsDir2();
     await registerBuiltInAgentsAndTasks(definitionsDir, vaultDir);
     logger.info(LOG_KINDS.AGENT_TASK, "Built-in agents and tasks registered");
@@ -4503,10 +4792,10 @@ async function main() {
   }
   let uiDir = null;
   {
-    const root = findPackageRoot(path13.dirname(new URL(import.meta.url).pathname));
+    const root = findPackageRoot(path15.dirname(new URL(import.meta.url).pathname));
     if (root) {
-      const candidate = path13.join(root, "dist", "ui");
-      if (fs11.existsSync(candidate)) uiDir = candidate;
+      const candidate = path15.join(root, "dist", "ui");
+      if (fs13.existsSync(candidate)) uiDir = candidate;
     }
   }
   if (uiDir) {
@@ -4543,7 +4832,7 @@ async function main() {
     const running = getRunningRun(DEFAULT_AGENT_ID);
     if (running) return;
     try {
-      const { runAgent } = await import("./executor-SWXSN7ZC.js");
+      const { runAgent } = await import("./executor-ESRLUCGU.js");
       runAgent(vaultDir, {
         task: "title-summary",
         instruction: `Process session ${sessionId} only`,
@@ -4552,7 +4841,7 @@ async function main() {
     } catch {
     }
   }
-  const bufferDir = path13.join(vaultDir, "buffer");
+  const bufferDir = path15.join(vaultDir, "buffer");
   const sessionBuffers = /* @__PURE__ */ new Map();
   const startupCleanedCount = cleanStaleBuffers(bufferDir, STALE_BUFFER_MAX_AGE_MS);
   if (startupCleanedCount > 0) {
@@ -4596,9 +4885,9 @@ async function main() {
   function reconcileSession(sessionId) {
     if (reconciledSessions.has(sessionId)) return;
     reconciledSessions.add(sessionId);
-    const bufferPath = path13.join(bufferDir, `${sessionId}.jsonl`);
-    if (!fs11.existsSync(bufferPath)) return;
-    const content = fs11.readFileSync(bufferPath, "utf-8").trim();
+    const bufferPath = path15.join(bufferDir, `${sessionId}.jsonl`);
+    if (!fs13.existsSync(bufferPath)) return;
+    const content = fs13.readFileSync(bufferPath, "utf-8").trim();
     if (!content) return;
     if (!getSession(sessionId)) {
       logger.debug(LOG_KINDS.LIFECYCLE_RECONCILE, "Skipping reconciliation for deleted session", { session_id: sessionId });
@@ -4753,10 +5042,10 @@ async function main() {
       );
       if (planFilePath) {
         const captureSessionId = event.session_id;
-        fs11.promises.readFile(planFilePath, "utf-8").then((planContent) => {
+        fs13.promises.readFile(planFilePath, "utf-8").then((planContent) => {
           const latestBatch = getLatestBatch(captureSessionId);
           capturePlan({
-            sourcePath: path13.relative(projectRoot, planFilePath),
+            sourcePath: path15.relative(projectRoot, planFilePath),
             content: planContent,
             sessionId: captureSessionId,
             promptBatchId: latestBatch?.id ?? null
@@ -5142,6 +5431,21 @@ async function main() {
   });
   server.registerRoute("GET", "/api/models", async (req) => handleGetModels(req));
   server.registerRoute("POST", "/api/restart", async (req) => handleRestart({ vaultDir, progressTracker }, req.body));
+  const updateProjectRoot = path15.dirname(vaultDir);
+  const updateHandlers = createUpdateHandlers({
+    vaultDir,
+    projectRoot: updateProjectRoot,
+    currentVersion: server.version,
+    scheduleShutdown: () => {
+      setTimeout(() => {
+        process.kill(process.pid, "SIGTERM");
+      }, RESTART_RESPONSE_FLUSH_MS);
+    }
+  });
+  server.registerRoute("GET", "/api/update/status", async (req) => updateHandlers.handleUpdateStatus(req));
+  server.registerRoute("POST", "/api/update/check", async (req) => updateHandlers.handleUpdateCheck(req));
+  server.registerRoute("POST", "/api/update/apply", async (req) => updateHandlers.handleUpdateApply(req));
+  server.registerRoute("PUT", "/api/update/channel", async (req) => updateHandlers.handleUpdateChannel(req));
   server.registerRoute("GET", "/api/progress/:token", async (req) => handleGetProgress(progressTracker, req.params.token));
   server.registerRoute("GET", "/api/sessions", handleListSessions);
   server.registerRoute("GET", "/api/sessions/:id", handleGetSession);
@@ -5191,14 +5495,14 @@ async function main() {
       const contentType2 = att.media_type ?? "application/octet-stream";
       return { status: 200, headers: { "Content-Type": contentType2 }, body: att.data };
     }
-    const filePath = path13.join(vaultDir, "attachments", filename);
+    const filePath = path15.join(vaultDir, "attachments", filename);
     let diskData;
     try {
-      diskData = fs11.readFileSync(filePath);
+      diskData = fs13.readFileSync(filePath);
     } catch {
       return { status: 404, body: { error: "not_found" } };
     }
-    const ext = path13.extname(filename).slice(1).toLowerCase();
+    const ext = path15.extname(filename).slice(1).toLowerCase();
     const contentType = ATTACHMENT_MEDIA_TYPES[ext] ?? "application/octet-stream";
     return { status: 200, headers: { "Content-Type": contentType }, body: diskData };
   });
@@ -5209,7 +5513,7 @@ async function main() {
   });
   server.registerRoute("POST", "/api/agent/run", async (req) => {
     const { task, instruction, agentId } = AgentRunBody.parse(req.body);
-    const { runAgent } = await import("./executor-SWXSN7ZC.js");
+    const { runAgent } = await import("./executor-ESRLUCGU.js");
     const resultPromise = runAgent(vaultDir, { task, instruction, agentId, embeddingManager });
     const effectiveAgentId = agentId ?? "myco-agent";
     const latestRun = getRunningRun(effectiveAgentId);
@@ -5390,7 +5694,7 @@ async function main() {
       name: USER_AGENT_NAME,
       created_at: now
     });
-    const { insertResolutionEvent } = await import("./resolution-events-UPHJJLDQ.js");
+    const { insertResolutionEvent } = await import("./resolution-events-WZHPQQMN.js");
     const resolutionId = `res-${randomBytes(RESOLUTION_ID_RANDOM_BYTES).toString("hex")}`;
     insertResolutionEvent({
       id: resolutionId,
@@ -5409,7 +5713,7 @@ async function main() {
       }
     };
   });
-  const backupDir = config.backup.dir ? path13.resolve(config.backup.dir) : path13.resolve(vaultDir, "backups");
+  const backupDir = config.backup.dir ? path15.resolve(config.backup.dir) : path15.resolve(vaultDir, "backups");
   const backupHandlers = createBackupHandlers({ db, backupDir, machineId });
   server.registerRoute("POST", "/api/backup", backupHandlers.handleCreateBackup);
   server.registerRoute("GET", "/api/backups", backupHandlers.handleListBackups);
@@ -5417,7 +5721,7 @@ async function main() {
   server.registerRoute("POST", "/api/restore", backupHandlers.handleRestore);
   server.registerRoute("GET", "/api/backup/config", async () => {
     const cfg = loadConfig(vaultDir);
-    return { body: { dir: cfg.backup.dir ?? null, default_dir: path13.resolve(vaultDir, "backups") } };
+    return { body: { dir: cfg.backup.dir ?? null, default_dir: path15.resolve(vaultDir, "backups") } };
   });
   server.registerRoute("PUT", "/api/backup/config", async (req) => {
     const { dir } = req.body;
@@ -5545,7 +5849,7 @@ async function main() {
         lastAgentRun = Date.now();
         try {
           logger.info(LOG_KINDS.AGENT_AUTO_RUN, "Unprocessed batches found, starting agent", { count });
-          const { runAgent } = await import("./executor-SWXSN7ZC.js");
+          const { runAgent } = await import("./executor-ESRLUCGU.js");
           const runResult = await runAgent(vaultDir, { embeddingManager });
           logger.info(LOG_KINDS.AGENT_RUN, "Agent run completed", { status: runResult.status, runId: runResult.runId });
         } catch (err) {
@@ -5650,4 +5954,4 @@ export {
   handleUserPrompt,
   main
 };
-//# sourceMappingURL=main-UBUZTMGV.js.map
+//# sourceMappingURL=main-3NTAT7ZD.js.map