@lydia-agent/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3419 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import { ReplayManager, StrategyRegistry as StrategyRegistry3, StrategyReviewer, StrategyApprovalService as StrategyApprovalService2, ShadowRouter as ShadowRouter2, ConfigLoader as ConfigLoader3, MemoryManager as MemoryManager2, BasicStrategyGate, StrategyUpdateGate, resolveCanonicalComputerUseToolName } from "@lydia-agent/core";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import * as readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+import open from "open";
+
+// src/server/index.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import {
+  MemoryManager,
+  ConfigLoader as ConfigLoader2,
+  Agent,
+  StrategyRegistry as StrategyRegistry2,
+  StrategyApprovalService,
+  ShadowRouter,
+  createLLMFromConfig
+} from "@lydia-agent/core";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { readFile as readFile2, mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2 } from "path";
+import { randomUUID } from "crypto";
+
+// src/mcp/health.ts
+import { McpClientManager } from "@lydia-agent/core";
+function timeoutError(timeoutMs) {
+  return new Error(`Timeout after ${timeoutMs}ms`);
+}
+async function withTimeout(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(timeoutError(timeoutMs)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function checkMcpServer(target, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const retries = Math.max(0, options.retries ?? 0);
+  const start = Date.now();
+  let attempts = 0;
+  let lastError = null;
+  while (attempts <= retries) {
+    attempts += 1;
+    const manager = new McpClientManager();
+    try {
+      await withTimeout(
+        manager.connect({
+          id: target.id,
+          type: "stdio",
+          command: target.command,
+          args: target.args || [],
+          env: target.env
+        }),
+        timeoutMs
+      );
+      const tools = manager.getTools().map((t) => t.name);
+      return {
+        id: target.id,
+        ok: true,
+        tools,
+        durationMs: Date.now() - start,
+        attempts
+      };
+    } catch (error) {
+      lastError = error;
+    } finally {
+      await manager.closeAll().catch(() => {
+      });
+    }
+  }
+  return {
+    id: target.id,
+    ok: false,
+    tools: [],
+    durationMs: Date.now() - start,
+    attempts,
+    error: lastError instanceof Error ? lastError.message : String(lastError)
+  };
+}
+async function checkMcpServers(targets, options = {}) {
+  const results = [];
+  for (const target of targets) {
+    results.push(await checkMcpServer(target, options));
+  }
+  return results;
+}
+
+// src/service/constants.ts
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 15536;
+var STATUS_POLL_INTERVAL_MS = 300;
+var STATUS_POLL_TIMEOUT_MS = 1e4;
+
+// src/service/runtime.ts
+import { ConfigLoader, StrategyRegistry } from "@lydia-agent/core";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+function getLydiaPaths(home = os.homedir()) {
+  const baseDir = path.join(home, ".lydia");
+  const strategiesDir = path.join(baseDir, "strategies");
+  const skillsDir = path.join(baseDir, "skills");
+  const dataDir = path.join(baseDir, "data");
+  const logsDir = path.join(baseDir, "logs");
+  const runDir = path.join(baseDir, "run");
+  return {
+    home,
+    baseDir,
+    configPath: path.join(baseDir, "config.json"),
+    dataDir,
+    logsDir,
+    runDir,
+    skillsDir,
+    strategiesDir,
+    strategyPath: path.join(strategiesDir, "default.yml"),
+    serverPidPath: path.join(runDir, "server.pid"),
+    serverStatePath: path.join(runDir, "server.json"),
+    serverLogPath: path.join(logsDir, "server.log"),
+    serverErrorLogPath: path.join(logsDir, "server-error.log")
+  };
+}
+function getBaseUrl(port = DEFAULT_PORT, host = DEFAULT_HOST) {
+  return `http://${host}:${port}`;
+}
+async function initLocalWorkspace() {
+  const paths = getLydiaPaths();
+  const created = [];
+  const existing = [];
+  const dirs = [
+    paths.baseDir,
+    paths.strategiesDir,
+    paths.skillsDir,
+    paths.dataDir,
+    paths.logsDir,
+    paths.runDir
+  ];
+  for (const dir of dirs) {
+    if (fs.existsSync(dir)) {
+      existing.push(dir);
+      continue;
+    }
+    await fsPromises.mkdir(dir, { recursive: true });
+    created.push(dir);
+  }
+  const loader = new ConfigLoader();
+  if (!fs.existsSync(paths.configPath)) {
+    const config2 = await loader.load();
+    await fsPromises.writeFile(paths.configPath, JSON.stringify(config2, null, 2), "utf-8");
+    created.push(paths.configPath);
+  } else {
+    existing.push(paths.configPath);
+  }
+  if (!fs.existsSync(paths.strategyPath)) {
+    const registry = new StrategyRegistry();
+    const strategy = await registry.loadDefault();
+    const initial = {
+      ...strategy,
+      metadata: {
+        ...strategy.metadata,
+        id: "default",
+        version: "1.0.0",
+        name: "Default Strategy",
+        description: "Baseline strategy for safe execution."
+      }
+    };
+    await registry.saveToFile(initial, paths.strategyPath);
+    created.push(paths.strategyPath);
+  } else {
+    existing.push(paths.strategyPath);
+  }
+  const config = await loader.load();
+  if (!config.strategy.activePath) {
+    await loader.update({
+      strategy: {
+        activePath: paths.strategyPath
+      }
+    });
+  }
+  return { paths, created, existing };
+}
+async function readServiceState() {
+  const { serverStatePath } = getLydiaPaths();
+  try {
+    const raw = await fsPromises.readFile(serverStatePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeServiceState(state) {
+  const { serverStatePath, serverPidPath } = getLydiaPaths();
+  await fsPromises.mkdir(path.dirname(serverStatePath), { recursive: true });
+  await fsPromises.writeFile(serverStatePath, JSON.stringify(state, null, 2), "utf-8");
+  await fsPromises.writeFile(serverPidPath, `${state.pid}
+`, "utf-8");
+}
+async function removeServiceState() {
+  const { serverStatePath, serverPidPath } = getLydiaPaths();
+  await Promise.all([
+    fsPromises.rm(serverStatePath, { force: true }),
+    fsPromises.rm(serverPidPath, { force: true })
+  ]);
+}
+
+// src/server/index.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+function getSetupPaths() {
+  const paths = getLydiaPaths();
+  return {
+    baseDir: paths.baseDir,
+    strategiesDir: paths.strategiesDir,
+    skillsDir: paths.skillsDir,
+    configPath: paths.configPath,
+    strategyPath: paths.strategyPath
+  };
+}
+function maskSecret(value) {
+  if (!value) return "";
+  if (value.length <= 8) return "*".repeat(value.length);
+  return `${value.slice(0, 4)}${"*".repeat(Math.max(4, value.length - 8))}${value.slice(-4)}`;
+}
+function pickString(value) {
+  if (typeof value !== "string") return void 0;
+  return value.trim();
+}
+async function ensureLocalWorkspace() {
+  const { strategiesDir, skillsDir, configPath, strategyPath } = getSetupPaths();
+  await mkdir2(strategiesDir, { recursive: true });
+  await mkdir2(skillsDir, { recursive: true });
+  const loader = new ConfigLoader2();
+  if (!existsSync2(configPath)) {
+    const config2 = await loader.load();
+    await writeFile2(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  }
+  if (!existsSync2(strategyPath)) {
+    const registry = new StrategyRegistry2();
+    const strategy = await registry.loadDefault();
+    const initial = {
+      ...strategy,
+      metadata: {
+        ...strategy.metadata,
+        id: "default",
+        version: "1.0.0",
+        name: "Default Strategy"
+      }
+    };
+    await registry.saveToFile(initial, strategyPath);
+  }
+  const config = await loader.load();
+  if (!config.strategy.activePath) {
+    await loader.update({ strategy: { activePath: strategyPath } });
+  }
+  return getSetupPaths();
+}
+function createServer(port = DEFAULT_PORT, options) {
+  const app = new Hono();
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+  const configLoader = new ConfigLoader2();
+  const runs = /* @__PURE__ */ new Map();
+  let activeRunId = null;
+  const wsClients = /* @__PURE__ */ new Set();
+  const apiSessions = /* @__PURE__ */ new Map();
+  let authState = {
+    required: false,
+    apiToken: "",
+    sessionTtlMs: 24 * 60 * 60 * 1e3
+  };
+  let lastConfigRefreshAt = 0;
+  function broadcastWs(message) {
+    const data = JSON.stringify(message);
+    for (const ws of wsClients) {
+      try {
+        ws.send(data);
+      } catch {
+        wsClients.delete(ws);
+      }
+    }
+  }
+  function isPublicApiPath(path3) {
+    return path3 === "/api/status" || path3.startsWith("/api/setup") || path3 === "/api/auth/session";
+  }
+  function extractBearerToken(headerValue) {
+    if (!headerValue) return "";
+    const lower = headerValue.toLowerCase();
+    if (!lower.startsWith("bearer ")) return "";
+    return headerValue.slice(7).trim();
+  }
+  function pruneExpiredSessions(now) {
+    for (const [id, expiresAt] of apiSessions.entries()) {
+      if (expiresAt <= now) {
+        apiSessions.delete(id);
+      }
+    }
+  }
+  function isValidSession(sessionId) {
+    if (!sessionId) return false;
+    const now = Date.now();
+    pruneExpiredSessions(now);
+    const expiresAt = apiSessions.get(sessionId);
+    if (!expiresAt || expiresAt <= now) {
+      apiSessions.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+  app.get("/ws", upgradeWebSocket(() => ({
+    onOpen(_event, ws) {
+      wsClients.add(ws);
+      ws.send(JSON.stringify({
+        type: "connected",
+        data: { status: activeRunId ? "running" : "idle", activeRunId },
+        timestamp: Date.now()
+      }));
+    },
+    onMessage(event, ws) {
+      try {
+        const msg = JSON.parse(String(event.data));
+        if (msg.type === "ping") {
+          ws.send(JSON.stringify({ type: "pong", timestamp: Date.now() }));
+        }
+      } catch {
+      }
+    },
+    onClose(_event, ws) {
+      wsClients.delete(ws);
+    },
+    onError(_event, ws) {
+      wsClients.delete(ws);
+    }
+  })));
+  const dbPath = join2(homedir2(), ".lydia", "memory.db");
+  const soulPath = join2(homedir2(), ".lydia", "Soul.md");
+  const memoryManager = options?.memoryManager || new MemoryManager(dbPath);
+  const approvalService = new StrategyApprovalService(memoryManager, configLoader);
+  const shadowRouter = new ShadowRouter(memoryManager);
+  async function readSoulProfile() {
+    try {
+      if (!existsSync2(soulPath)) return {};
+      const content = await readFile2(soulPath, "utf-8");
+      const userDisplayName = content.match(/^- User display name: (.+)$/m)?.[1]?.trim();
+      const assistantDisplayName = content.match(/^- Assistant display name: (.+)$/m)?.[1]?.trim();
+      const updatedAt = content.match(/^- Updated at: (.+)$/m)?.[1]?.trim();
+      return {
+        userDisplayName: userDisplayName || void 0,
+        assistantDisplayName: assistantDisplayName || void 0,
+        updatedAt: updatedAt || void 0
+      };
+    } catch {
+      return {};
+    }
+  }
+  async function writeSoulProfile(profile) {
+    const next = {
+      ...profile,
+      assistantDisplayName: profile.assistantDisplayName || "Lydia",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const content = [
+      "# Soul",
+      "",
+      "Core identity notes for Lydia chat.",
+      "",
+      "## Identity",
+      `- User display name: ${next.userDisplayName || ""}`,
+      `- Assistant display name: ${next.assistantDisplayName}`,
+      `- Updated at: ${next.updatedAt}`,
+      ""
+    ].join("\n");
+    await writeFile2(soulPath, content, "utf-8");
+  }
+  function normalizeSoulName(value) {
+    if (!value) return void 0;
+    const cleaned = value.replace(/[*`"'“”‘’<>]/g, "").replace(/[。！!,.，~～：:]+$/g, "").replace(/^(叫|是)/, "").replace(/了$/g, "").trim();
+    if (!cleaned || cleaned.length > 24) return void 0;
+    return cleaned;
+  }
+  function inferSoulFromMessage(message) {
+    const userPatterns = [
+      /(?:从现在起|以后)?我(?:就)?叫\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /(?:从现在起|以后)?我(?:就)?是\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /(?:从现在起|以后)?(?:你|您)(?:可以|就)?叫我\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /(?:请|就)?称呼我\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /\bcall me\s+([a-zA-Z][a-zA-Z0-9 _-]{0,23})/i
+    ];
+    const assistantPatterns = [
+      /(?:你|您)(?:以后|就)?叫\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /(?:你的名字是|你叫)\s*[:：]?\s*([^\n，。,.!！]+)/i,
+      /\byour name is\s+([a-zA-Z][a-zA-Z0-9 _-]{0,23})/i
+    ];
+    let userDisplayName;
+    let assistantDisplayName;
+    for (const pattern of userPatterns) {
+      const value = normalizeSoulName(message.match(pattern)?.[1]);
+      if (value) {
+        userDisplayName = value;
+        break;
+      }
+    }
+    for (const pattern of assistantPatterns) {
+      const value = normalizeSoulName(message.match(pattern)?.[1]);
+      if (value) {
+        assistantDisplayName = value;
+        break;
+      }
+    }
+    return { userDisplayName, assistantDisplayName };
+  }
+  async function updateSoulFromMessage(message) {
+    const current = await readSoulProfile();
+    const inferred = inferSoulFromMessage(message);
+    if (!inferred.userDisplayName && !inferred.assistantDisplayName) {
+      return current;
+    }
+    await writeSoulProfile({
+      userDisplayName: inferred.userDisplayName || current.userDisplayName,
+      assistantDisplayName: inferred.assistantDisplayName || current.assistantDisplayName || "Lydia"
+    });
+    return readSoulProfile();
+  }
+  async function createRoutedAgent(llm) {
+    const currentConfig = await configLoader.load();
+    const routedStrategy = await shadowRouter.selectStrategy(currentConfig);
+    const agent = new Agent(
+      llm,
+      routedStrategy.path ? { strategyPathOverride: routedStrategy.path } : {}
+    );
+    return { agent, routedStrategy };
+  }
+  function formatErrorMessage(error) {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+    return String(error);
+  }
+  async function refreshRuntimeConfig(force = false) {
+    const now = Date.now();
+    if (!force && now - lastConfigRefreshAt < 5e3) return;
+    const config = await configLoader.load();
+    lastConfigRefreshAt = now;
+    const configuredToken = String(config.server?.apiToken || "").trim();
+    const envToken = String(process.env.LYDIA_API_TOKEN || "").trim();
+    const apiToken = envToken || configuredToken;
+    const sessionTtlHours = Math.max(1, Number(config.server?.sessionTtlHours || 24));
+    authState = {
+      required: apiToken.length > 0,
+      apiToken,
+      sessionTtlMs: sessionTtlHours * 60 * 60 * 1e3
+    };
+    const checkpointTtlHours = Math.max(1, Number(config.memory?.checkpointTtlHours || 24));
+    const observationTtlHours = Math.max(1, Number(config.memory?.observationFrameTtlHours || 24 * 7));
+    memoryManager.cleanupStaleCheckpoints(checkpointTtlHours * 60 * 60 * 1e3);
+    memoryManager.cleanupStaleObservationFrames(observationTtlHours * 60 * 60 * 1e3);
+  }
+  refreshRuntimeConfig(true).catch(() => {
+  });
+  app.use("/api/*", async (c, next) => {
+    await refreshRuntimeConfig();
+    if (!authState.required || isPublicApiPath(c.req.path)) {
+      await next();
+      return;
+    }
+    const bearer = extractBearerToken(c.req.header("authorization"));
+    const sessionId = c.req.header("x-lydia-session");
+    if (bearer === authState.apiToken || isValidSession(sessionId)) {
+      await next();
+      return;
+    }
+    return c.json({ error: "Unauthorized" }, 401);
+  });
+  app.post("/api/auth/session", async (c) => {
+    await refreshRuntimeConfig();
+    if (!authState.required) {
+      return c.json({
+        ok: true,
+        authRequired: false,
+        message: "API token auth is disabled."
+      });
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const providedToken = typeof body?.token === "string" ? body.token.trim() : "";
+    if (!providedToken || providedToken !== authState.apiToken) {
+      return c.json({ error: "Invalid API token" }, 401);
+    }
+    const sessionId = `lsess-${randomUUID()}`;
+    const expiresAt = Date.now() + authState.sessionTtlMs;
+    apiSessions.set(sessionId, expiresAt);
+    return c.json({
+      ok: true,
+      authRequired: true,
+      sessionId,
+      expiresAt
+    });
+  });
+  app.get("/api/status", (c) => {
+    return c.json({
+      status: "ok",
+      version: "0.1.0",
+      pid: process.pid,
+      host: DEFAULT_HOST,
+      port,
+      baseUrl: getBaseUrl(port, DEFAULT_HOST),
+      uptimeMs: Math.round(process.uptime() * 1e3),
+      startedAt: new Date(Date.now() - Math.round(process.uptime() * 1e3)).toISOString(),
+      memory_db: dbPath
+    });
+  });
+  app.get("/api/setup", async (c) => {
+    const { configPath, strategyPath } = getSetupPaths();
+    const ready = existsSync2(configPath) && existsSync2(strategyPath);
+    const config = await configLoader.load();
+    const hasConfiguredKey = Boolean(config.llm.openaiApiKey || config.llm.anthropicApiKey);
+    const hasEnvKey = Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY);
+    return c.json({
+      ready,
+      configPath,
+      strategyPath,
+      llmConfigured: hasConfiguredKey || hasEnvKey,
+      provider: config.llm.provider || "auto"
+    });
+  });
+  app.post("/api/setup/init", async (c) => {
+    try {
+      const paths = await ensureLocalWorkspace();
+      return c.json({
+        ok: true,
+        ready: existsSync2(paths.configPath) && existsSync2(paths.strategyPath),
+        ...paths
+      });
+    } catch (error) {
+      return c.json({ error: error?.message || "Failed to initialize workspace." }, 500);
+    }
+  });
+  app.get("/api/soul", async (c) => {
+    const soul = await readSoulProfile();
+    return c.json({
+      userDisplayName: soul.userDisplayName,
+      assistantDisplayName: soul.assistantDisplayName || "Lydia",
+      updatedAt: soul.updatedAt
+    });
+  });
+  app.get("/api/setup/config", async (c) => {
+    const { configPath, strategyPath } = getSetupPaths();
+    const config = await configLoader.load();
+    const openaiKey = config.llm.openaiApiKey || process.env.OPENAI_API_KEY || "";
+    const anthropicKey = config.llm.anthropicApiKey || process.env.ANTHROPIC_API_KEY || "";
+    return c.json({
+      ready: existsSync2(configPath) && existsSync2(strategyPath),
+      llm: {
+        provider: config.llm.provider,
+        defaultModel: config.llm.defaultModel,
+        fallbackOrder: config.llm.fallbackOrder,
+        openaiBaseUrl: config.llm.openaiBaseUrl,
+        anthropicBaseUrl: config.llm.anthropicBaseUrl,
+        ollamaBaseUrl: config.llm.ollamaBaseUrl,
+        openaiApiKeySet: Boolean(openaiKey),
+        anthropicApiKeySet: Boolean(anthropicKey),
+        openaiApiKeyMasked: maskSecret(openaiKey),
+        anthropicApiKeyMasked: maskSecret(anthropicKey)
+      },
+      server: {
+        hasApiToken: Boolean(config.server.apiToken || process.env.LYDIA_API_TOKEN),
+        sessionTtlHours: config.server.sessionTtlHours
+      },
+      memory: {
+        checkpointTtlHours: config.memory.checkpointTtlHours,
+        observationFrameTtlHours: config.memory.observationFrameTtlHours
+      }
+    });
+  });
+  app.post("/api/setup/config", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const llmInput = body?.llm || {};
+    const serverInput = body?.server || {};
+    const memoryInput = body?.memory || {};
+    const provider = pickString(llmInput.provider);
+    const defaultModel = pickString(llmInput.defaultModel);
+    const openaiBaseUrl = pickString(llmInput.openaiBaseUrl);
+    const anthropicBaseUrl = pickString(llmInput.anthropicBaseUrl);
+    const ollamaBaseUrl = pickString(llmInput.ollamaBaseUrl);
+    const fallbackOrder = Array.isArray(llmInput.fallbackOrder) ? llmInput.fallbackOrder.filter((item) => typeof item === "string") : void 0;
+    const providerSet = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "mock", "auto"]);
+    if (provider && !providerSet.has(provider)) {
+      return c.json({ error: `Unsupported provider: ${provider}` }, 400);
+    }
+    const updateLlm = {};
+    if (provider !== void 0) updateLlm.provider = provider;
+    if (defaultModel !== void 0) updateLlm.defaultModel = defaultModel;
+    if (fallbackOrder !== void 0) updateLlm.fallbackOrder = fallbackOrder;
+    if (openaiBaseUrl !== void 0) updateLlm.openaiBaseUrl = openaiBaseUrl;
+    if (anthropicBaseUrl !== void 0) updateLlm.anthropicBaseUrl = anthropicBaseUrl;
+    if (ollamaBaseUrl !== void 0) updateLlm.ollamaBaseUrl = ollamaBaseUrl;
+    if (Object.prototype.hasOwnProperty.call(llmInput, "openaiApiKey")) {
+      updateLlm.openaiApiKey = String(llmInput.openaiApiKey || "").trim();
+    }
+    if (Object.prototype.hasOwnProperty.call(llmInput, "anthropicApiKey")) {
+      updateLlm.anthropicApiKey = String(llmInput.anthropicApiKey || "").trim();
+    }
+    const updateServer = {};
+    if (Object.prototype.hasOwnProperty.call(serverInput, "apiToken")) {
+      updateServer.apiToken = String(serverInput.apiToken || "").trim();
+    }
+    if (Object.prototype.hasOwnProperty.call(serverInput, "sessionTtlHours")) {
+      const sessionTtlHours = Number(serverInput.sessionTtlHours);
+      if (!Number.isNaN(sessionTtlHours) && sessionTtlHours > 0) {
+        updateServer.sessionTtlHours = sessionTtlHours;
+      }
+    }
+    const updateMemory = {};
+    if (Object.prototype.hasOwnProperty.call(memoryInput, "checkpointTtlHours")) {
+      const checkpointTtlHours = Number(memoryInput.checkpointTtlHours);
+      if (!Number.isNaN(checkpointTtlHours) && checkpointTtlHours > 0) {
+        updateMemory.checkpointTtlHours = checkpointTtlHours;
+      }
+    }
+    if (Object.prototype.hasOwnProperty.call(memoryInput, "observationFrameTtlHours")) {
+      const observationFrameTtlHours = Number(memoryInput.observationFrameTtlHours);
+      if (!Number.isNaN(observationFrameTtlHours) && observationFrameTtlHours > 0) {
+        updateMemory.observationFrameTtlHours = observationFrameTtlHours;
+      }
+    }
+    try {
+      const next = await configLoader.update({
+        llm: updateLlm,
+        server: updateServer,
+        memory: updateMemory
+      });
+      await refreshRuntimeConfig(true);
+      return c.json({
+        ok: true,
+        llm: {
+          provider: next.llm.provider,
+          defaultModel: next.llm.defaultModel,
+          fallbackOrder: next.llm.fallbackOrder,
+          openaiBaseUrl: next.llm.openaiBaseUrl,
+          anthropicBaseUrl: next.llm.anthropicBaseUrl,
+          ollamaBaseUrl: next.llm.ollamaBaseUrl,
+          openaiApiKeySet: Boolean(next.llm.openaiApiKey),
+          anthropicApiKeySet: Boolean(next.llm.anthropicApiKey),
+          openaiApiKeyMasked: maskSecret(next.llm.openaiApiKey),
+          anthropicApiKeyMasked: maskSecret(next.llm.anthropicApiKey)
+        },
+        server: {
+          hasApiToken: Boolean(next.server.apiToken),
+          sessionTtlHours: next.server.sessionTtlHours
+        },
+        memory: {
+          checkpointTtlHours: next.memory.checkpointTtlHours,
+          observationFrameTtlHours: next.memory.observationFrameTtlHours
+        }
+      });
+    } catch (error) {
+      return c.json({ error: error?.message || "Failed to update setup config." }, 400);
+    }
+  });
+  app.post("/api/setup/test-llm", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const probe = Boolean(body?.probe);
+    const llmInput = body?.llm || {};
+    const testProvider = pickString(llmInput.provider);
+    const testDefaultModel = pickString(llmInput.defaultModel);
+    const testOpenaiApiKey = pickString(llmInput.openaiApiKey);
+    const testAnthropicApiKey = pickString(llmInput.anthropicApiKey);
+    const testOpenaiBaseUrl = pickString(llmInput.openaiBaseUrl);
+    const testAnthropicBaseUrl = pickString(llmInput.anthropicBaseUrl);
+    const testOllamaBaseUrl = pickString(llmInput.ollamaBaseUrl);
+    const testFallbackOrder = Array.isArray(llmInput.fallbackOrder) ? llmInput.fallbackOrder.filter((item) => typeof item === "string") : void 0;
+    try {
+      const llm = await createLLMFromConfig({
+        provider: testProvider,
+        model: testDefaultModel,
+        llmOverrides: {
+          provider: testProvider,
+          defaultModel: testDefaultModel,
+          fallbackOrder: testFallbackOrder,
+          openaiApiKey: Object.prototype.hasOwnProperty.call(llmInput, "openaiApiKey") ? testOpenaiApiKey : void 0,
+          anthropicApiKey: Object.prototype.hasOwnProperty.call(llmInput, "anthropicApiKey") ? testAnthropicApiKey : void 0,
+          openaiBaseUrl: testOpenaiBaseUrl,
+          anthropicBaseUrl: testAnthropicBaseUrl,
+          ollamaBaseUrl: testOllamaBaseUrl
+        }
+      });
+      if (probe) {
+        const timeoutMs = Number(body?.timeoutMs) > 0 ? Number(body.timeoutMs) : 15e3;
+        const response = await Promise.race([
+          llm.generate({
+            messages: [{ role: "user", content: "Reply with exactly: OK" }],
+            max_tokens: 16,
+            temperature: 0
+          }),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("LLM probe timeout")), timeoutMs))
+        ]);
+        const text = response?.content?.filter((block) => block.type === "text")?.map((block) => block.text)?.join("\n")?.trim?.() || "";
+        return c.json({ ok: true, provider: llm.id, probeText: text.slice(0, 200) });
+      }
+      return c.json({ ok: true, provider: llm.id });
+    } catch (error) {
+      return c.json({ ok: false, error: error?.message || "Failed to initialize provider." }, 400);
+    }
+  });
+  app.get("/api/mcp/check", async (c) => {
+    const config = await configLoader.load();
+    const allServers = Object.entries(config.mcpServers || {});
+    const targetServer = c.req.query("server");
+    const timeoutMs = Number(c.req.query("timeoutMs")) || 15e3;
+    const retries = Math.max(0, Number(c.req.query("retries")) || 0);
+    const targets = targetServer ? allServers.filter(([id]) => id === targetServer) : allServers;
+    if (targets.length === 0) {
+      return c.json({
+        ok: false,
+        error: targetServer ? `MCP server "${targetServer}" not found in config.` : "No external MCP servers configured.",
+        results: []
+      }, 404);
+    }
+    const results = await checkMcpServers(
+      targets.map(([id, s]) => ({ id, command: s.command, args: s.args, env: s.env })),
+      { timeoutMs, retries }
+    );
+    return c.json({
+      ok: results.every((r) => r.ok),
+      timeoutMs,
+      retries,
+      results
+    });
+  });
+  app.get("/api/memory/facts", (c) => {
+    const limit = Number(c.req.query("limit")) || 100;
+    const tag = c.req.query("tag");
+    const facts = tag ? memoryManager.getFactsByTag(tag, limit) : memoryManager.getAllFacts(limit);
+    return c.json(facts);
+  });
+  app.get("/api/memory/approvals", (c) => {
+    const limit = Number(c.req.query("limit")) || 100;
+    const facts = memoryManager.getFactsByTag("risk_approval", limit);
+    return c.json(facts);
+  });
+  app.delete("/api/memory/approvals/:id", (c) => {
+    const id = Number(c.req.param("id"));
+    if (Number.isNaN(id)) return c.json({ error: "Invalid id" }, 400);
+    const ok = memoryManager.deleteFactById(id);
+    return c.json({ ok });
+  });
+  app.delete("/api/memory/approvals", (c) => {
+    const signature = c.req.query("signature");
+    if (!signature) return c.json({ error: "signature is required" }, 400);
+    const key = `risk_approval:${signature}`;
+    const ok = memoryManager.deleteFactByKey(key);
+    return c.json({ ok });
+  });
+  app.get("/api/replay", (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const episodes = memoryManager.listEpisodes(limit);
+    return c.json(episodes);
+  });
+  app.get("/api/strategy/proposals", (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const proposals = memoryManager.listStrategyProposals(limit).map((proposal) => {
+      let evaluationSummary = null;
+      if (proposal.evaluation_json) {
+        try {
+          const evaluation = JSON.parse(proposal.evaluation_json);
+          const replay = evaluation?.replay;
+          if (replay?.candidateSummary && replay?.baselineSummary && replay?.delta) {
+            evaluationSummary = {
+              candidateScore: replay.candidateScore,
+              baselineScore: replay.baselineScore,
+              tasksEvaluated: replay.tasksEvaluated,
+              candidateSummary: replay.candidateSummary,
+              baselineSummary: replay.baselineSummary,
+              delta: replay.delta,
+              validation: evaluation?.validation || null
+            };
+          } else if (evaluation?.validation) {
+            evaluationSummary = { validation: evaluation.validation };
+          }
+        } catch {
+          evaluationSummary = null;
+        }
+      }
+      return {
+        ...proposal,
+        evaluationSummary
+      };
+    });
+    return c.json(proposals);
+  });
+  app.get("/api/reports", (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const reports = memoryManager.listTaskReports(limit);
+    return c.json(reports);
+  });
+  app.get("/api/tasks", (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const offset = Number(c.req.query("offset")) || 0;
+    const statusFilter = c.req.query("status") || "";
+    const search = c.req.query("search") || "";
+    const liveItems = [];
+    for (const run of runs.values()) {
+      liveItems.push({
+        id: run.runId,
+        input: run.input,
+        status: run.status,
+        createdAt: run.startedAt,
+        duration: run.completedAt ? run.completedAt - run.startedAt : void 0,
+        summary: run.result?.substring(0, 120),
+        persisted: false
+      });
+    }
+    const dbReports = memoryManager.listTaskReports(limit + 50);
+    const dbItems = dbReports.map((r) => {
+      let report = null;
+      try {
+        report = JSON.parse(r.report_json);
+      } catch {
+      }
+      return {
+        id: `report-${r.id}`,
+        input: report?.intentSummary || r.task_id || "Unknown task",
+        status: report?.success ? "completed" : "failed",
+        createdAt: r.created_at,
+        duration: report?.duration,
+        summary: report?.summary || report?.intentSummary,
+        persisted: true
+      };
+    });
+    const liveTaskIds = new Set(liveItems.map((i) => i.id));
+    const merged = [
+      ...liveItems,
+      ...dbItems.filter((d) => !liveTaskIds.has(d.id))
+    ];
+    let filtered = merged;
+    if (statusFilter) {
+      filtered = filtered.filter((i) => i.status === statusFilter);
+    }
+    if (search) {
+      const q = search.toLowerCase();
+      filtered = filtered.filter(
+        (i) => i.input?.toLowerCase().includes(q) || i.summary?.toLowerCase().includes(q)
+      );
+    }
+    filtered.sort((a, b) => {
+      if (a.status === "running" && b.status !== "running") return -1;
+      if (b.status === "running" && a.status !== "running") return 1;
+      return (b.createdAt || 0) - (a.createdAt || 0);
+    });
+    const paginated = filtered.slice(offset, offset + limit);
+    return c.json({
+      items: paginated,
+      total: filtered.length,
+      activeRunId
+    });
+  });
+  app.get("/api/tasks/:id/detail", (c) => {
+    const id = c.req.param("id");
+    const liveRun = runs.get(id);
+    if (liveRun) {
+      const evidence = liveRun.taskId ? memoryManager.listObservationFramesByTask(liveRun.taskId, 100) : [];
+      return c.json({
+        id: liveRun.runId,
+        input: liveRun.input,
+        status: liveRun.status,
+        createdAt: liveRun.startedAt,
+        completedAt: liveRun.completedAt,
+        duration: liveRun.completedAt ? liveRun.completedAt - liveRun.startedAt : void 0,
+        result: liveRun.result,
+        error: liveRun.error,
+        pendingPrompt: liveRun.pendingPrompt,
+        report: null,
+        traces: null,
+        episode: null,
+        evidence
+      });
+    }
+    if (id.startsWith("report-")) {
+      const reportId = Number(id.slice("report-".length));
+      if (Number.isNaN(reportId)) return c.json({ error: "Invalid id" }, 400);
+      const dbReports = memoryManager.listTaskReports(500);
+      const dbReport = dbReports.find((r) => r.id === reportId);
+      if (!dbReport) return c.json({ error: "Task not found" }, 404);
+      let report = null;
+      try {
+        report = JSON.parse(dbReport.report_json);
+      } catch {
+      }
+      let episode = null;
+      let traces = [];
+      if (dbReport.task_id) {
+        const episodes = memoryManager.listEpisodes(200);
+        episode = episodes.find((e) => e.input?.includes(dbReport.task_id)) || null;
+        if (episode?.id) {
+          const rawTraces = memoryManager.getTraces(episode.id);
+          traces = rawTraces.map((t) => {
+            let args = null;
+            let output2 = null;
+            try {
+              args = JSON.parse(t.tool_args);
+            } catch {
+            }
+            try {
+              output2 = JSON.parse(t.tool_output);
+            } catch {
+            }
+            return { ...t, args, output: output2 };
+          });
+        }
+      }
+      const evidence = dbReport.task_id ? memoryManager.listObservationFramesByTask(dbReport.task_id, 200) : [];
+      return c.json({
+        id,
+        input: report?.intentSummary || dbReport.task_id || "Unknown task",
+        status: report?.success ? "completed" : "failed",
+        createdAt: dbReport.created_at,
+        completedAt: dbReport.created_at,
+        duration: report?.duration,
+        report,
+        traces: traces.length > 0 ? traces : null,
+        episode,
+        evidence
+      });
+    }
+    return c.json({ error: "Task not found" }, 404);
+  });
+  app.post("/api/tasks/run", async (c) => {
+    if (activeRunId) {
+      return c.json({ error: "A task is already running. Please wait." }, 409);
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const inputText = typeof body?.input === "string" ? body.input.trim() : "";
+    if (!inputText) {
+      return c.json({ error: "input is required" }, 400);
+    }
+    let llm;
+    try {
+      llm = await createLLMFromConfig();
+    } catch (error) {
+      return c.json({ error: error.message || "Failed to initialize provider." }, 500);
+    }
+    const runId = `run-${Date.now()}`;
+    const runState = {
+      runId,
+      input: inputText,
+      status: "running",
+      startedAt: Date.now()
+    };
+    runs.set(runId, runState);
+    activeRunId = runId;
+    try {
+      const { agent, routedStrategy } = await createRoutedAgent(llm);
+      runState.agent = agent;
+      runState.strategyPath = routedStrategy.path;
+      runState.strategyRole = routedStrategy.role;
+      runState.strategyId = routedStrategy.strategyId;
+      runState.strategyVersion = routedStrategy.strategyVersion;
+      agent.on("task:start", (task) => {
+        runState.taskId = task.id;
+        broadcastWs({
+          type: "task:start",
+          data: {
+            runId,
+            taskId: task.id,
+            description: task.description,
+            strategy: {
+              role: routedStrategy.role,
+              path: routedStrategy.path,
+              id: routedStrategy.strategyId,
+              version: routedStrategy.strategyVersion,
+              reason: routedStrategy.reason
+            }
+          },
+          timestamp: Date.now()
+        });
+      });
+      agent.on("stream:text", (text) => {
+        broadcastWs({ type: "stream:text", data: { runId, text }, timestamp: Date.now() });
+      });
+      agent.on("stream:thinking", (thinking) => {
+        broadcastWs({ type: "stream:thinking", data: { runId, thinking }, timestamp: Date.now() });
+      });
+      agent.on("message", (msg) => {
+        broadcastWs({ type: "message", data: { runId, ...msg }, timestamp: Date.now() });
+      });
+      agent.on("tool:start", (data) => {
+        broadcastWs({ type: "tool:start", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("tool:complete", (data) => {
+        broadcastWs({ type: "tool:complete", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("tool:error", (data) => {
+        broadcastWs({ type: "tool:error", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("retry", (data) => {
+        broadcastWs({ type: "retry", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("interaction_request", (req) => {
+        runState.pendingPrompt = { id: req.id, prompt: req.prompt };
+        broadcastWs({ type: "interaction_request", data: { runId, id: req.id, prompt: req.prompt }, timestamp: Date.now() });
+      });
+      agent.on("checkpoint:saved", (data) => {
+        broadcastWs({ type: "checkpoint:saved", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("checkpoint:error", (data) => {
+        broadcastWs({
+          type: "checkpoint:error",
+          data: { runId, ...data || {}, error: formatErrorMessage(data?.error) },
+          timestamp: Date.now()
+        });
+      });
+      agent.on("phase:start", (phase) => {
+        broadcastWs({ type: "phase:start", data: { runId, phase }, timestamp: Date.now() });
+      });
+      agent.on("phase:end", (phase) => {
+        broadcastWs({ type: "phase:end", data: { runId, phase }, timestamp: Date.now() });
+      });
+      agent.on("intent", (intent) => {
+        broadcastWs({ type: "intent", data: { runId, intent }, timestamp: Date.now() });
+      });
+      agent.on("plan", (steps) => {
+        broadcastWs({ type: "plan", data: { runId, steps }, timestamp: Date.now() });
+      });
+      agent.on("plan:error", (error) => {
+        broadcastWs({ type: "plan:error", data: { runId, error: formatErrorMessage(error) }, timestamp: Date.now() });
+      });
+      agent.on("max_iterations", (data) => {
+        broadcastWs({ type: "max_iterations", data: { runId, ...data || {} }, timestamp: Date.now() });
+      });
+      agent.on("skill:error", (error) => {
+        broadcastWs({ type: "skill:error", data: { runId, error: formatErrorMessage(error) }, timestamp: Date.now() });
+      });
+      agent.on("thinking", (thinking) => {
+        broadcastWs({ type: "thinking", data: { runId, thinking }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:session.start", (data) => {
+        broadcastWs({ type: "computer-use:session.start", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:action.dispatch", (data) => {
+        broadcastWs({ type: "computer-use:action.dispatch", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:observation.collect", (data) => {
+        broadcastWs({ type: "computer-use:observation.collect", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:checkpoint.save", (data) => {
+        broadcastWs({ type: "computer-use:checkpoint.save", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:verification", (data) => {
+        broadcastWs({ type: "computer-use:verification", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:session.end", (data) => {
+        broadcastWs({ type: "computer-use:session.end", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.run(inputText, runId).then(async (task) => {
+        runState.taskId = task.id;
+        runState.status = task.status === "completed" ? "completed" : "failed";
+        runState.result = task.result;
+        runState.completedAt = Date.now();
+        runState.pendingPrompt = void 0;
+        try {
+          const latestConfig = await configLoader.load();
+          const promotion = await shadowRouter.evaluateAutoPromotion(latestConfig);
+          if (promotion) {
+            const nextCandidates = (latestConfig.strategy.shadowCandidatePaths || []).filter((p) => p !== promotion.candidatePath);
+            await configLoader.update({
+              strategy: {
+                activePath: promotion.candidatePath,
+                shadowCandidatePaths: nextCandidates
+              }
+            });
+            memoryManager.rememberFact(
+              JSON.stringify({
+                promotedAt: Date.now(),
+                candidatePath: promotion.candidatePath,
+                candidateId: promotion.candidateId,
+                candidateVersion: promotion.candidateVersion,
+                baselineId: promotion.baselineId,
+                baselineVersion: promotion.baselineVersion,
+                successImprovement: promotion.successImprovement,
+                pValue: promotion.pValue
+              }),
+              `strategy.autopromote.${Date.now()}`,
+              ["strategy", "shadow", "autopromote"]
+            );
+            broadcastWs({
+              type: "strategy:autopromote",
+              data: {
+                runId,
+                candidatePath: promotion.candidatePath,
+                candidateId: promotion.candidateId,
+                candidateVersion: promotion.candidateVersion,
+                successImprovement: promotion.successImprovement,
+                pValue: promotion.pValue
+              },
+              timestamp: Date.now()
+            });
+          }
+        } catch {
+        }
+        broadcastWs({ type: "task:complete", data: { runId, taskId: task.id, status: task.status, result: task.result }, timestamp: Date.now() });
+      }).catch((error) => {
+        runState.status = "failed";
+        runState.error = error?.message || "Task failed.";
+        runState.completedAt = Date.now();
+        runState.pendingPrompt = void 0;
+        broadcastWs({ type: "task:error", data: { runId, error: runState.error }, timestamp: Date.now() });
+      }).finally(() => {
+        activeRunId = null;
+        runState.agent = void 0;
+      });
+      return c.json({ runId });
+    } catch (error) {
+      activeRunId = null;
+      runs.delete(runId);
+      return c.json({ error: error.message || "Task failed." }, 500);
+    }
+  });
+  app.get("/api/tasks/:id/status", (c) => {
+    const runId = c.req.param("id");
+    const run = runs.get(runId);
+    if (!run) {
+      return c.json({ error: "Task not found" }, 404);
+    }
+    return c.json({
+      runId: run.runId,
+      input: run.input,
+      status: run.status,
+      taskId: run.taskId,
+      strategyPath: run.strategyPath,
+      strategyRole: run.strategyRole,
+      strategyId: run.strategyId,
+      strategyVersion: run.strategyVersion,
+      result: run.result,
+      error: run.error,
+      startedAt: run.startedAt,
+      completedAt: run.completedAt,
+      duration: run.completedAt ? run.completedAt - run.startedAt : Date.now() - run.startedAt,
+      pendingPrompt: run.pendingPrompt
+    });
+  });
+  app.post("/api/tasks/:id/respond", async (c) => {
+    const runId = c.req.param("id");
+    const run = runs.get(runId);
+    if (!run) {
+      return c.json({ error: "Task not found" }, 404);
+    }
+    if (!run.pendingPrompt) {
+      return c.json({ error: "No pending prompt" }, 409);
+    }
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const response = typeof body?.response === "string" ? body.response.trim() : "";
+    if (!response) {
+      return c.json({ error: "response is required" }, 400);
+    }
+    if (!run.agent) {
+      return c.json({ error: "Agent not available" }, 500);
+    }
+    const promptId = run.pendingPrompt.id;
+    run.pendingPrompt = void 0;
+    run.agent.resolveInteraction(promptId, response);
+    return c.json({ ok: true });
+  });
+  app.get("/api/tasks/resumable", (c) => {
+    const checkpoints = memoryManager.listCheckpoints();
+    const items = checkpoints.map((cp) => ({
+      taskId: cp.taskId,
+      runId: cp.runId,
+      input: cp.input,
+      iteration: cp.iteration,
+      taskCreatedAt: cp.taskCreatedAt,
+      updatedAt: cp.updatedAt
+    }));
+    return c.json({ items });
+  });
+  app.post("/api/tasks/:id/resume", async (c) => {
+    if (activeRunId) {
+      return c.json({ error: "A task is already running. Please wait." }, 409);
+    }
+    const taskId = c.req.param("id");
+    const checkpoint = memoryManager.loadCheckpoint(taskId);
+    if (!checkpoint) {
+      return c.json({ error: "No checkpoint found for this task." }, 404);
+    }
+    let llm;
+    try {
+      llm = await createLLMFromConfig();
+    } catch (error) {
+      return c.json({ error: error.message || "Failed to initialize provider." }, 500);
+    }
+    const runId = checkpoint.runId || `resume-${Date.now()}`;
+    const runState = {
+      runId,
+      input: checkpoint.input,
+      status: "running",
+      startedAt: Date.now(),
+      taskId: checkpoint.taskId
+    };
+    runs.set(runId, runState);
+    activeRunId = runId;
+    try {
+      const { agent, routedStrategy } = await createRoutedAgent(llm);
+      runState.agent = agent;
+      runState.strategyPath = routedStrategy.path;
+      runState.strategyRole = routedStrategy.role;
+      runState.strategyId = routedStrategy.strategyId;
+      runState.strategyVersion = routedStrategy.strategyVersion;
+      agent.on("task:resume", (data) => {
+        broadcastWs({
+          type: "task:resume",
+          data: {
+            runId,
+            ...data,
+            strategy: {
+              role: routedStrategy.role,
+              path: routedStrategy.path,
+              id: routedStrategy.strategyId,
+              version: routedStrategy.strategyVersion,
+              reason: routedStrategy.reason
+            }
+          },
+          timestamp: Date.now()
+        });
+      });
+      agent.on("stream:text", (text) => {
+        broadcastWs({ type: "stream:text", data: { runId, text }, timestamp: Date.now() });
+      });
+      agent.on("stream:thinking", (thinking) => {
+        broadcastWs({ type: "stream:thinking", data: { runId, thinking }, timestamp: Date.now() });
+      });
+      agent.on("message", (msg) => {
+        broadcastWs({ type: "message", data: { runId, ...msg }, timestamp: Date.now() });
+      });
+      agent.on("tool:start", (data) => {
+        broadcastWs({ type: "tool:start", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("tool:complete", (data) => {
+        broadcastWs({ type: "tool:complete", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("tool:error", (data) => {
+        broadcastWs({ type: "tool:error", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("retry", (data) => {
+        broadcastWs({ type: "retry", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("interaction_request", (req) => {
+        runState.pendingPrompt = { id: req.id, prompt: req.prompt };
+        broadcastWs({ type: "interaction_request", data: { runId, id: req.id, prompt: req.prompt }, timestamp: Date.now() });
+      });
+      agent.on("checkpoint:saved", (data) => {
+        broadcastWs({ type: "checkpoint:saved", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("checkpoint:error", (data) => {
+        broadcastWs({
+          type: "checkpoint:error",
+          data: { runId, ...data || {}, error: formatErrorMessage(data?.error) },
+          timestamp: Date.now()
+        });
+      });
+      agent.on("phase:start", (phase) => {
+        broadcastWs({ type: "phase:start", data: { runId, phase }, timestamp: Date.now() });
+      });
+      agent.on("phase:end", (phase) => {
+        broadcastWs({ type: "phase:end", data: { runId, phase }, timestamp: Date.now() });
+      });
+      agent.on("intent", (intent) => {
+        broadcastWs({ type: "intent", data: { runId, intent }, timestamp: Date.now() });
+      });
+      agent.on("plan", (steps) => {
+        broadcastWs({ type: "plan", data: { runId, steps }, timestamp: Date.now() });
+      });
+      agent.on("plan:error", (error) => {
+        broadcastWs({ type: "plan:error", data: { runId, error: formatErrorMessage(error) }, timestamp: Date.now() });
+      });
+      agent.on("max_iterations", (data) => {
+        broadcastWs({ type: "max_iterations", data: { runId, ...data || {} }, timestamp: Date.now() });
+      });
+      agent.on("skill:error", (error) => {
+        broadcastWs({ type: "skill:error", data: { runId, error: formatErrorMessage(error) }, timestamp: Date.now() });
+      });
+      agent.on("thinking", (thinking) => {
+        broadcastWs({ type: "thinking", data: { runId, thinking }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:session.start", (data) => {
+        broadcastWs({ type: "computer-use:session.start", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:action.dispatch", (data) => {
+        broadcastWs({ type: "computer-use:action.dispatch", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:observation.collect", (data) => {
+        broadcastWs({ type: "computer-use:observation.collect", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:checkpoint.save", (data) => {
+        broadcastWs({ type: "computer-use:checkpoint.save", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:verification", (data) => {
+        broadcastWs({ type: "computer-use:verification", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.on("computer-use:session.end", (data) => {
+        broadcastWs({ type: "computer-use:session.end", data: { runId, ...data }, timestamp: Date.now() });
+      });
+      agent.resume(taskId).then((task) => {
+        runState.taskId = task.id;
+        runState.status = task.status === "completed" ? "completed" : "failed";
+        runState.result = task.result;
+        runState.completedAt = Date.now();
+        runState.pendingPrompt = void 0;
+        broadcastWs({ type: "task:complete", data: { runId, taskId: task.id, status: task.status, result: task.result }, timestamp: Date.now() });
+      }).catch((error) => {
+        runState.status = "failed";
+        runState.error = error?.message || "Resume failed.";
+        runState.completedAt = Date.now();
+        runState.pendingPrompt = void 0;
+        broadcastWs({ type: "task:error", data: { runId, error: runState.error }, timestamp: Date.now() });
+      }).finally(() => {
+        activeRunId = null;
+        runState.agent = void 0;
+      });
+      return c.json({ runId, resumed: true, fromIteration: checkpoint.iteration });
+    } catch (error) {
+      activeRunId = null;
+      runs.delete(runId);
+      return c.json({ error: error.message || "Resume failed." }, 500);
+    }
+  });
+  app.get("/api/tasks/:id/evidence", (c) => {
+    const taskId = c.req.param("id");
+    const frames = memoryManager.listObservationFramesByTask(taskId);
+    return c.json({
+      taskId,
+      frames,
+      total: frames.length
+    });
+  });
+  app.get("/api/computer-use/sessions/:id", (c) => {
+    const sessionId = c.req.param("id");
+    const frames = memoryManager.listObservationFramesBySession(sessionId);
+    const summary = memoryManager.getComputerUseSessionSummary(sessionId);
+    const activeCheckpoint = memoryManager.listCheckpoints().find((item) => item.computerUseSessionId === sessionId);
+    return c.json({
+      sessionId,
+      checkpoint: summary ? {
+        taskId: summary.taskId,
+        lastActionId: summary.lastActionId,
+        latestFrameIds: summary.latestFrameIds,
+        verificationFailures: summary.verificationFailures,
+        updatedAt: summary.updatedAt,
+        status: summary.status,
+        startedAt: summary.startedAt,
+        endedAt: summary.endedAt || null
+      } : activeCheckpoint ? {
+        taskId: activeCheckpoint.taskId,
+        lastActionId: activeCheckpoint.computerUseLastActionId,
+        latestFrameIds: (() => {
+          try {
+            return activeCheckpoint.computerUseLatestFrameIdsJson ? JSON.parse(activeCheckpoint.computerUseLatestFrameIdsJson) : [];
+          } catch {
+            return [];
+          }
+        })(),
+        verificationFailures: activeCheckpoint.computerUseVerificationFailures || 0,
+        updatedAt: activeCheckpoint.updatedAt,
+        status: "active",
+        startedAt: null,
+        endedAt: null
+      } : null,
+      frames,
+      total: frames.length
+    });
+  });
+  const chatSessions = /* @__PURE__ */ new Map();
+  app.post("/api/chat/start", async (c) => {
+    let llm;
+    try {
+      llm = await createLLMFromConfig();
+    } catch (error) {
+      return c.json({ error: error.message }, 500);
+    }
+    try {
+      const sessionId = `chat-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const { agent } = await createRoutedAgent(llm);
+      chatSessions.set(sessionId, { agent, createdAt: Date.now() });
+      return c.json({ sessionId });
+    } catch (error) {
+      return c.json({ error: error?.message || "Failed to start chat session" }, 500);
+    }
+  });
+  app.post("/api/chat/:id/message", async (c) => {
+    const sessionId = c.req.param("id");
+    const session = chatSessions.get(sessionId);
+    if (!session) return c.json({ error: "Session not found" }, 404);
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      body = {};
+    }
+    const message = typeof body?.message === "string" ? body.message.trim() : "";
+    if (!message) return c.json({ error: "message is required" }, 400);
+    try {
+      await updateSoulFromMessage(message);
+      const handleStreamText = (text) => {
+        broadcastWs({ type: "chat:stream:text", data: { sessionId, text }, timestamp: Date.now() });
+      };
+      const handleStreamThinking = (thinking) => {
+        broadcastWs({ type: "chat:stream:thinking", data: { sessionId, thinking }, timestamp: Date.now() });
+      };
+      const handleMessage = (msg) => {
+        broadcastWs({ type: "chat:message", data: { sessionId, ...msg }, timestamp: Date.now() });
+      };
+      const handleThinking = (thinking) => {
+        broadcastWs({ type: "chat:thinking", data: { sessionId, thinking }, timestamp: Date.now() });
+      };
+      session.agent.on("stream:text", handleStreamText);
+      session.agent.on("stream:thinking", handleStreamThinking);
+      session.agent.on("message", handleMessage);
+      session.agent.on("thinking", handleThinking);
+      try {
+        const response = await session.agent.chat(message);
+        return c.json({ response });
+      } finally {
+        session.agent.off("stream:text", handleStreamText);
+        session.agent.off("stream:thinking", handleStreamThinking);
+        session.agent.off("message", handleMessage);
+        session.agent.off("thinking", handleThinking);
+      }
+    } catch (error) {
+      return c.json({ error: error.message || "Chat failed." }, 500);
+    }
+  });
+  app.delete("/api/chat/:id", (c) => {
+    const sessionId = c.req.param("id");
+    const deleted = chatSessions.delete(sessionId);
+    return c.json({ ok: deleted });
+  });
+  app.get("/api/strategy/active", async (c) => {
+    const config = await configLoader.load();
+    const fallbackPath = join2(homedir2(), ".lydia", "strategies", "default.yml");
+    const activePath = config.strategy?.activePath || fallbackPath;
+    try {
+      if (!existsSync2(activePath)) {
+        return c.json({ error: "Active strategy not found", path: activePath }, 404);
+      }
+      const content = await readFile2(activePath, "utf-8");
+      return c.json({ path: activePath, content });
+    } catch {
+      return c.json({ error: "Failed to read active strategy" }, 500);
+    }
+  });
+  app.post("/api/strategy/proposals/:id/approve", async (c) => {
+    const id = Number(c.req.param("id"));
+    try {
+      const result = await approvalService.approveProposal(id);
+      return c.json({ ok: true, activePath: result.activePath });
+    } catch (error) {
+      const message = error?.message || "Approval failed";
+      if (message === "Proposal not found") return c.json({ error: message }, 404);
+      return c.json({ error: message }, 400);
+    }
+  });
+  app.get("/api/strategy/shadow/status", async (c) => {
+    const config = await configLoader.load();
+    const registry = new StrategyRegistry2();
+    const windowDays = config.strategy.shadowWindowDays ?? 14;
+    const sinceMs = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+    const baseline = config.strategy.activePath ? await registry.loadFromFile(config.strategy.activePath) : await registry.loadDefault();
+    const baselineSummary = memoryManager.summarizeEpisodesByStrategy(
+      baseline.metadata.id,
+      baseline.metadata.version,
+      { sinceMs, limit: 1e3 }
+    );
+    const candidates = [];
+    for (const candidatePath of config.strategy.shadowCandidatePaths || []) {
+      try {
+        const strategy = await registry.loadFromFile(candidatePath);
+        const summary = memoryManager.summarizeEpisodesByStrategy(
+          strategy.metadata.id,
+          strategy.metadata.version,
+          { sinceMs, limit: 1e3 }
+        );
+        candidates.push({
+          path: candidatePath,
+          id: strategy.metadata.id,
+          version: strategy.metadata.version,
+          summary
+        });
+      } catch (error) {
+        candidates.push({
+          path: candidatePath,
+          error: error?.message || String(error)
+        });
+      }
+    }
+    return c.json({
+      enabled: config.strategy.shadowModeEnabled,
+      mode: config.strategy.shadowRolloutMode,
+      trafficRatio: config.strategy.shadowTrafficRatio,
+      autoPromoteEnabled: config.strategy.autoPromoteEnabled,
+      autoPromoteEvalInterval: config.strategy.autoPromoteEvalInterval,
+      windowDays,
+      baseline: {
+        path: config.strategy.activePath || null,
+        id: baseline.metadata.id,
+        version: baseline.metadata.version,
+        summary: baselineSummary
+      },
+      candidates
+    });
+  });
+  app.post("/api/strategy/proposals/:id/reject", async (c) => {
+    const id = Number(c.req.param("id"));
+    let reason = "";
+    try {
+      const body = await c.req.json();
+      reason = body?.reason || "";
+    } catch {
+    }
+    try {
+      await approvalService.rejectProposal(id, reason);
+      return c.json({ ok: true });
+    } catch (error) {
+      const message = error?.message || "Rejection failed";
+      if (message === "Proposal not found") return c.json({ error: message }, 404);
+      return c.json({ error: message }, 400);
+    }
+  });
+  app.get("/api/replay/:id", (c) => {
+    const id = Number(c.req.param("id"));
+    const episode = memoryManager.getEpisode(id);
+    if (!episode) return c.json({ error: "Episode not found" }, 404);
+    const traces = memoryManager.getTraces(id);
+    const summary = {
+      total: traces.length,
+      success: traces.filter((t) => t.status === "success").length,
+      failed: traces.filter((t) => t.status === "failed").length
+    };
+    const traceDetails = traces.map((t) => {
+      let args = null;
+      let output2 = null;
+      try {
+        args = JSON.parse(t.tool_args);
+      } catch {
+      }
+      try {
+        output2 = JSON.parse(t.tool_output);
+      } catch {
+      }
+      return {
+        ...t,
+        args,
+        output: output2
+      };
+    });
+    return c.json({ episode, traces: traceDetails, summary });
+  });
+  app.get("/api/strategy/content", async (c) => {
+    const filePath = c.req.query("path");
+    if (!filePath) return c.json({ error: "path is required" }, 400);
+    const strategiesDir = join2(homedir2(), ".lydia", "strategies");
+    const resolvedPath = join2(dirname2(filePath), "..", filePath);
+    if (!filePath.includes(".lydia") || !filePath.includes("strategies")) {
+      return c.json({ error: "Access denied: Path must be within .lydia/strategies" }, 403);
+    }
+    try {
+      if (!existsSync2(filePath)) return c.json({ error: "File not found" }, 404);
+      const content = await readFile2(filePath, "utf-8");
+      return c.json({ content });
+    } catch (e) {
+      return c.json({ error: "Failed to read file" }, 500);
+    }
+  });
+  const publicDirCandidates = [
+    join2(process.cwd(), "packages", "cli", "public"),
+    join2(process.cwd(), "public"),
+    join2(__dirname, "../public"),
+    join2(__dirname, "../../public")
+  ];
+  const publicDir = publicDirCandidates.find((candidate) => existsSync2(candidate)) || publicDirCandidates[0];
+  app.get("/*", async (c) => {
+    const path3 = c.req.path === "/" ? "/index.html" : c.req.path;
+    const filePath = join2(publicDir, path3);
+    if (path3.startsWith("/api")) return c.json({ error: "Not found" }, 404);
+    try {
+      if (existsSync2(filePath)) {
+        const content = await readFile2(filePath);
+        if (path3.endsWith(".html")) c.header("Content-Type", "text/html");
+        if (path3.endsWith(".js")) c.header("Content-Type", "application/javascript");
+        if (path3.endsWith(".css")) c.header("Content-Type", "text/css");
+        return c.body(content);
+      } else {
+        const indexHtml = join2(publicDir, "index.html");
+        if (existsSync2(indexHtml)) {
+          const content = await readFile2(indexHtml);
+          c.header("Content-Type", "text/html");
+          return c.body(content);
+        }
+        return c.text('Dashboard not found. Please run "pnpm build:dashboard" first.', 404);
+      }
+    } catch (e) {
+      return c.text("Internal Server Error", 500);
+    }
+  });
+  return {
+    app,
+    start: () => {
+      if (!options?.silent) {
+        console.log(`Starting server on port ${port}...`);
+      }
+      const server = serve({
+        fetch: app.fetch,
+        port
+      });
+      injectWebSocket(server);
+      return server;
+    }
+  };
+}
+
+// src/service/manager.ts
+import * as fs2 from "fs";
+import { spawn } from "child_process";
+function isPidRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isServerHealthy(port = DEFAULT_PORT, host = DEFAULT_HOST) {
+  try {
+    const res = await fetch(`${getBaseUrl(port, host)}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function waitForServer(port = DEFAULT_PORT, host = DEFAULT_HOST) {
+  const deadline = Date.now() + STATUS_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await isServerHealthy(port, host)) return;
+    await sleep(STATUS_POLL_INTERVAL_MS);
+  }
+  throw new Error(`Server failed to become healthy on ${host}:${port} within ${STATUS_POLL_TIMEOUT_MS}ms`);
+}
+async function getServiceStatus() {
+  const state = await readServiceState();
+  const host = state?.host || DEFAULT_HOST;
+  const port = state?.port || DEFAULT_PORT;
+  const baseUrl = getBaseUrl(port, host);
+  if (!state) {
+    const healthy2 = await isServerHealthy(port, host);
+    return {
+      running: healthy2,
+      healthy: healthy2,
+      pid: null,
+      port,
+      host,
+      baseUrl,
+      reason: healthy2 ? "Healthy service detected without local state file." : "Service is not running."
+    };
+  }
+  const pidRunning = isPidRunning(state.pid);
+  const healthy = await isServerHealthy(state.port, state.host);
+  if (!pidRunning && !healthy) {
+    await removeServiceState();
+    return {
+      running: false,
+      healthy: false,
+      pid: state.pid,
+      port: state.port,
+      host: state.host,
+      baseUrl: state.baseUrl,
+      startedAt: state.startedAt,
+      version: state.version,
+      reason: "Found stale Lydia state; cleaned it up."
+    };
+  }
+  return {
+    running: pidRunning || healthy,
+    healthy,
+    pid: state.pid,
+    port: state.port,
+    host: state.host,
+    baseUrl: state.baseUrl,
+    startedAt: state.startedAt,
+    version: state.version,
+    reason: healthy ? "Service is healthy." : "Process exists but health endpoint is not responding yet."
+  };
+}
+async function ensureServiceStarted(port = DEFAULT_PORT, host = DEFAULT_HOST) {
+  const status = await getServiceStatus();
+  if (status.running && status.healthy) {
+    return status;
+  }
+  return startService({ port, host });
+}
+async function startService(options = {}) {
+  const port = options.port || DEFAULT_PORT;
+  const host = options.host || DEFAULT_HOST;
+  const version = options.version || "unknown";
+  const status = await getServiceStatus();
+  if (status.running && status.healthy) {
+    return status;
+  }
+  await initLocalWorkspace();
+  const paths = getLydiaPaths();
+  const launch = resolveLaunchCommand(port, host);
+  const outFd = fs2.openSync(paths.serverLogPath, "a");
+  const errFd = fs2.openSync(paths.serverErrorLogPath, "a");
+  const child = spawn(launch.command, launch.args, {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: ["ignore", outFd, errFd],
+    windowsHide: true
+  });
+  fs2.closeSync(outFd);
+  fs2.closeSync(errFd);
+  child.unref();
+  try {
+    await waitForServer(port, host);
+    const nextState = {
+      pid: child.pid ?? 0,
+      port,
+      host,
+      baseUrl: getBaseUrl(port, host),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version
+    };
+    await writeServiceState(nextState);
+    return {
+      running: true,
+      healthy: true,
+      pid: nextState.pid,
+      port,
+      host,
+      baseUrl: nextState.baseUrl,
+      startedAt: nextState.startedAt,
+      version,
+      reason: "Service started successfully."
+    };
+  } catch (error) {
+    try {
+      if (child.pid) process.kill(child.pid);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function stopService() {
+  const state = await readServiceState();
+  if (!state) {
+    return {
+      running: false,
+      healthy: false,
+      pid: null,
+      port: DEFAULT_PORT,
+      host: DEFAULT_HOST,
+      baseUrl: getBaseUrl(),
+      reason: "Service is not running."
+    };
+  }
+  if (isPidRunning(state.pid)) {
+    try {
+      process.kill(state.pid);
+    } catch {
+    }
+  }
+  const deadline = Date.now() + STATUS_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!isPidRunning(state.pid)) break;
+    await sleep(STATUS_POLL_INTERVAL_MS);
+  }
+  await removeServiceState();
+  return {
+    running: false,
+    healthy: false,
+    pid: state.pid,
+    port: state.port,
+    host: state.host,
+    baseUrl: state.baseUrl,
+    startedAt: state.startedAt,
+    version: state.version,
+    reason: "Service stopped."
+  };
+}
+function resolveLaunchCommand(port, host) {
+  const entry = process.argv[1];
+  if (!entry) {
+    throw new Error("Unable to resolve Lydia CLI entry point.");
+  }
+  if (entry.endsWith(".ts")) {
+    const pnpmCommand = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+    return {
+      command: pnpmCommand,
+      args: ["tsx", entry, "serve", "--port", String(port), "--host", host]
+    };
+  }
+  return {
+    command: process.execPath,
+    args: [entry, "serve", "--port", String(port), "--host", host]
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/client.ts
+function getServerUrl(port) {
+  return `http://${DEFAULT_HOST}:${port || DEFAULT_PORT}`;
+}
+function getWsUrl(port) {
+  return `ws://${DEFAULT_HOST}:${port || DEFAULT_PORT}/ws`;
+}
+async function ensureServer(port) {
+  const p = port || DEFAULT_PORT;
+  await ensureServiceStarted(p);
+  return p;
+}
+function buildAuthHeaders(base = {}) {
+  const token = (process.env.LYDIA_API_TOKEN || "").trim();
+  if (!token) return base;
+  return {
+    ...base,
+    Authorization: `Bearer ${token}`
+  };
+}
+async function resolveWebSocketCtor() {
+  const globalWs = globalThis.WebSocket;
+  if (typeof globalWs === "function") {
+    return globalWs;
+  }
+  try {
+    const mod = await import("ws");
+    return mod.default;
+  } catch {
+    throw new Error('WebSocket runtime not found. Install dependency "ws" or use a Node.js runtime with global WebSocket.');
+  }
+}
+function bindWsEvent(ws, event, handler) {
+  if (typeof ws.on === "function") {
+    ws.on(event, handler);
+    return;
+  }
+  if (typeof ws.addEventListener === "function") {
+    ws.addEventListener(event, handler);
+  }
+}
+async function apiGet(path3, port) {
+  const res = await fetch(`${getServerUrl(port)}${path3}`, {
+    headers: buildAuthHeaders()
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `GET ${path3} failed: ${res.status}`);
+  }
+  return res.json();
+}
+async function apiPost(path3, body, port) {
+  const headers = buildAuthHeaders(body ? { "Content-Type": "application/json" } : {});
+  const res = await fetch(`${getServerUrl(port)}${path3}`, {
+    method: "POST",
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error || `POST ${path3} failed: ${res.status}`);
+  }
+  return res.json();
+}
+function connectTaskStream(runId, handlers, port) {
+  return (async () => {
+    const WebSocketCtor = await resolveWebSocketCtor();
+    return await new Promise((resolve2, reject) => {
+      const ws = new WebSocketCtor(getWsUrl(port));
+      let resolved = false;
+      bindWsEvent(ws, "open", () => {
+        resolved = true;
+        resolve2({ close: () => ws.close() });
+      });
+      bindWsEvent(ws, "error", (err) => {
+        if (!resolved) {
+          reject(err);
+        }
+      });
+      bindWsEvent(ws, "message", (raw) => {
+        try {
+          const rawText = typeof raw === "string" ? raw : raw?.data ? String(raw.data) : raw?.toString?.() || "";
+          const msg = JSON.parse(rawText);
+          if (msg.data?.runId && msg.data.runId !== runId) return;
+          switch (msg.type) {
+            case "stream:text":
+              handlers.onText?.(msg.data?.text || "");
+              break;
+            case "stream:thinking":
+              handlers.onThinking?.(msg.data?.thinking || "");
+              break;
+            case "tool:start":
+              handlers.onToolStart?.(msg.data?.name || "unknown");
+              break;
+            case "tool:complete":
+              handlers.onToolComplete?.(msg.data?.name || "unknown", msg.data?.duration || 0, msg.data?.result);
+              break;
+            case "tool:error":
+              handlers.onToolError?.(msg.data?.name || "unknown", msg.data?.error || "unknown error");
+              break;
+            case "retry":
+              handlers.onRetry?.(msg.data?.attempt, msg.data?.maxRetries, msg.data?.delay, msg.data?.error);
+              break;
+            case "interaction_request":
+              if (handlers.onInteraction) {
+                handlers.onInteraction(msg.data?.id, msg.data?.prompt).then((response) => {
+                  apiPost(`/api/tasks/${runId}/respond`, { response }, port).catch(() => {
+                  });
+                });
+              }
+              break;
+            case "task:complete":
+              handlers.onComplete?.(msg.data?.taskId || "", msg.data?.result || "");
+              ws.close();
+              break;
+            case "task:error":
+              handlers.onError?.(msg.data?.error || "Task failed.");
+              ws.close();
+              break;
+            default:
+              handlers.onMessage?.(msg.type, msg.data);
+              break;
+          }
+        } catch {
+        }
+      });
+    });
+  })();
+}
+
+// src/index.ts
+import * as os2 from "os";
+import * as path2 from "path";
+import * as fs3 from "fs";
+import * as fsPromises2 from "fs/promises";
+
+// src/commands/review.ts
+import { Command } from "commander";
+import { ReviewManager, StrategyBranchManager } from "@lydia-agent/core";
+import inquirer from "inquirer";
+import chalk from "chalk";
+function reviewCommand() {
+  const command = new Command("review");
+  command.description("Review pending strategy updates").action(async () => {
+    const reviewManager = new ReviewManager();
+    const branchManager = new StrategyBranchManager();
+    await reviewManager.init();
+    await branchManager.init();
+    const pending = await reviewManager.listPending();
+    if (pending.length === 0) {
+      console.log(chalk.green("No pending reviews."));
+      return;
+    }
+    console.log(chalk.bold(`Found ${pending.length} pending reviews:
+`));
+    for (const req of pending) {
+      console.log(chalk.cyan(`ID: ${req.id}`));
+      console.log(`Source: ${req.source}`);
+      console.log(`Branch: ${req.branchName}`);
+      console.log(`Summary: ${req.diffSummary}`);
+      console.log(chalk.gray(`Validation: ${req.validationResult.status} ${req.validationResult.reason || ""}`));
+      console.log("-".repeat(40));
+    }
+    const { action } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { name: "Approve a request", value: "approve" },
+          { name: "Reject a request", value: "reject" },
+          { name: "Exit", value: "exit" }
+        ]
+      }
+    ]);
+    if (action === "exit") return;
+    const { reqId } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "reqId",
+        message: "Select request:",
+        choices: pending.map((r) => ({ name: `${r.id} - ${r.diffSummary}`, value: r.id }))
+      }
+    ]);
+    if (action === "approve") {
+      const req = pending.find((r) => r.id === reqId);
+      try {
+        console.log(chalk.yellow("Merging branch..."));
+        await branchManager.mergeBranch(req.branchName);
+        await reviewManager.updateStatus(reqId, "approved");
+        console.log(chalk.green(`Request ${reqId} approved and merged.`));
+      } catch (e) {
+        console.error(chalk.red(`Failed to merge: ${e}`));
+      }
+    } else if (action === "reject") {
+      await reviewManager.updateStatus(reqId, "rejected");
+      console.log(chalk.yellow(`Request ${reqId} rejected.`));
+    }
+  });
+  return command;
+}
+
+// src/index.ts
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+async function getVersion() {
+  try {
+    const pkg = JSON.parse(await readFile3(join3(__dirname2, "../package.json"), "utf-8"));
+    return pkg.version;
+  } catch (e) {
+    return "unknown";
+  }
+}
+function formatDurationMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainSeconds = seconds % 60;
+  return `${minutes}m ${remainSeconds}s`;
+}
+function bumpPatchVersion(version) {
+  const parts = version.split(".").map((p) => parseInt(p, 10));
+  if (parts.length !== 3 || parts.some((p) => Number.isNaN(p))) {
+    return `${version}-next`;
+  }
+  parts[2] += 1;
+  return parts.join(".");
+}
+function buildLocalApiAuthHeaders(base = {}) {
+  const token = (process.env.LYDIA_API_TOKEN || "").trim();
+  if (!token) return base;
+  return { ...base, Authorization: `Bearer ${token}` };
+}
+async function main() {
+  const program = new Command2();
+  const version = await getVersion();
+  program.name("lydia").description("Lydia - AI Agent with Strategic Evolution").version(version);
+  program.command("serve").description("Run the Lydia local service").option("--port <number>", "Server port", String(DEFAULT_PORT)).option("--host <host>", "Server host", DEFAULT_HOST).action(async (options) => {
+    const port = parseInt(options.port, 10) || DEFAULT_PORT;
+    const host = String(options.host || DEFAULT_HOST);
+    await initLocalWorkspace();
+    const server = createServer(port);
+    server.start();
+    await writeServiceState({
+      pid: process.pid,
+      port,
+      host,
+      baseUrl: getBaseUrl(port, host),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version
+    });
+  });
+  program.command("start").description("Start the Lydia local service").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (options) => {
+    const port = parseInt(options.port, 10) || DEFAULT_PORT;
+    const status = await startService({ port, version });
+    console.log(chalk2.green(`Lydia service running at ${status.baseUrl}`));
+    if (status.pid) {
+      console.log(chalk2.dim(`pid=${status.pid}`));
+    }
+  });
+  program.command("stop").description("Stop the Lydia local service").action(async () => {
+    const status = await stopService();
+    console.log(chalk2.green(status.reason || "Service stopped."));
+  });
+  program.command("restart").description("Restart the Lydia local service").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (options) => {
+    await stopService();
+    const port = parseInt(options.port, 10) || DEFAULT_PORT;
+    const status = await startService({ port, version });
+    console.log(chalk2.green(`Lydia service restarted at ${status.baseUrl}`));
+    if (status.pid) {
+      console.log(chalk2.dim(`pid=${status.pid}`));
+    }
+  });
+  program.command("status").description("Show Lydia service status").action(async () => {
+    const status = await getServiceStatus();
+    const stateText = status.healthy ? chalk2.green("healthy") : status.running ? chalk2.yellow("starting") : chalk2.red("stopped");
+    console.log(`Service: ${stateText}`);
+    console.log(`URL: ${status.baseUrl}`);
+    if (status.pid) console.log(`PID: ${status.pid}`);
+    if (status.version) console.log(`Version: ${status.version}`);
+    if (status.startedAt) console.log(`Started: ${status.startedAt}`);
+    if (status.reason) console.log(chalk2.dim(status.reason));
+  });
+  program.command("doctor").description("Run local health checks for Lydia").action(async () => {
+    const checks = [];
+    const init = await initLocalWorkspace();
+    const config = await new ConfigLoader3().load();
+    const service = await getServiceStatus();
+    checks.push({
+      name: "Workspace",
+      ok: true,
+      detail: init.paths.baseDir
+    });
+    checks.push({
+      name: "Config",
+      ok: fs3.existsSync(init.paths.configPath),
+      detail: init.paths.configPath
+    });
+    checks.push({
+      name: "Strategy",
+      ok: fs3.existsSync(init.paths.strategyPath),
+      detail: init.paths.strategyPath
+    });
+    checks.push({
+      name: "Service",
+      ok: service.healthy,
+      detail: service.healthy ? service.baseUrl : service.reason || service.baseUrl
+    });
+    checks.push({
+      name: "LLM Provider",
+      ok: Boolean(config.llm.provider),
+      detail: config.llm.provider || "auto"
+    });
+    checks.push({
+      name: "API Keys",
+      ok: Boolean(
+        config.llm.openaiApiKey || config.llm.anthropicApiKey || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY
+      ),
+      detail: "OpenAI/Anthropic key configured"
+    });
+    for (const check of checks) {
+      const icon = check.ok ? chalk2.green("*") : chalk2.red("x");
+      console.log(`${icon} ${check.name}: ${check.detail}`);
+    }
+    if (checks.some((check) => !check.ok)) {
+      process.exitCode = 1;
+    }
+  });
+  program.command("run").description("Execute a task").argument("<task>", "The task description").option("-m, --model <model>", "Override default model").option("-p, --provider <provider>", "LLM provider (anthropic|openai|ollama|mock|auto)").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (taskDescription, options) => {
+    console.log(chalk2.bold.blue("\nLydia is starting...\n"));
+    const spinner = ora("Connecting to server...").start();
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      spinner.succeed(chalk2.green("Server connected"));
+      spinner.start("Submitting task...");
+      const { runId } = await apiPost("/api/tasks/run", { input: taskDescription }, port);
+      spinner.succeed(chalk2.green(`Task submitted (${runId})`));
+      console.log(chalk2.bold(`
+Task: ${taskDescription}
+`));
+      spinner.start("Thinking...");
+      let isStreaming = false;
+      await new Promise((resolve2, reject) => {
+        connectTaskStream(runId, {
+          onText(text) {
+            if (!isStreaming) {
+              spinner.stop();
+              isStreaming = true;
+            }
+            process.stdout.write(chalk2.white(text));
+          },
+          onThinking() {
+            if (!isStreaming) {
+              spinner.stop();
+              isStreaming = true;
+            }
+            spinner.text = chalk2.dim("Thinking...");
+          },
+          onToolStart(name) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.start(`Using tool: ${name}`);
+          },
+          onToolComplete(name, duration, result) {
+            spinner.stopAndPersist({
+              symbol: chalk2.green("*"),
+              text: `${chalk2.green(name)} ${chalk2.dim(`(${duration}ms)`)}`
+            });
+            if (result) {
+              const resultLines = String(result).split("\n");
+              const preview = resultLines.slice(0, 5).join("\n");
+              console.log(chalk2.dim(preview.replace(/^/gm, "      ")));
+              if (resultLines.length > 5) {
+                console.log(chalk2.dim(`      ... (${resultLines.length - 5} more lines)`));
+              }
+            }
+            spinner.start("Thinking...");
+          },
+          onToolError(name, error) {
+            spinner.stopAndPersist({
+              symbol: chalk2.red("x"),
+              text: `${chalk2.red(name)}: ${error}`
+            });
+            spinner.start("Thinking...");
+          },
+          onRetry(attempt, maxRetries, delay, error) {
+            spinner.text = chalk2.yellow(`Retry ${attempt}/${maxRetries} after ${delay}ms: ${error}`);
+          },
+          async onInteraction(_id, prompt) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.stopAndPersist({ symbol: "!", text: "User Input Required" });
+            const rl = readline.createInterface({ input, output });
+            console.log(chalk2.yellow(`
+Agent asks: ${prompt}`));
+            const answer = await rl.question(chalk2.bold("> "));
+            rl.close();
+            spinner.start("Resuming...");
+            return answer;
+          },
+          onComplete(_taskId, _result) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.succeed(chalk2.bold.green("Task Completed."));
+            resolve2();
+          },
+          onError(error) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.fail(chalk2.red("Task Failed"));
+            console.error(chalk2.red(`
+Error details: ${error}`));
+            resolve2();
+          },
+          onMessage(type, _data) {
+            if (type === "message" && _data?.text) {
+              spinner.stop();
+              console.log(chalk2.white(_data.text));
+              spinner.start("Thinking...");
+            }
+          }
+        }, port).catch(reject);
+      });
+    } catch (error) {
+      spinner.fail(chalk2.red("Fatal Error"));
+      console.error(chalk2.red(error.message || error));
+      process.exit(1);
+    }
+  });
+  program.command("chat").description("Start an interactive chat session with Lydia").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (options) => {
+    console.log(chalk2.bold.blue("\nLydia Chat Mode\n"));
+    console.log(chalk2.dim("Commands: /exit, /reset, /tasks, /task <id>, /help"));
+    console.log(chalk2.dim("\u2500".repeat(40) + "\n"));
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      let sessionId = (await apiPost("/api/chat/start", {}, port)).sessionId;
+      const rl = readline.createInterface({ input, output });
+      while (true) {
+        const userInput = await rl.question(chalk2.bold.cyan("You> "));
+        const trimmed = userInput.trim();
+        if (!trimmed) continue;
+        if (trimmed === "/exit" || trimmed === "/quit") {
+          await apiPost(`/api/chat/${sessionId}`, void 0, port).catch(() => {
+          });
+          console.log(chalk2.dim("\nGoodbye!"));
+          rl.close();
+          break;
+        }
+        if (trimmed === "/reset") {
+          await fetch(`http://localhost:${port}/api/chat/${sessionId}`, {
+            method: "DELETE",
+            headers: buildLocalApiAuthHeaders()
+          }).catch(() => {
+          });
+          sessionId = (await apiPost("/api/chat/start", {}, port)).sessionId;
+          console.log(chalk2.dim("Session reset.\n"));
+          continue;
+        }
+        if (trimmed === "/help") {
+          console.log(chalk2.dim("  /exit      - End the chat session"));
+          console.log(chalk2.dim("  /reset     - Clear conversation history"));
+          console.log(chalk2.dim("  /tasks     - List recent task history"));
+          console.log(chalk2.dim("  /task <id> - Show task detail"));
+          console.log(chalk2.dim("  /help      - Show this help message\n"));
+          continue;
+        }
+        if (trimmed === "/tasks") {
+          try {
+            const result = await apiGet("/api/tasks?limit=10", port);
+            if (!result.items?.length) {
+              console.log(chalk2.dim("No tasks found.\n"));
+            } else {
+              console.log(chalk2.bold("\nRecent Tasks:"));
+              for (const item of result.items) {
+                const icon = item.status === "completed" ? chalk2.green("\u2713") : item.status === "running" ? chalk2.blue("\u25CB") : chalk2.red("\u2717");
+                const date = new Date(item.createdAt).toLocaleString();
+                console.log(`  ${icon} ${item.input?.substring(0, 60) || "Unknown"} ${chalk2.dim(`\xB7 ${date} \xB7 ${item.id}`)}`);
+              }
+              console.log("");
+            }
+          } catch (err) {
+            console.log(chalk2.red(`Failed to fetch tasks: ${err.message}
+`));
+          }
+          continue;
+        }
+        if (trimmed.startsWith("/task ")) {
+          const taskId = trimmed.slice("/task ".length).trim();
+          try {
+            const detail = await apiGet(`/api/tasks/${encodeURIComponent(taskId)}/detail`, port);
+            const statusText = detail.status === "completed" ? chalk2.green("SUCCESS") : detail.status === "running" ? chalk2.blue("RUNNING") : chalk2.red("FAILED");
+            console.log(chalk2.bold(`
+${detail.report?.intentSummary || detail.input || "Task"}`));
+            console.log(`  Status: ${statusText} \xB7 ${new Date(detail.createdAt).toLocaleString()}`);
+            if (detail.report?.summary) console.log(`  ${detail.report.summary}`);
+            if (detail.report?.outputs?.length) {
+              for (const out of detail.report.outputs) console.log(`  \u2192 ${out}`);
+            }
+            console.log("");
+          } catch (err) {
+            console.log(chalk2.red(`Failed to fetch task: ${err.message}
+`));
+          }
+          continue;
+        }
+        try {
+          const { response } = await apiPost(
+            `/api/chat/${sessionId}/message`,
+            { message: trimmed },
+            port
+          );
+          if (response) {
+            console.log(chalk2.white(response));
+          }
+          console.log("");
+        } catch (error) {
+          console.error(chalk2.red(`Error: ${error.message}
+`));
+        }
+      }
+    } catch (error) {
+      console.error(chalk2.red("Fatal Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  program.command("replay").description("Replay a past episode").argument("<episodeId>", "The ID of the episode to replay").option("--runs <n>", "Run replay determinism check N times (default: 1)", "1").option("--min-consistency <n>", "Minimum consistency rate for determinism check [0,1] (default: 0.99)", "0.99").action(async (episodeId, options) => {
+    try {
+      const id = parseInt(episodeId, 10);
+      if (isNaN(id)) throw new Error("Episode ID must be a number");
+      const runs = Math.max(1, Number(options.runs) || 1);
+      const minConsistency = Math.min(1, Math.max(0, Number(options.minConsistency) || 0.99));
+      const replayer = new ReplayManager();
+      const evaluation = await replayer.replay(id);
+      console.log(chalk2.bold(`
+Replay Result for Episode #${id}`));
+      console.log(`  Success: ${evaluation.success ? chalk2.green("yes") : chalk2.red("no")}`);
+      console.log(`  Score: ${evaluation.score.toFixed(3)}`);
+      console.log(`  Duration: ${formatDurationMs(evaluation.metrics.duration)}`);
+      console.log(`  Steps: ${evaluation.metrics.steps}`);
+      console.log(`  Drift: ${evaluation.metrics.driftDetected ? chalk2.yellow("detected") : chalk2.green("none")}`);
+      console.log(`  Risk events: ${evaluation.metrics.riskEvents}`);
+      console.log(`  Human interrupts: ${evaluation.metrics.humanInterrupts}`);
+      console.log(`  Observation frames: ${evaluation.metrics.observationFrames}`);
+      console.log(`  Multimodal frames: ${evaluation.metrics.multimodalFrames}`);
+      if (runs > 1) {
+        const det = await replayer.replayDeterminism(id, {
+          runs,
+          minConsistencyRate: minConsistency
+        });
+        const rateText = `${(det.consistencyRate * 100).toFixed(1)}% (${det.consistentRuns}/${det.runs})`;
+        console.log(`  Determinism: ${det.ok ? chalk2.green(rateText) : chalk2.red(rateText)}`);
+        console.log(`  Determinism threshold: ${(minConsistency * 100).toFixed(1)}%`);
+        if (!det.ok) {
+          process.exitCode = 1;
+        }
+      }
+      console.log("");
+    } catch (error) {
+      console.error(chalk2.red("Replay Error:"), error.message);
+    }
+  });
+  program.command("dashboard").description("Launch the Web Dashboard").option("-p, --port <number>", "Port to run on", String(DEFAULT_PORT)).option("--no-open", "Do not open browser automatically").action(async (options) => {
+    const port = parseInt(options.port, 10) || DEFAULT_PORT;
+    const status = await startService({ port, version });
+    const url = status.baseUrl;
+    console.log(chalk2.green(`
+ Dashboard running at: ${chalk2.bold(url)}
+`));
+    if (options.open) {
+      await open(url);
+    }
+  });
+  program.addCommand(reviewCommand());
+  const mcpCmd = program.command("mcp").description("Inspect external MCP server connectivity");
+  mcpCmd.command("check").description("Check configured external MCP servers and list discovered tools").option("-s, --server <id>", "Check only one configured server id (e.g. browser)").option("--timeout-ms <ms>", "Connection timeout per server (default: 15000)", "15000").option("--retries <n>", "Retry attempts per server (default: 0)", "0").option("--json", "Output JSON only").action(async (options) => {
+    const config = await new ConfigLoader3().load();
+    const allServers = Object.entries(config.mcpServers || {});
+    if (allServers.length === 0) {
+      console.log(chalk2.yellow("No external MCP servers configured in ~/.lydia/config.json"));
+      return;
+    }
+    const targets = options.server ? allServers.filter(([id]) => id === options.server) : allServers;
+    if (targets.length === 0) {
+      const message = `MCP server "${options.server}" not found in config.`;
+      if (options.json) {
+        console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+      } else {
+        console.error(chalk2.red(message));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const checkTargets = targets.map(([id, serverConfig]) => ({
+      id,
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env
+    }));
+    const timeoutMs = Number(options.timeoutMs) || 15e3;
+    const retries = Math.max(0, Number(options.retries) || 0);
+    const results = await checkMcpServers(checkTargets, { timeoutMs, retries });
+    if (options.json) {
+      const failed2 = results.filter((r) => !r.ok).length;
+      console.log(JSON.stringify({
+        ok: failed2 === 0,
+        timeoutMs,
+        retries,
+        results
+      }, null, 2));
+      if (failed2 > 0) process.exitCode = 1;
+      return;
+    }
+    console.log(chalk2.bold(`
+Checking ${targets.length} MCP server(s)...
+`));
+    let failed = 0;
+    for (const result of results) {
+      if (!result.ok) {
+        failed += 1;
+        console.log(chalk2.red(`x ${result.id} (${result.durationMs}ms, attempts=${result.attempts})`));
+        console.log(chalk2.dim(`  ${result.error}`));
+        continue;
+      }
+      console.log(chalk2.green(`* ${result.id} (${result.durationMs}ms, attempts=${result.attempts})`));
+      if (result.tools.length === 0) {
+        console.log(chalk2.dim("  tools: (none discovered)"));
+      } else {
+        console.log(chalk2.dim(`  tools (${result.tools.length}): ${result.tools.join(", ")}`));
+      }
+    }
+    if (failed > 0) {
+      process.exitCode = 1;
+      console.log(chalk2.red(`
+${failed} server(s) failed health check.`));
+    } else {
+      console.log(chalk2.green("\nAll checked MCP servers are reachable."));
+    }
+  });
+  mcpCmd.command("tools").description("List discovered tools from configured external MCP servers").option("-s, --server <id>", "Inspect one configured server id").option("--timeout-ms <ms>", "Connection timeout per server (default: 15000)", "15000").option("--retries <n>", "Retry attempts per server (default: 0)", "0").option("--json", "Output JSON only").action(async (options) => {
+    const config = await new ConfigLoader3().load();
+    const allServers = Object.entries(config.mcpServers || {});
+    const targets = options.server ? allServers.filter(([id]) => id === options.server) : allServers;
+    if (targets.length === 0) {
+      const message = options.server ? `MCP server "${options.server}" not found in config.` : "No external MCP servers configured in ~/.lydia/config.json";
+      if (options.json) {
+        console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+      } else {
+        console.error(chalk2.red(message));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const timeoutMs = Number(options.timeoutMs) || 15e3;
+    const retries = Math.max(0, Number(options.retries) || 0);
+    const results = await checkMcpServers(
+      targets.map(([id, s]) => ({ id, command: s.command, args: s.args, env: s.env })),
+      { timeoutMs, retries }
+    );
+    if (options.json) {
+      console.log(JSON.stringify({
+        ok: results.every((r) => r.ok),
+        toolsByServer: results.map((r) => ({ id: r.id, ok: r.ok, tools: r.tools, error: r.error }))
+      }, null, 2));
+      if (!results.every((r) => r.ok)) process.exitCode = 1;
+      return;
+    }
+    for (const result of results) {
+      if (!result.ok) {
+        console.log(chalk2.red(`x ${result.id}: ${result.error}`));
+        continue;
+      }
+      console.log(chalk2.green(`${result.id}`));
+      if (result.tools.length === 0) {
+        console.log(chalk2.dim("  (no tools)"));
+        continue;
+      }
+      for (const tool of result.tools) {
+        console.log(`  - ${tool}`);
+      }
+    }
+    if (!results.every((r) => r.ok)) process.exitCode = 1;
+  });
+  program.command("init").description("Initialize Lydia config, strategy, and folders").action(async () => {
+    try {
+      const result = await initLocalWorkspace();
+      for (const filePath of result.created) {
+        console.log(chalk2.green(`Created: ${filePath}`));
+      }
+      for (const filePath of result.existing) {
+        console.log(chalk2.gray(`Exists: ${filePath}`));
+      }
+      console.log(chalk2.green("Lydia initialization complete."));
+    } catch (error) {
+      console.error(chalk2.red("Initialization failed:"), error.message);
+    }
+  });
+  const strategyCmd = program.command("strategy").description("Manage strategies");
+  strategyCmd.command("list").description("List available strategies").action(async () => {
+    const registry = new StrategyRegistry3();
+    const dir = path2.join(os2.homedir(), ".lydia", "strategies");
+    try {
+      const strategies = await registry.listFromDirectory(dir);
+      if (strategies.length === 0) {
+        console.log(chalk2.yellow("No strategies found."));
+        return;
+      }
+      strategies.forEach((s) => {
+        console.log(`${chalk2.green(s.metadata.id)} v${s.metadata.version} - ${s.metadata.name}`);
+      });
+    } catch (error) {
+      console.error(chalk2.red("Failed to list strategies:"), error.message);
+    }
+  });
+  strategyCmd.command("use").description("Set active strategy by file path").argument("<file>", "Path to strategy file").action(async (file) => {
+    const loader = new ConfigLoader3();
+    try {
+      const absPath = path2.resolve(file);
+      const registry = new StrategyRegistry3();
+      await registry.loadFromFile(absPath);
+      await loader.update({ strategy: { activePath: absPath } });
+      console.log(chalk2.green(`Active strategy set to: ${absPath}`));
+    } catch (error) {
+      console.error(chalk2.red("Failed to set active strategy:"), error.message);
+    }
+  });
+  strategyCmd.command("propose").description("Propose a strategy update for review").argument("<file>", "Path to strategy file").action(async (file) => {
+    const absPath = path2.resolve(file);
+    const dbPath = path2.join(os2.homedir(), ".lydia", "memory.db");
+    const memory = new MemoryManager2(dbPath);
+    const registry = new StrategyRegistry3();
+    const updateGate = new StrategyUpdateGate();
+    const replayManager = new ReplayManager(memory);
+    try {
+      const config = await new ConfigLoader3().load();
+      const strategy = await registry.loadFromFile(absPath);
+      const baselinePath = config.strategy?.activePath;
+      const baseline = baselinePath ? await registry.loadFromFile(baselinePath) : await registry.loadDefault();
+      const replayCount = config.strategy?.replayEpisodes ?? 10;
+      const replayEpisodeIds = memory.listEpisodes(replayCount).map((ep) => ep.id).filter((id2) => typeof id2 === "number");
+      const replayComparison = replayEpisodeIds.length > 0 ? await replayManager.replayCompare(replayEpisodeIds, baseline, strategy) : null;
+      const validation = await updateGate.process(
+        strategy,
+        {
+          name: strategy.metadata.id,
+          version: strategy.metadata.version,
+          path: absPath,
+          parent: strategy.metadata.inheritFrom,
+          createdAt: Date.now()
+        },
+        replayComparison?.details || [],
+        baseline
+      );
+      const proposalStatus = validation.status === "REJECT" ? "invalid" : "pending_human";
+      const evaluation = {
+        validation,
+        replay: replayComparison,
+        sampledEpisodeIds: replayEpisodeIds,
+        baseline: {
+          id: baseline.metadata.id,
+          version: baseline.metadata.version
+        },
+        candidate: {
+          id: strategy.metadata.id,
+          version: strategy.metadata.version
+        }
+      };
+      const id = memory.recordStrategyProposal({
+        strategy_path: absPath,
+        status: proposalStatus,
+        reason: validation.reason,
+        evaluation_json: JSON.stringify(evaluation),
+        created_at: Date.now(),
+        decided_at: proposalStatus === "invalid" ? Date.now() : void 0
+      });
+      if (proposalStatus === "invalid") {
+        console.error(chalk2.red(`Proposal rejected by gate: ${id}`));
+        console.error(chalk2.red(validation.reason || "Rejected by automated validation"));
+        return;
+      }
+      console.log(chalk2.green(`Proposal created: ${id}`));
+      if (replayComparison) {
+        console.log(
+          chalk2.gray(
+            `Replay compared ${replayComparison.tasksEvaluated} episodes (candidate ${(replayComparison.candidateScore * 100).toFixed(1)}%, baseline ${(replayComparison.baselineScore * 100).toFixed(1)}%).`
+          )
+        );
+      } else {
+        console.log(chalk2.yellow("No replay episodes found. Proposal requires manual review."));
+      }
+    } catch (error) {
+      const id = memory.recordStrategyProposal({
+        strategy_path: absPath,
+        status: "invalid",
+        reason: error.message,
+        created_at: Date.now(),
+        decided_at: Date.now()
+      });
+      console.error(chalk2.red(`Proposal invalid: ${id}`));
+      console.error(chalk2.red(error.message));
+    }
+  });
+  strategyCmd.command("review").description("Review recent episodes and generate a strategy proposal").option("-n, --limit <limit>", "Max episodes to review", "50").option("--min-failures <count>", "Min failures per tool", "1").option("--min-failure-rate <rate>", "Min failure rate per tool", "0.2").action(async (options) => {
+    const config = await new ConfigLoader3().load();
+    const registry = new StrategyRegistry3();
+    const dbPath = path2.join(os2.homedir(), ".lydia", "memory.db");
+    const memory = new MemoryManager2(dbPath);
+    try {
+      const activePath = config.strategy?.activePath;
+      const active = activePath ? await registry.loadFromFile(activePath) : await registry.loadDefault();
+      const reviewer = new StrategyReviewer(memory);
+      const summary = reviewer.review(active, {
+        episodeLimit: Number(options.limit) || 50,
+        minFailures: Number(options.minFailures) || 1,
+        minFailureRate: Number(options.minFailureRate) || 0.2
+      });
+      if (summary.findings.length === 0) {
+        console.log(chalk2.yellow("No actionable findings."));
+        return;
+      }
+      const proposed = JSON.parse(JSON.stringify(active));
+      proposed.metadata = {
+        ...active.metadata,
+        version: bumpPatchVersion(active.metadata.version),
+        inheritFrom: active.metadata.id,
+        description: `${active.metadata.description || "Strategy"} (auto review)`
+      };
+      const existingConfirmations = new Set(active.execution?.requiresConfirmation || []);
+      for (const tool of summary.suggestedConfirmations) {
+        existingConfirmations.add(tool);
+      }
+      proposed.execution = {
+        ...active.execution || {},
+        requiresConfirmation: Array.from(existingConfirmations)
+      };
+      const proposalsDir = path2.join(os2.homedir(), ".lydia", "strategies", "proposals");
+      await fsPromises2.mkdir(proposalsDir, { recursive: true });
+      const proposalPath = path2.join(
+        proposalsDir,
+        `${proposed.metadata.id}-v${proposed.metadata.version}.yml`
+      );
+      await registry.saveToFile(proposed, proposalPath);
+      const gate = BasicStrategyGate.validate(proposed);
+      const status = gate.ok ? "pending_human" : "invalid";
+      const id = memory.recordStrategyProposal({
+        strategy_path: proposalPath,
+        status,
+        reason: gate.reason,
+        evaluation_json: JSON.stringify({ review: summary }),
+        created_at: Date.now(),
+        decided_at: gate.ok ? void 0 : Date.now()
+      });
+      if (gate.ok) {
+        console.log(chalk2.green(`Review proposal created: ${id}`));
+        console.log(chalk2.green(`Proposal file: ${proposalPath}`));
+      } else {
+        console.error(chalk2.red(`Proposal rejected by gate: ${id}`));
+        console.error(chalk2.red(gate.reason || "Invalid strategy"));
+      }
+    } catch (error) {
+      console.error(chalk2.red("Review failed:"), error.message);
+    }
+  });
+  strategyCmd.command("approve").description("Approve a strategy proposal").argument("<id>", "Proposal id").action(async (id) => {
+    const proposalId = Number(id);
+    const approval = new StrategyApprovalService2();
+    try {
+      const result = await approval.approveProposal(proposalId);
+      console.log(chalk2.green(`Approved proposal ${proposalId}`));
+      console.log(chalk2.gray(`Active strategy: ${result.activePath}`));
+    } catch (error) {
+      console.error(chalk2.red(error.message || String(error)));
+    }
+  });
+  strategyCmd.command("reject").description("Reject a strategy proposal").argument("<id>", "Proposal id").option("-r, --reason <reason>", "Rejection reason").action(async (id, options) => {
+    const proposalId = Number(id);
+    const approval = new StrategyApprovalService2();
+    try {
+      await approval.rejectProposal(proposalId, options.reason);
+      console.log(chalk2.yellow(`Rejected proposal ${proposalId}`));
+    } catch (error) {
+      console.error(chalk2.red(error.message || String(error)));
+    }
+  });
+  strategyCmd.command("proposals").description("List recent strategy proposals").option("-n, --limit <limit>", "Max number of proposals", "20").action(async (options) => {
+    const limit = Number(options.limit) || 20;
+    const dbPath = path2.join(os2.homedir(), ".lydia", "memory.db");
+    const memory = new MemoryManager2(dbPath);
+    const proposals = memory.listStrategyProposals(limit);
+    if (proposals.length === 0) {
+      console.log(chalk2.yellow("No proposals found."));
+      return;
+    }
+    proposals.forEach((p) => {
+      let details = "";
+      if (p.evaluation_json) {
+        try {
+          const evalData = JSON.parse(p.evaluation_json);
+          const replay = evalData?.replay;
+          const validation = evalData?.validation;
+          if (replay?.candidateSummary && replay?.baselineSummary && replay?.delta) {
+            const candidate = replay.candidateSummary;
+            const baseline = replay.baselineSummary;
+            const delta = replay.delta;
+            details = ` | score ${((replay.candidateScore || 0) * 100).toFixed(1)}% vs ${((replay.baselineScore || 0) * 100).toFixed(1)}% | dur ${Math.round(candidate.averageDuration || 0)}ms (${Math.round(delta.averageDuration || 0)}ms) | risk ${(candidate.averageRiskEvents || 0).toFixed(2)} (${(delta.averageRiskEvents || 0).toFixed(2)}) | human ${(candidate.averageHumanInterrupts || 0).toFixed(2)} (${(delta.averageHumanInterrupts || 0).toFixed(2)}) | drift ${(candidate.driftRate || 0).toFixed(2)} (${(delta.driftRate || 0).toFixed(2)})`;
+          } else if (validation?.status) {
+            details = ` | validation ${validation.status}${validation.reason ? `: ${validation.reason}` : ""}`;
+          }
+        } catch {
+        }
+      }
+      const summary = p.evaluation_json ? "has_eval" : "no_eval";
+      console.log(`${p.id} | ${p.status} | ${summary}${details} | ${p.strategy_path}`);
+    });
+  });
+  strategyCmd.command("report").description("Export proposal evaluation to a JSON file").argument("<id>", "Proposal id").argument("<file>", "Output file path").action(async (id, file) => {
+    const proposalId = Number(id);
+    if (Number.isNaN(proposalId)) {
+      console.error(chalk2.red("Proposal id must be a number"));
+      return;
+    }
+    const dbPath = path2.join(os2.homedir(), ".lydia", "memory.db");
+    const memory = new MemoryManager2(dbPath);
+    const proposal = memory.getStrategyProposal(proposalId);
+    if (!proposal || !proposal.evaluation_json) {
+      console.error(chalk2.red("Proposal evaluation not found"));
+      return;
+    }
+    const outPath = path2.resolve(file);
+    fs3.writeFileSync(outPath, proposal.evaluation_json, "utf-8");
+    console.log(chalk2.green(`Report saved: ${outPath}`));
+  });
+  const shadowCmd = strategyCmd.command("shadow").description("Manage shadow/canary rollout and auto-promotion settings");
+  shadowCmd.command("status").description("Show current shadow rollout status and recent metrics").action(async () => {
+    const config = await new ConfigLoader3().load();
+    const registry = new StrategyRegistry3();
+    const dbPath = path2.join(os2.homedir(), ".lydia", "memory.db");
+    const memory = new MemoryManager2(dbPath);
+    const active = config.strategy?.activePath ? await registry.loadFromFile(config.strategy.activePath) : await registry.loadDefault();
+    const windowDays = config.strategy.shadowWindowDays ?? 14;
+    const sinceMs = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+    const baselineSummary = memory.summarizeEpisodesByStrategy(
+      active.metadata.id,
+      active.metadata.version,
+      { sinceMs, limit: 1e3 }
+    );
+    console.log(chalk2.bold("\nShadow Rollout Status"));
+    console.log(`  Enabled: ${config.strategy.shadowModeEnabled ? chalk2.green("yes") : chalk2.gray("no")}`);
+    console.log(`  Mode: ${config.strategy.shadowRolloutMode}`);
+    console.log(`  Traffic Ratio: ${(config.strategy.shadowTrafficRatio * 100).toFixed(1)}%`);
+    console.log(`  Auto-Promote: ${config.strategy.autoPromoteEnabled ? chalk2.green("yes") : chalk2.gray("no")}`);
+    console.log(`  Promote Check Interval: ${config.strategy.autoPromoteEvalInterval} task(s)`);
+    console.log(`  Window: ${windowDays} day(s)`);
+    console.log(`  Baseline: ${active.metadata.id} v${active.metadata.version}`);
+    console.log(
+      `    tasks=${baselineSummary.total} success=${baselineSummary.success} failure=${baselineSummary.failure} avgDuration=${baselineSummary.avg_duration_ms}ms`
+    );
+    const candidates = config.strategy.shadowCandidatePaths || [];
+    if (candidates.length === 0) {
+      console.log(chalk2.yellow("\n  No shadow candidates configured.\n"));
+      return;
+    }
+    console.log(chalk2.bold("\nCandidates:"));
+    for (const candidatePath of candidates) {
+      try {
+        const candidate = await registry.loadFromFile(candidatePath);
+        const summary = memory.summarizeEpisodesByStrategy(
+          candidate.metadata.id,
+          candidate.metadata.version,
+          { sinceMs, limit: 1e3 }
+        );
+        console.log(`  - ${candidate.metadata.id} v${candidate.metadata.version}`);
+        console.log(`    path=${candidatePath}`);
+        console.log(
+          `    tasks=${summary.total} success=${summary.success} failure=${summary.failure} avgDuration=${summary.avg_duration_ms}ms`
+        );
+      } catch (error) {
+        console.log(`  - ${candidatePath}`);
+        console.log(chalk2.red(`    failed to load: ${error.message || String(error)}`));
+      }
+    }
+    console.log("");
+  });
+  shadowCmd.command("enable").description("Enable shadow/canary rollout").action(async () => {
+    await new ConfigLoader3().update({ strategy: { shadowModeEnabled: true } });
+    console.log(chalk2.green("Shadow rollout enabled."));
+  });
+  shadowCmd.command("disable").description("Disable shadow/canary rollout").action(async () => {
+    await new ConfigLoader3().update({ strategy: { shadowModeEnabled: false } });
+    console.log(chalk2.yellow("Shadow rollout disabled."));
+  });
+  shadowCmd.command("mode").description("Set rollout mode: shadow (safe) or canary (real traffic)").argument("<mode>", "shadow | canary").action(async (mode) => {
+    const normalized = String(mode || "").trim().toLowerCase();
+    if (normalized !== "shadow" && normalized !== "canary") {
+      console.error(chalk2.red("mode must be shadow or canary"));
+      return;
+    }
+    await new ConfigLoader3().update({ strategy: { shadowRolloutMode: normalized } });
+    console.log(chalk2.green(`Shadow rollout mode set to ${normalized}.`));
+  });
+  shadowCmd.command("ratio").description("Set shadow traffic ratio (0.0 - 1.0)").argument("<value>", "Traffic ratio").action(async (value) => {
+    const ratio = Number(value);
+    if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
+      console.error(chalk2.red("ratio must be between 0.0 and 1.0"));
+      return;
+    }
+    await new ConfigLoader3().update({ strategy: { shadowTrafficRatio: ratio } });
+    console.log(chalk2.green(`Shadow traffic ratio set to ${(ratio * 100).toFixed(1)}%.`));
+  });
+  shadowCmd.command("eval-interval").description("Set auto-promotion evaluation interval in completed tasks").argument("<value>", "Positive integer").action(async (value) => {
+    const interval = Number(value);
+    if (!Number.isInteger(interval) || interval <= 0) {
+      console.error(chalk2.red("eval interval must be a positive integer"));
+      return;
+    }
+    await new ConfigLoader3().update({ strategy: { autoPromoteEvalInterval: interval } });
+    console.log(chalk2.green(`Auto-promotion evaluation interval set to ${interval}.`));
+  });
+  shadowCmd.command("add").description("Add a shadow candidate strategy file").argument("<file>", "Path to strategy file").action(async (file) => {
+    const absPath = path2.resolve(file);
+    const registry = new StrategyRegistry3();
+    try {
+      await registry.loadFromFile(absPath);
+    } catch (error) {
+      console.error(chalk2.red(`Invalid strategy file: ${error.message || String(error)}`));
+      return;
+    }
+    const loader = new ConfigLoader3();
+    const config = await loader.load();
+    const current = new Set(config.strategy.shadowCandidatePaths || []);
+    current.add(absPath);
+    await loader.update({ strategy: { shadowCandidatePaths: Array.from(current) } });
+    console.log(chalk2.green(`Added shadow candidate: ${absPath}`));
+  });
+  shadowCmd.command("remove").description("Remove a shadow candidate strategy file").argument("<file>", "Path to strategy file").action(async (file) => {
+    const absPath = path2.resolve(file);
+    const loader = new ConfigLoader3();
+    const config = await loader.load();
+    const next = (config.strategy.shadowCandidatePaths || []).filter((item) => path2.resolve(item) !== absPath);
+    await loader.update({ strategy: { shadowCandidatePaths: next } });
+    console.log(chalk2.yellow(`Removed shadow candidate: ${absPath}`));
+  });
+  shadowCmd.command("promote-check").description("Evaluate whether a candidate should be auto-promoted now").action(async () => {
+    const config = await new ConfigLoader3().load();
+    const router = new ShadowRouter2();
+    const decision = await router.evaluateAutoPromotion(config);
+    if (!decision) {
+      console.log(chalk2.yellow("No candidate currently meets auto-promotion criteria."));
+      return;
+    }
+    console.log(chalk2.green("Auto-promotion candidate ready:"));
+    console.log(`  Candidate: ${decision.candidateId} v${decision.candidateVersion}`);
+    console.log(`  Path: ${decision.candidatePath}`);
+    console.log(`  Improvement: ${(decision.successImprovement * 100).toFixed(2)}%`);
+    console.log(`  p-value: ${decision.pValue.toFixed(6)}`);
+  });
+  const tasksCmd = program.command("tasks").description("View and manage task history");
+  tasksCmd.command("list").description("List recent tasks").option("-n, --limit <limit>", "Max number of tasks", "20").option("--status <status>", "Filter by status (running|completed|failed)").option("-s, --search <query>", "Search tasks by keyword").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (options) => {
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      const limit = Number(options.limit) || 20;
+      const params = new URLSearchParams({ limit: String(limit) });
+      if (options.status) params.set("status", options.status);
+      if (options.search) params.set("search", options.search);
+      const result = await apiGet(
+        `/api/tasks?${params}`,
+        port
+      );
+      if (!result.items?.length) {
+        console.log(chalk2.yellow("No tasks found."));
+        return;
+      }
+      console.log(chalk2.bold(`
+Recent Tasks (${result.items.length} of ${result.total}):
+`));
+      for (const item of result.items) {
+        const statusIcon = item.status === "completed" ? chalk2.green("\u2713") : item.status === "running" ? chalk2.blue("\u25CB") : chalk2.red("\u2717");
+        const statusText = item.status === "completed" ? chalk2.green("completed") : item.status === "running" ? chalk2.blue("running") : chalk2.red("failed");
+        const title = item.input?.substring(0, 80) || item.summary || "Unknown task";
+        const date = new Date(item.createdAt).toLocaleString();
+        const duration = item.duration ? ` (${formatDurationMs(item.duration)})` : "";
+        console.log(`  ${statusIcon} ${chalk2.bold(title)}`);
+        console.log(`    ${statusText}${duration} \xB7 ${chalk2.dim(date)} \xB7 ID: ${chalk2.dim(item.id)}`);
+        if (item.summary && item.summary !== item.input) {
+          console.log(`    ${chalk2.dim(item.summary.substring(0, 100))}`);
+        }
+        console.log("");
+      }
+    } catch (error) {
+      console.error(chalk2.red("Failed to list tasks:"), error.message);
+    }
+  });
+  tasksCmd.command("show").description("Show detailed information about a task").argument("<id>", "Task ID (e.g., report-5 or run-...)").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (id, options) => {
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      const detail = await apiGet(`/api/tasks/${encodeURIComponent(id)}/detail`, port);
+      const statusText = detail.status === "completed" ? chalk2.green("SUCCESS") : detail.status === "running" ? chalk2.blue("RUNNING") : chalk2.red("FAILED");
+      const title = detail.report?.intentSummary || detail.input || "Unknown task";
+      const date = new Date(detail.createdAt).toLocaleString();
+      const duration = detail.duration ? formatDurationMs(detail.duration) : "N/A";
+      console.log(chalk2.bold(`
+Task: ${title}
+`));
+      console.log(`  Status:   ${statusText}`);
+      console.log(`  Date:     ${date}`);
+      console.log(`  Duration: ${duration}`);
+      console.log(`  ID:       ${id}`);
+      if (detail.report?.summary) {
+        console.log(`
+  ${chalk2.bold("Summary:")}`);
+        console.log(`  ${detail.report.summary}`);
+      }
+      if (detail.report?.outputs?.length) {
+        console.log(`
+  ${chalk2.bold("Outputs:")}`);
+        for (const out of detail.report.outputs) {
+          console.log(`  \u2192 ${out}`);
+        }
+      }
+      if (detail.report?.steps?.length) {
+        console.log(`
+  ${chalk2.bold("Steps:")}`);
+        for (const step of detail.report.steps) {
+          const stepIcon = step.status === "completed" ? chalk2.green("\u2713") : chalk2.red("\u2717");
+          console.log(`  ${stepIcon} ${step.stepId} (${step.status})`);
+        }
+      }
+      if (detail.report?.followUps?.length) {
+        console.log(`
+  ${chalk2.bold("Follow-ups:")}`);
+        for (const item of detail.report.followUps) {
+          console.log(`  \u2022 ${item}`);
+        }
+      }
+      if (detail.traces?.length) {
+        console.log(`
+  ${chalk2.bold(`Tool Traces (${detail.traces.length} steps):`)}`);
+        for (const trace of detail.traces) {
+          const traceIcon = trace.status === "success" ? chalk2.green("\u2713") : chalk2.red("\u2717");
+          console.log(`  ${traceIcon} ${trace.tool_name} ${chalk2.dim(`(${trace.duration}ms)`)}`);
+        }
+      }
+      if (detail.evidence?.length) {
+        console.log(`
+  ${chalk2.bold(`Evidence Frames (${detail.evidence.length}):`)}`);
+        for (const frame of detail.evidence.slice(0, 10)) {
+          const blockTypes = Array.isArray(frame.blocks) ? frame.blocks.map((block) => block.type).join(", ") : "unknown";
+          console.log(`  - ${frame.frameId} ${chalk2.dim(`(${blockTypes})`)}`);
+        }
+      }
+      console.log("");
+    } catch (error) {
+      console.error(chalk2.red("Failed to show task:"), error.message);
+    }
+  });
+  tasksCmd.command("resumable").description("List tasks that can be resumed from checkpoint").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (options) => {
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      const result = await apiGet("/api/tasks/resumable", port);
+      if (!result.items?.length) {
+        console.log(chalk2.yellow("No resumable tasks found."));
+        return;
+      }
+      console.log(chalk2.bold(`
+Resumable Tasks (${result.items.length}):
+`));
+      for (const item of result.items) {
+        const date = new Date(item.taskCreatedAt).toLocaleString();
+        const updated = new Date(item.updatedAt).toLocaleString();
+        const title = item.input?.substring(0, 80) || "Unknown task";
+        console.log(`  ${chalk2.blue("\u25CB")} ${chalk2.bold(title)}`);
+        console.log(`    Iteration: ${chalk2.cyan(String(item.iteration))} \xB7 Started: ${chalk2.dim(date)} \xB7 Last checkpoint: ${chalk2.dim(updated)}`);
+        console.log(`    ID: ${chalk2.dim(item.taskId)}`);
+        console.log("");
+      }
+    } catch (error) {
+      console.error(chalk2.red("Failed to list resumable tasks:"), error.message);
+    }
+  });
+  tasksCmd.command("resume").description("Resume an interrupted task from its checkpoint").argument("<id>", 'Task ID (from "tasks resumable")').option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (taskId, options) => {
+    const spinner = ora("Connecting to server...").start();
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      spinner.succeed(chalk2.green("Server connected"));
+      spinner.start("Resuming task from checkpoint...");
+      const { runId, fromIteration } = await apiPost(
+        `/api/tasks/${encodeURIComponent(taskId)}/resume`,
+        {},
+        port
+      );
+      spinner.succeed(chalk2.green(`Task resumed from iteration ${fromIteration} (${runId})`));
+      spinner.start("Thinking...");
+      let isStreaming = false;
+      await new Promise((resolve2, reject) => {
+        connectTaskStream(runId, {
+          onText(text) {
+            if (!isStreaming) {
+              spinner.stop();
+              isStreaming = true;
+            }
+            process.stdout.write(chalk2.white(text));
+          },
+          onThinking() {
+            if (!isStreaming) {
+              spinner.stop();
+              isStreaming = true;
+            }
+            spinner.text = chalk2.dim("Thinking...");
+          },
+          onToolStart(name) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.start(`Using tool: ${name}`);
+          },
+          onToolComplete(name, duration, result) {
+            spinner.stopAndPersist({
+              symbol: chalk2.green("*"),
+              text: `${chalk2.green(name)} ${chalk2.dim(`(${duration}ms)`)}`
+            });
+            if (result) {
+              const resultLines = String(result).split("\n");
+              const preview = resultLines.slice(0, 5).join("\n");
+              console.log(chalk2.dim(preview.replace(/^/gm, "      ")));
+              if (resultLines.length > 5) {
+                console.log(chalk2.dim(`      ... (${resultLines.length - 5} more lines)`));
+              }
+            }
+            spinner.start("Thinking...");
+          },
+          onToolError(name, error) {
+            spinner.stopAndPersist({
+              symbol: chalk2.red("x"),
+              text: `${chalk2.red(name)}: ${error}`
+            });
+            spinner.start("Thinking...");
+          },
+          onRetry(attempt, maxRetries, delay, error) {
+            spinner.text = chalk2.yellow(`Retry ${attempt}/${maxRetries} after ${delay}ms: ${error}`);
+          },
+          async onInteraction(_id, prompt) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.stopAndPersist({ symbol: "!", text: "User Input Required" });
+            const rl = readline.createInterface({ input, output });
+            console.log(chalk2.yellow(`
+Agent asks: ${prompt}`));
+            const answer = await rl.question(chalk2.bold("> "));
+            rl.close();
+            spinner.start("Resuming...");
+            return answer;
+          },
+          onComplete() {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.succeed(chalk2.bold.green("Task Completed."));
+            resolve2();
+          },
+          onError(error) {
+            if (isStreaming) {
+              process.stdout.write("\n");
+              isStreaming = false;
+            }
+            spinner.fail(chalk2.red("Task Failed"));
+            console.error(chalk2.red(`
+Error details: ${error}`));
+            resolve2();
+          }
+        }, port).catch(reject);
+      });
+    } catch (error) {
+      spinner.fail(chalk2.red("Resume Error"));
+      console.error(chalk2.red(error.message || error));
+      process.exit(1);
+    }
+  });
+  const computerUseCmd = program.command("computer-use").description("Inspect computer-use sessions and evidence");
+  computerUseCmd.command("task-evidence").description("Inspect observation frames for a task").argument("<taskId>", "Task ID").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (taskId, options) => {
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      const result = await apiGet(
+        `/api/tasks/${encodeURIComponent(taskId)}/evidence`,
+        port
+      );
+      console.log(chalk2.bold(`
+Task Evidence: ${result.taskId}`));
+      console.log(`  Frames: ${result.total}`);
+      for (const frame of result.frames) {
+        const blockTypes = Array.isArray(frame.blocks) ? frame.blocks.map((block) => block.type).join(", ") : "unknown";
+        console.log(`  - ${frame.frameId} (${blockTypes})`);
+      }
+      console.log("");
+    } catch (error) {
+      console.error(chalk2.red("Failed to inspect task evidence:"), error.message);
+    }
+  });
+  computerUseCmd.command("session").description("Inspect a computer-use session timeline").argument("<sessionId>", "Computer-use session ID").option("--port <number>", "Server port", String(DEFAULT_PORT)).action(async (sessionId, options) => {
+    try {
+      const port = await ensureServer(parseInt(options.port, 10));
+      const result = await apiGet(`/api/computer-use/sessions/${encodeURIComponent(sessionId)}`, port);
+      console.log(chalk2.bold(`
+Computer-Use Session: ${result.sessionId}`));
+      if (result.checkpoint) {
+        console.log(`  Task: ${result.checkpoint.taskId}`);
+        console.log(`  Last action: ${result.checkpoint.lastActionId || "n/a"}`);
+        console.log(`  Verification failures: ${result.checkpoint.verificationFailures}`);
+      } else {
+        console.log(chalk2.yellow("  No active checkpoint found for this session."));
+      }
+      console.log(`  Frames: ${result.total}`);
+      for (const frame of result.frames) {
+        const blockTypes = Array.isArray(frame.blocks) ? frame.blocks.map((block) => block.type).join(", ") : "unknown";
+        console.log(`  - ${frame.actionId} -> ${frame.frameId} (${blockTypes})`);
+      }
+      console.log("");
+    } catch (error) {
+      console.error(chalk2.red("Failed to inspect session:"), error.message);
+    }
+  });
+  computerUseCmd.command("smoke").description("Run computer-use MCP smoke checks (health + canonical tool coverage + success rate)").option("-s, --server <id>", "Configured MCP server id", "browser").option("--timeout-ms <ms>", "Connection timeout per server (default: 15000)", "15000").option("--retries <n>", "Retry attempts (default: 1)", "1").option("--runs <n>", "Number of repeated smoke attempts (default: 1)", "1").option("--min-success-rate <n>", "Minimum pass ratio in [0,1] (default: 0.95)", "0.95").option("--json", "Output JSON only").action(async (options) => {
+    const config = await new ConfigLoader3().load();
+    const serverId = String(options.server || "browser");
+    const server = (config.mcpServers || {})[serverId];
+    if (!server) {
+      const message = `MCP server "${serverId}" not found in ~/.lydia/config.json`;
+      if (options.json) {
+        console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+      } else {
+        console.error(chalk2.red(message));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const timeoutMs = Number(options.timeoutMs) || 15e3;
+    const retries = Math.max(0, Number(options.retries) || 1);
+    const runs = Math.max(1, Number(options.runs) || 1);
+    const minSuccessRate = Math.min(1, Math.max(0, Number(options.minSuccessRate) || 0.95));
+    const attempts = [];
+    for (let i = 0; i < runs; i += 1) {
+      const [result] = await checkMcpServers(
+        [{ id: serverId, command: server.command, args: server.args, env: server.env }],
+        { timeoutMs, retries }
+      );
+      const tools = result?.tools || [];
+      const canonicalTools = tools.filter((name) => Boolean(resolveCanonicalComputerUseToolName(name)));
+      attempts.push({
+        ok: Boolean(result?.ok) && canonicalTools.length > 0,
+        health: result,
+        totalTools: tools.length,
+        canonicalTools
+      });
+    }
+    const passed = attempts.filter((item) => item.ok).length;
+    const successRate = runs > 0 ? passed / runs : 0;
+    const last = attempts[attempts.length - 1];
+    const smoke = {
+      ok: successRate >= minSuccessRate,
+      serverId,
+      runs,
+      passed,
+      successRate,
+      minSuccessRate,
+      lastAttempt: last,
+      attempts
+    };
+    if (options.json) {
+      console.log(JSON.stringify(smoke, null, 2));
+    } else {
+      if (!last?.health?.ok) {
+        console.log(chalk2.red(`x ${serverId}: ${last?.health?.error || "health check failed"}`));
+      } else {
+        console.log(chalk2.green(`* ${serverId}: latest health check passed (${last.health.durationMs}ms)`));
+        console.log(chalk2.dim(`  discovered tools: ${last.totalTools}`));
+        console.log(chalk2.dim(`  canonical computer-use aliases: ${last.canonicalTools.length}`));
+        if (last.canonicalTools.length > 0) {
+          console.log(chalk2.dim(`  ${last.canonicalTools.join(", ")}`));
+        }
+      }
+      console.log(
+        `${smoke.ok ? chalk2.green("*") : chalk2.red("x")} smoke success rate: ${(successRate * 100).toFixed(1)}% (${passed}/${runs}), threshold ${(minSuccessRate * 100).toFixed(1)}%`
+      );
+    }
+    if (!smoke.ok) {
+      if (!options.json && last?.health?.ok && (last?.canonicalTools?.length || 0) === 0) {
+        console.log(chalk2.red("Smoke failed: no canonical computer-use tools detected."));
+      }
+      process.exitCode = 1;
+    }
+  });
+  const skillsCmd = program.command("skills").description("Manage skills");
+  skillsCmd.command("list").description("List all loaded skills").action(async () => {
+    const { SkillRegistry, SkillLoader } = await import("@lydia-agent/core");
+    const registry = new SkillRegistry();
+    const loader = new SkillLoader(registry);
+    const config = await new ConfigLoader3().load();
+    const extraDirs = config.skills?.extraDirs ?? [];
+    await loader.loadAll(extraDirs);
+    const skills = registry.list();
+    if (skills.length === 0) {
+      console.log(chalk2.yellow("No skills found."));
+      return;
+    }
+    console.log(chalk2.bold(`
+Loaded Skills (${skills.length}):
+`));
+    for (const skill of skills) {
+      const version2 = "version" in skill && skill.version ? ` v${skill.version}` : "";
+      const tags = skill.tags?.length ? chalk2.dim(` [${skill.tags.join(", ")}]`) : "";
+      const source = skill.path ? chalk2.dim(` (${skill.path})`) : "";
+      const isDynamic = "execute" in skill ? chalk2.cyan(" [dynamic]") : "";
+      console.log(`  ${chalk2.green(skill.name)}${version2}${isDynamic} - ${skill.description}${tags}`);
+      if (source) console.log(`    ${source}`);
+    }
+    console.log("");
+  });
+  skillsCmd.command("info").description("Show detailed information about a skill").argument("<name>", "Skill name").action(async (name) => {
+    const { SkillRegistry, SkillLoader } = await import("@lydia-agent/core");
+    const registry = new SkillRegistry();
+    const loader = new SkillLoader(registry);
+    const config = await new ConfigLoader3().load();
+    const extraDirs = config.skills?.extraDirs ?? [];
+    await loader.loadAll(extraDirs);
+    const skill = registry.get(name);
+    if (!skill) {
+      console.error(chalk2.red(`Skill "${name}" not found.`));
+      return;
+    }
+    console.log(chalk2.bold(`
+Skill: ${skill.name}
+`));
+    console.log(`  Description: ${skill.description}`);
+    if ("version" in skill && skill.version) console.log(`  Version:     ${skill.version}`);
+    if ("author" in skill && skill.author) console.log(`  Author:      ${skill.author}`);
+    if (skill.tags?.length) console.log(`  Tags:        ${skill.tags.join(", ")}`);
+    if (skill.allowedTools?.length) console.log(`  Allowed Tools: ${skill.allowedTools.join(", ")}`);
+    if (skill.path) console.log(`  Path:        ${skill.path}`);
+    const content = await loader.loadContent(name);
+    if (content) {
+      console.log(chalk2.dim(`
+${"\u2500".repeat(40)}
+`));
+      console.log(content);
+      console.log("");
+    }
+  });
+  skillsCmd.command("install").description("Install a skill from a GitHub URL or local path").argument("<source>", "GitHub URL (github:user/repo/path) or local directory path").option("--project", "Install to project .lydia/skills/ instead of user global").action(async (source, options) => {
+    const targetDir = options.project ? path2.join(process.cwd(), ".lydia", "skills") : path2.join(os2.homedir(), ".lydia", "skills");
+    await fsPromises2.mkdir(targetDir, { recursive: true });
+    if (source.startsWith("github:")) {
+      const ghPath = source.slice("github:".length);
+      const parts = ghPath.split("/");
+      if (parts.length < 3) {
+        console.error(chalk2.red("Invalid GitHub source. Format: github:owner/repo/path/to/skill"));
+        return;
+      }
+      const owner = parts[0];
+      const repo = parts[1];
+      const skillPath = parts.slice(2).join("/");
+      const skillName = parts[parts.length - 1].replace(/\.md$/, "");
+      console.log(chalk2.dim(`Fetching from GitHub: ${owner}/${repo}/${skillPath}...`));
+      try {
+        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/${skillPath}`;
+        const response = await fetch(rawUrl);
+        if (response.ok) {
+          const content = await response.text();
+          const fileName = skillPath.endsWith(".md") ? path2.basename(skillPath) : `${skillName}.md`;
+          const destPath = path2.join(targetDir, fileName);
+          await fsPromises2.writeFile(destPath, content, "utf-8");
+          console.log(chalk2.green(`Installed skill to: ${destPath}`));
+        } else {
+          const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}`;
+          const apiResponse = await fetch(apiUrl, {
+            headers: { "Accept": "application/vnd.github.v3+json" }
+          });
+          if (!apiResponse.ok) {
+            console.error(chalk2.red(`Failed to fetch from GitHub: ${apiResponse.statusText}`));
+            return;
+          }
+          const contents = await apiResponse.json();
+          if (!Array.isArray(contents)) {
+            console.error(chalk2.red("Source is not a valid file or directory."));
+            return;
+          }
+          const skillDir = path2.join(targetDir, skillName);
+          await fsPromises2.mkdir(skillDir, { recursive: true });
+          for (const item of contents) {
+            if (item.type === "file" && item.download_url) {
+              const fileRes = await fetch(item.download_url);
+              if (fileRes.ok) {
+                const fileContent = await fileRes.text();
+                const fileDest = path2.join(skillDir, item.name);
+                await fsPromises2.writeFile(fileDest, fileContent, "utf-8");
+                console.log(chalk2.dim(`  Downloaded: ${item.name}`));
+              }
+            }
+          }
+          console.log(chalk2.green(`Installed skill directory to: ${skillDir}`));
+        }
+      } catch (error) {
+        console.error(chalk2.red(`Installation failed: ${error.message}`));
+      }
+    } else {
+      const sourcePath = path2.resolve(source);
+      try {
+        const stat2 = await fsPromises2.stat(sourcePath);
+        if (stat2.isFile()) {
+          const destPath = path2.join(targetDir, path2.basename(sourcePath));
+          await fsPromises2.copyFile(sourcePath, destPath);
+          console.log(chalk2.green(`Installed skill to: ${destPath}`));
+        } else if (stat2.isDirectory()) {
+          const dirName = path2.basename(sourcePath);
+          const destDir = path2.join(targetDir, dirName);
+          await fsPromises2.mkdir(destDir, { recursive: true });
+          await copyDir(sourcePath, destDir);
+          console.log(chalk2.green(`Installed skill directory to: ${destDir}`));
+        }
+      } catch (error) {
+        console.error(chalk2.red(`Installation failed: ${error.message}`));
+      }
+    }
+  });
+  skillsCmd.command("remove").description("Remove an installed skill").argument("<name>", "Skill name to remove").option("--project", "Remove from project .lydia/skills/ instead of user global").action(async (name, options) => {
+    const baseDir = options.project ? path2.join(process.cwd(), ".lydia", "skills") : path2.join(os2.homedir(), ".lydia", "skills");
+    let removed = false;
+    const mdPath = path2.join(baseDir, `${name}.md`);
+    if (fs3.existsSync(mdPath)) {
+      await fsPromises2.unlink(mdPath);
+      console.log(chalk2.green(`Removed skill file: ${mdPath}`));
+      removed = true;
+    }
+    const dirPath = path2.join(baseDir, name);
+    if (fs3.existsSync(dirPath)) {
+      await fsPromises2.rm(dirPath, { recursive: true });
+      console.log(chalk2.green(`Removed skill directory: ${dirPath}`));
+      removed = true;
+    }
+    if (!removed) {
+      console.error(chalk2.red(`Skill "${name}" not found in ${baseDir}`));
+    }
+  });
+  program.parse();
+}
+async function copyDir(src, dest) {
+  const entries = await fsPromises2.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await fsPromises2.mkdir(destPath, { recursive: true });
+      await copyDir(srcPath, destPath);
+    } else {
+      await fsPromises2.copyFile(srcPath, destPath);
+    }
+  }
+}
+main();