@codelia/runtime 0.1.3 → 0.1.12

package/dist/index.cjs

@@ -23,11 +23,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/runtime.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
+var import_storage9 = require("@codelia/storage");
 
 // src/agent-factory.ts
-var import_core16 = require("@codelia/core");
-var import_storage4 = require("@codelia/storage");
+var import_node_fs14 = require("fs");
+var import_core17 = require("@codelia/core");
+var import_storage5 = require("@codelia/storage");
 
 // src/agents/context.ts
 var createAgentsResolverKey = (resolver) => ({
@@ -856,10 +858,13 @@ var describeRpcMessage = (msg) => {
   }
   return "unknown";
 };
+var serializeMessage = (msg) => ({
+  payload: `${JSON.stringify(msg)}
+`,
+  label: describeRpcMessage(msg)
+});
 var send = (msg) => {
-  const payload = `${JSON.stringify(msg)}
-`;
-  const label = describeRpcMessage(msg);
+  const { payload, label } = serializeMessage(msg);
   const writable = process.stdout.write(payload, (error) => {
     if (error) {
       (0, import_logger.debugLog)(`transport.write.error label=${label} message=${error.message}`);
@@ -869,6 +874,20 @@ var send = (msg) => {
     (0, import_logger.debugLog)(`transport.backpressure label=${label} bytes=${payload.length}`);
   }
 };
+var sendAsync = async (msg) => new Promise((resolve) => {
+  const { payload, label } = serializeMessage(msg);
+  const writable = process.stdout.write(payload, (error) => {
+    if (error) {
+      (0, import_logger.debugLog)(
+        `transport.write.error label=${label} message=${error.message}`
+      );
+    }
+    resolve();
+  });
+  if (!writable) {
+    (0, import_logger.debugLog)(`transport.backpressure label=${label} bytes=${payload.length}`);
+  }
+});
 var sendError = (id, error) => {
   const response = { jsonrpc: "2.0", id, error };
   send(response);
@@ -892,6 +911,21 @@ var sendAgentEvent = (state, runId, event) => {
   send(notify);
   return seq;
 };
+var sendAgentEventAsync = async (state, runId, event) => {
+  if (state.shouldSuppressEvent(runId)) return null;
+  const seq = state.nextSequence(runId);
+  const notify = {
+    jsonrpc: "2.0",
+    method: "agent.event",
+    params: {
+      run_id: runId,
+      seq,
+      event
+    }
+  };
+  await sendAsync(notify);
+  return seq;
+};
 var sendRunStatus = (runId, status, message) => {
   const notify = {
     jsonrpc: "2.0",
@@ -904,6 +938,18 @@ var sendRunStatus = (runId, status, message) => {
   };
   send(notify);
 };
+var sendRunStatusAsync = async (runId, status, message) => {
+  const notify = {
+    jsonrpc: "2.0",
+    method: "run.status",
+    params: {
+      run_id: runId,
+      status,
+      message
+    }
+  };
+  await sendAsync(notify);
+};
 var sendRunContext = (runId, contextLeftPercent) => {
   const notify = {
     jsonrpc: "2.0",
@@ -982,10 +1028,15 @@ var AuthStore = class {
 };
 
 // src/auth/resolver.ts
-var SUPPORTED_PROVIDERS = ["openai", "anthropic"];
+var SUPPORTED_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "openrouter"
+];
 var API_KEY_ENV = {
   openai: "OPENAI_API_KEY",
-  anthropic: "ANTHROPIC_API_KEY"
+  anthropic: "ANTHROPIC_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
 };
 var AuthResolver = class _AuthResolver {
   auth;
@@ -1003,6 +1054,12 @@ var AuthResolver = class _AuthResolver {
     const auth = await store.load();
     return new _AuthResolver(state, log2, store, auth);
   }
+  hasAnyAvailableAuth() {
+    return SUPPORTED_PROVIDERS.some((provider) => {
+      if (this.auth.providers[provider]) return true;
+      return Boolean(readEnvValue(API_KEY_ENV[provider]));
+    });
+  }
   async resolveProvider(preferred) {
     const preferredProvider = preferred && SUPPORTED_PROVIDERS.includes(preferred) ? preferred : null;
     if (preferredProvider) return preferredProvider;
@@ -1021,10 +1078,11 @@ var AuthResolver = class _AuthResolver {
       return "openai";
     }
     const result = await requestUiPick(this.state, {
-      title: "Select provider",
+      title: "Welcome! Choose your provider to get started.",
       items: SUPPORTED_PROVIDERS.map((provider) => ({
         id: provider,
-        label: provider
+        label: provider,
+        detail: provider === "openai" ? "OAuth (ChatGPT Plus/Pro) or API key" : provider === "openrouter" ? "API key (OpenRouter)" : "API key"
       })),
       multi: false
     });
@@ -1047,7 +1105,17 @@ var AuthResolver = class _AuthResolver {
     if (provider === "openai") {
       return this.promptOpenAiAuth();
     }
-    return this.promptApiKey(provider, "Anthropic API key");
+    return this.promptApiKey(provider, this.getApiKeyPromptLabel(provider));
+  }
+  getApiKeyPromptLabel(provider) {
+    switch (provider) {
+      case "anthropic":
+        return "Anthropic API key";
+      case "openrouter":
+        return "OpenRouter API key";
+      default:
+        return "API key";
+    }
   }
   async getOpenAiAccessToken() {
     const entry = this.auth.providers.openai;
@@ -1076,10 +1144,18 @@ var AuthResolver = class _AuthResolver {
       throw new Error("UI does not support auth prompts");
     }
     const pick = await requestUiPick(this.state, {
-      title: "OpenAI auth method",
+      title: "How would you like to connect OpenAI?",
       items: [
-        { id: "oauth", label: "ChatGPT Plus/Pro (OAuth)" },
-        { id: "api_key", label: "Manually enter API key" }
+        {
+          id: "oauth",
+          label: "ChatGPT Plus/Pro (OAuth)",
+          detail: "Recommended if you use ChatGPT subscription access"
+        },
+        {
+          id: "api_key",
+          label: "OpenAI API key",
+          detail: "Use a standard OpenAI API key from platform settings"
+        }
       ],
       multi: false
     });
@@ -1103,7 +1179,7 @@ var AuthResolver = class _AuthResolver {
     const session = await createOAuthSession();
     const confirm = await requestUiConfirm(this.state, {
       title: "OpenAI OAuth",
-      message: `Open your browser to authenticate.
+      message: `You're almost done. Open your browser to continue sign in.
 
 ${session.authUrl}`,
       confirm_label: "Open browser",
@@ -1142,7 +1218,7 @@ ${session.authUrl}`,
     }
     const prompt = await requestUiPrompt(this.state, {
       title: label,
-      message: "Enter the API key.",
+      message: "Paste your API key to continue. You can change it later with /logout.",
       secret: true
     });
     const value = prompt?.value?.trim() ?? "";
@@ -1343,7 +1419,8 @@ var createMcpOAuthSession = async (params) => {
 var import_core2 = require("@codelia/core");
 var import_model_metadata = require("@codelia/model-metadata");
 var import_storage3 = require("@codelia/storage");
-var buildModelRegistry = async (llm) => {
+var buildModelRegistry = async (llm, options = {}) => {
+  const strict = options.strict ?? true;
   const metadataService = new import_model_metadata.ModelMetadataServiceImpl({
     storagePathService: new import_storage3.StoragePathServiceImpl()
   });
@@ -1358,9 +1435,11 @@ var buildModelRegistry = async (llm) => {
     fullIdEntry = providerEntries?.[`${llm.provider}/${llm.model}`];
   }
   if (!directEntry && !fullIdEntry) {
-    throw new Error(
-      `Model metadata not found for ${llm.provider}/${llm.model} after refresh`
-    );
+    if (strict) {
+      throw new Error(
+        `Model metadata not found for ${llm.provider}/${llm.model} after refresh`
+      );
+    }
   }
   return (0, import_core2.applyModelMetadata)(import_core2.DEFAULT_MODEL_REGISTRY, { models: entries });
 };
@@ -1717,6 +1796,8 @@ var SYSTEM_TOOL_ALLOWLIST = [
   "agents_resolve",
   "skill_search",
   "skill_load",
+  "lane_list",
+  "lane_status",
   "done"
 ];
 var SYSTEM_BASH_ALLOWLIST = [
@@ -1808,7 +1889,27 @@ var PermissionService = class {
         message: `${skillName ? skillName : explicitPath || `skill_load ${rawArgs}`}${rememberPreview}`
       };
     }
-    return { title: "Run tool?", message: `${toolName} ${rawArgs}` };
+    if (toolName === "write") {
+      const parsed = parseRawArgsForPrompt(rawArgs);
+      const filePath = parsed && typeof parsed.file_path === "string" ? parsed.file_path.trim() : "";
+      const content = parsed && typeof parsed.content === "string" ? parsed.content : "";
+      const target = filePath || "(unknown path)";
+      return {
+        title: "Run tool?",
+        message: `write ${target} (${content.length} bytes)${rememberPreview}`
+      };
+    }
+    if (toolName === "edit") {
+      const parsed = parseRawArgsForPrompt(rawArgs);
+      const filePath = parsed && typeof parsed.file_path === "string" ? parsed.file_path.trim() : "";
+      const target = filePath || "(unknown path)";
+      const mode = parsed && typeof parsed.match_mode === "string" ? parsed.match_mode : "auto";
+      return {
+        title: "Run tool?",
+        message: `edit ${target} (match=${mode})${rememberPreview}`
+      };
+    }
+    return { title: "Run tool?", message: toolName };
   }
   evaluate(toolName, rawArgs) {
     if (toolName === "bash") {
@@ -3304,94 +3405,820 @@ var createGrepTool = (sandboxKey) => (0, import_core8.defineTool)({
   }
 });
 
-// src/tools/read.ts
-var import_node_fs10 = require("fs");
+// src/tools/lane.ts
 var import_core9 = require("@codelia/core");
 var import_zod8 = require("zod");
-var DEFAULT_READ_LIMIT = 2e3;
-var MAX_LINE_LENGTH = 2e3;
-var MAX_BYTES = 50 * 1024;
-var createReadTool = (sandboxKey) => (0, import_core9.defineTool)({
-  name: "read",
-  description: "Read a text file with optional 0-based line offset and line limit.",
-  input: import_zod8.z.object({
-    file_path: import_zod8.z.string().describe("File path under the sandbox root."),
-    offset: import_zod8.z.number().int().nonnegative().optional().describe("0-based start line. Default 0."),
-    limit: import_zod8.z.number().int().positive().optional().describe("Max lines to read. Default 2000.")
-  }),
-  execute: async (input, ctx) => {
-    let resolved;
+
+// src/lanes/manager.ts
+var import_node_crypto4 = __toESM(require("crypto"), 1);
+var import_node_fs11 = require("fs");
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/lanes/command.ts
+var import_node_child_process3 = require("child_process");
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_CAPTURE_BYTES = 512 * 1024;
+var truncate2 = (value) => {
+  if (value.length <= 8e3) return value;
+  return `${value.slice(0, 8e3)}...[truncated]`;
+};
+var runCommand = async (command, args, options = {}) => {
+  const timeoutMs = Math.max(1e3, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process3.spawn)(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let bytes = 0;
+    let done = false;
+    const finish = (fn) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      fn();
+    };
+    const consume = (chunk, kind) => {
+      const text = chunk.toString("utf8");
+      bytes += Buffer.byteLength(text, "utf8");
+      if (bytes > MAX_CAPTURE_BYTES) {
+        finish(
+          () => reject(
+            new Error(
+              `${command} output exceeded ${MAX_CAPTURE_BYTES} bytes while running ${args.join(" ")}`
+            )
+          )
+        );
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        return;
+      }
+      if (kind === "stdout") {
+        stdout += text;
+      } else {
+        stderr += text;
+      }
+    };
+    child.stdout?.on("data", (chunk) => consume(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => consume(chunk, "stderr"));
+    child.on("error", (error) => {
+      finish(() => reject(error));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        finish(() => resolve({ stdout, stderr }));
+        return;
+      }
+      const detail = `${stderr}
+${stdout}`.trim();
+      const message = detail ? `${command} ${args.join(" ")} failed (exit ${String(code)}): ${truncate2(detail)}` : `${command} ${args.join(" ")} failed (exit ${String(code)})`;
+      finish(() => reject(new Error(message)));
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      finish(
+        () => reject(
+          new Error(
+            `${command} ${args.join(" ")} timed out after ${Math.floor(timeoutMs / 1e3)}s`
+          )
+        )
+      );
+    }, timeoutMs);
+  });
+};
+
+// src/lanes/registry.ts
+var import_node_fs10 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
+var import_storage4 = require("@codelia/storage");
+var REGISTRY_DIRNAME = "lanes";
+var REGISTRY_FILENAME = "registry.json";
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var sortByUpdatedDesc = (lanes) => [...lanes].sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+var readJsonFile = async (filePath) => {
+  try {
+    const raw = await import_node_fs10.promises.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.lanes)) {
+      return null;
+    }
+    return {
+      version: 1,
+      lanes: parsed.lanes
+    };
+  } catch {
+    return null;
+  }
+};
+var atomicWrite = async (filePath, payload) => {
+  const dir = import_node_path10.default.dirname(filePath);
+  const base = import_node_path10.default.basename(filePath);
+  const tmp = import_node_path10.default.join(
+    dir,
+    `${base}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`
+  );
+  await import_node_fs10.promises.writeFile(tmp, payload, "utf8");
+  await import_node_fs10.promises.rename(tmp, filePath);
+};
+var LaneRegistryStore = class {
+  registryPath;
+  constructor(registryPath) {
+    if (registryPath) {
+      this.registryPath = registryPath;
+      return;
+    }
+    const root = (0, import_storage4.resolveStoragePaths)().root;
+    this.registryPath = import_node_path10.default.join(root, REGISTRY_DIRNAME, REGISTRY_FILENAME);
+  }
+  async ensureDir() {
+    await import_node_fs10.promises.mkdir(import_node_path10.default.dirname(this.registryPath), { recursive: true });
+  }
+  async readAll() {
+    await this.ensureDir();
+    const data = await readJsonFile(this.registryPath);
+    if (!data) return [];
+    return sortByUpdatedDesc(data.lanes);
+  }
+  async writeAll(lanes) {
+    await this.ensureDir();
+    const payload = {
+      version: 1,
+      lanes: sortByUpdatedDesc(lanes)
+    };
+    await atomicWrite(
+      this.registryPath,
+      `${JSON.stringify(payload, null, 2)}
+`
+    );
+  }
+  async list() {
+    return this.readAll();
+  }
+  async get(laneId) {
+    const lanes = await this.readAll();
+    return lanes.find((lane) => lane.lane_id === laneId) ?? null;
+  }
+  async upsert(record) {
+    const lanes = await this.readAll();
+    const idx = lanes.findIndex((lane) => lane.lane_id === record.lane_id);
+    const next = {
+      ...record,
+      updated_at: nowIso()
+    };
+    if (idx >= 0) {
+      lanes[idx] = next;
+    } else {
+      lanes.push(next);
+    }
+    await this.writeAll(lanes);
+  }
+  async patch(laneId, patch) {
+    const lanes = await this.readAll();
+    const idx = lanes.findIndex((lane) => lane.lane_id === laneId);
+    if (idx < 0) return null;
+    const current = lanes[idx];
+    const next = {
+      ...current,
+      ...patch,
+      lane_id: current.lane_id,
+      created_at: current.created_at,
+      updated_at: nowIso()
+    };
+    lanes[idx] = next;
+    await this.writeAll(lanes);
+    return next;
+  }
+};
+
+// src/lanes/manager.ts
+var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
+var INITIAL_MESSAGE_FLAG = "--initial-message";
+var toSlug = (value) => {
+  const normalized = value.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
+  return normalized || "task";
+};
+var parseDate = (value) => {
+  const ts = Date.parse(value);
+  if (Number.isNaN(ts)) return 0;
+  return ts;
+};
+var isNotFoundError = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("command not found") || message.includes("ENOENT") || message.includes("not found");
+};
+var isExitFailure = (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("failed (exit");
+};
+var LaneManagerError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LaneManagerError";
+  }
+};
+var LaneManager = class {
+  runner;
+  registry;
+  now;
+  randomId;
+  launchCommand;
+  defaultWorktreeRoot;
+  constructor(options = {}) {
+    this.runner = options.runner ?? runCommand;
+    this.registry = options.registry ?? new LaneRegistryStore();
+    this.now = options.now ?? nowIso2;
+    this.randomId = options.randomId ?? (() => import_node_crypto4.default.randomUUID());
+    this.launchCommand = options.launchCommand ?? process.env.CODELIA_LANE_LAUNCH_COMMAND?.trim() ?? "codelia";
+    this.defaultWorktreeRoot = options.defaultWorktreeRoot ?? import_node_path11.default.join(import_node_os2.default.homedir(), ".codelia", "worktrees");
+  }
+  async cmd(command, args, options) {
+    (0, import_logger.debugLog)(`lane.cmd ${command} ${args.join(" ")}`);
+    return this.runner(command, args, options);
+  }
+  async resolveRepoRoot(workingDir) {
+    const { stdout } = await this.cmd(
+      "git",
+      ["-C", workingDir, "rev-parse", "--show-toplevel"],
+      { cwd: workingDir }
+    );
+    const root = stdout.trim();
+    if (!root) {
+      throw new LaneManagerError(
+        "backend_command_failed",
+        "Could not resolve git repository root."
+      );
+    }
+    return root;
+  }
+  async preflightBackend(backend) {
+    if (backend === "tmux") {
+      try {
+        await this.cmd("tmux", ["-V"]);
+        return;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          throw new LaneManagerError(
+            "backend_not_found",
+            "tmux not found in PATH."
+          );
+        }
+        throw new LaneManagerError(
+          "backend_command_failed",
+          `tmux preflight failed: ${String(error)}`
+        );
+      }
+    }
     try {
-      const sandbox = await getSandboxContext(ctx, sandboxKey);
-      resolved = sandbox.resolvePath(input.file_path);
+      await this.cmd("zellij", ["--version"]);
     } catch (error) {
-      return `Security error: ${String(error)}`;
+      if (isNotFoundError(error)) {
+        throw new LaneManagerError(
+          "backend_not_found",
+          "zellij not found in PATH."
+        );
+      }
+      throw new LaneManagerError(
+        "backend_command_failed",
+        `zellij preflight failed: ${String(error)}`
+      );
     }
+    throw new LaneManagerError(
+      "backend_command_failed",
+      "zellij backend is not supported yet in lane MVP. Use tmux."
+    );
+  }
+  async startTmuxLane(target, worktreePath, seedContext) {
+    const launchCommand = this.buildLaunchCommand(seedContext);
+    await this.cmd("tmux", [
+      "new-session",
+      "-d",
+      "-s",
+      target,
+      "-c",
+      worktreePath
+    ]);
+    const paneTarget = `${target}:0.0`;
+    await this.cmd("tmux", [
+      "send-keys",
+      "-t",
+      paneTarget,
+      "-l",
+      launchCommand
+    ]);
+    await this.cmd("tmux", ["send-keys", "-t", paneTarget, "Enter"]);
+  }
+  shellQuote(value) {
+    if (!value) return "''";
+    return `'${value.replaceAll("'", "'\\''")}'`;
+  }
+  buildLaunchCommand(seedContext) {
+    const seed = seedContext?.trim();
+    if (!seed) {
+      return this.launchCommand;
+    }
+    return `${this.launchCommand} ${INITIAL_MESSAGE_FLAG} ${this.shellQuote(seed)}`;
+  }
+  async isTmuxAlive(target) {
     try {
-      const stat = await import_node_fs10.promises.stat(resolved);
-      if (stat.isDirectory()) {
-        return `Path is a directory: ${input.file_path}`;
-      }
+      await this.cmd("tmux", ["has-session", "-t", target], {
+        timeoutMs: 5e3
+      });
+      return true;
+    } catch (error) {
+      if (isExitFailure(error)) return false;
+      throw new LaneManagerError(
+        "backend_command_failed",
+        `tmux status failed: ${String(error)}`
+      );
+    }
+  }
+  async stopTmuxLane(target) {
+    try {
+      await this.cmd("tmux", ["kill-session", "-t", target], {
+        timeoutMs: 1e4
+      });
+    } catch (error) {
+      if (isExitFailure(error)) return;
+      throw new LaneManagerError(
+        "backend_command_failed",
+        `tmux close failed: ${String(error)}`
+      );
+    }
+  }
+  async resolveWorktreeMainRoot(worktreePath) {
+    const { stdout } = await this.cmd("git", [
+      "-C",
+      worktreePath,
+      "rev-parse",
+      "--git-common-dir"
+    ]);
+    const commonDir = import_node_path11.default.resolve(worktreePath, stdout.trim());
+    if (import_node_path11.default.basename(commonDir) === ".git") {
+      return import_node_path11.default.dirname(commonDir);
+    }
+    return await this.resolveRepoRoot(worktreePath);
+  }
+  async isWorktreeDirty(worktreePath) {
+    try {
+      await import_node_fs11.promises.access(worktreePath);
     } catch {
-      return `File not found: ${input.file_path}`;
+      return false;
     }
+    const { stdout } = await this.cmd("git", [
+      "-C",
+      worktreePath,
+      "status",
+      "--porcelain"
+    ]);
+    return stdout.trim().length > 0;
+  }
+  async removeWorktree(worktreePath, force) {
     try {
-      const content = await import_node_fs10.promises.readFile(resolved, "utf8");
-      const lines = content.split(/\r?\n/);
-      if (lines.length === 0) {
-        return "";
+      await import_node_fs11.promises.access(worktreePath);
+    } catch {
+      return;
+    }
+    const repoRoot = await this.resolveWorktreeMainRoot(worktreePath);
+    const args = ["-C", repoRoot, "worktree", "remove"];
+    if (force) args.push("--force");
+    args.push(worktreePath);
+    await this.cmd("git", args);
+  }
+  async create(input, options) {
+    const taskId = input.task_id.trim();
+    if (!taskId) {
+      throw new LaneManagerError(
+        "backend_command_failed",
+        "task_id is required."
+      );
+    }
+    const backend = input.mux_backend ?? "tmux";
+    await this.preflightBackend(backend);
+    const repoRoot = await this.resolveRepoRoot(options.workingDir);
+    const laneId = this.randomId();
+    const slug = toSlug(taskId);
+    const shortId = laneId.slice(0, 8);
+    const branchName = `lane/${slug}-${shortId}`;
+    const worktreePath = input.worktree_path ? import_node_path11.default.resolve(options.workingDir, input.worktree_path) : import_node_path11.default.join(this.defaultWorktreeRoot, `${slug}-${shortId}`);
+    const muxTarget = `codelia-lane-${shortId}`;
+    const createdAt = this.now();
+    const record = {
+      lane_id: laneId,
+      task_id: taskId,
+      state: "creating",
+      mux_backend: backend,
+      mux_target: muxTarget,
+      worktree_path: worktreePath,
+      branch_name: branchName,
+      session_id: import_node_crypto4.default.randomUUID(),
+      created_at: createdAt,
+      updated_at: createdAt,
+      last_activity_at: createdAt
+    };
+    await this.registry.upsert(record);
+    try {
+      await import_node_fs11.promises.mkdir(import_node_path11.default.dirname(worktreePath), { recursive: true });
+      await this.cmd("git", [
+        "-C",
+        repoRoot,
+        "worktree",
+        "add",
+        "-b",
+        branchName,
+        worktreePath,
+        input.base_ref?.trim() || "HEAD"
+      ]);
+      if (backend === "tmux") {
+        await this.startTmuxLane(muxTarget, worktreePath, input.seed_context);
       }
-      const offset = input.offset ?? 0;
-      const limit = input.limit ?? DEFAULT_READ_LIMIT;
-      if (offset >= lines.length) {
-        return `Offset exceeds file length: ${input.file_path}`;
+      const running = await this.registry.patch(laneId, {
+        state: "running",
+        last_activity_at: this.now(),
+        last_error: void 0
+      });
+      if (!running) {
+        throw new Error("lane record disappeared during create");
       }
-      const raw = [];
-      let bytes = 0;
-      let truncatedByBytes = false;
-      for (let index = offset; index < Math.min(lines.length, offset + limit); index += 1) {
-        const line = lines[index].length > MAX_LINE_LENGTH ? `${lines[index].slice(0, MAX_LINE_LENGTH)}...` : lines[index];
-        const size = Buffer.byteLength(line, "utf8") + (raw.length > 0 ? 1 : 0);
-        if (bytes + size > MAX_BYTES) {
-          truncatedByBytes = true;
-          break;
+      return running;
+    } catch (error) {
+      await this.registry.patch(laneId, {
+        state: "error",
+        last_error: String(error),
+        last_activity_at: this.now()
+      });
+      throw new LaneManagerError(
+        "backend_command_failed",
+        `lane.create failed (${laneId}): ${String(error)}`
+      );
+    }
+  }
+  async list(input) {
+    const all = await this.registry.list();
+    if (input?.include_closed) return all;
+    return all.filter((lane) => lane.state !== "closed");
+  }
+  async status(laneId) {
+    const lane = await this.registry.get(laneId);
+    if (!lane) {
+      throw new LaneManagerError("lane_not_found", `Lane not found: ${laneId}`);
+    }
+    let alive = false;
+    if (lane.state !== "closed") {
+      if (lane.mux_backend === "tmux") {
+        alive = await this.isTmuxAlive(lane.mux_target);
+      }
+      if (lane.state === "running" && !alive) {
+        const patched = await this.registry.patch(lane.lane_id, {
+          state: "finished",
+          last_activity_at: this.now()
+        });
+        if (patched) {
+          return { lane: patched, backend_alive: false };
         }
-        raw.push(line);
-        bytes += size;
       }
-      const numbered = raw.map(
-        (line, index) => `${String(index + offset + 1).padStart(5, " ")}  ${line}`
+    }
+    return { lane, backend_alive: alive };
+  }
+  async close(input) {
+    const lane = await this.registry.get(input.lane_id);
+    if (!lane) {
+      throw new LaneManagerError(
+        "lane_not_found",
+        `Lane not found: ${input.lane_id}`
       );
-      const lastReadLine = offset + raw.length;
-      const hasMoreLines = lines.length > lastReadLine;
-      const truncated = truncatedByBytes || hasMoreLines;
-      let output = numbered.join("\n");
-      if (truncated) {
-        const reason = truncatedByBytes ? `Output truncated at ${MAX_BYTES} bytes.` : "File has more lines.";
-        output += `
-
-${reason} Use offset to read beyond line ${lastReadLine}.`;
+    }
+    if (lane.state === "closed") {
+      return lane;
+    }
+    const force = input.force === true;
+    const removeWorktree = input.remove_worktree !== false;
+    const status = await this.status(lane.lane_id);
+    const refreshed = status.lane;
+    if (status.backend_alive && !force) {
+      throw new LaneManagerError(
+        "lane_running",
+        `Lane is still running: ${lane.lane_id}`
+      );
+    }
+    if (status.backend_alive && refreshed.mux_backend === "tmux") {
+      await this.stopTmuxLane(refreshed.mux_target);
+    }
+    if (removeWorktree) {
+      const dirty = await this.isWorktreeDirty(refreshed.worktree_path);
+      if (dirty && !force) {
+        throw new LaneManagerError(
+          "worktree_dirty",
+          `Worktree has uncommitted changes: ${refreshed.worktree_path}`
+        );
       }
-      return output;
-    } catch (error) {
-      return `Error reading file: ${String(error)}`;
+      await this.removeWorktree(refreshed.worktree_path, force);
+    }
+    const closed = await this.registry.patch(refreshed.lane_id, {
+      state: "closed",
+      last_activity_at: this.now()
+    });
+    if (!closed) {
+      throw new LaneManagerError(
+        "backend_command_failed",
+        "Failed to persist lane close state."
+      );
     }
+    return closed;
   }
-});
-
-// src/tools/skill-load.ts
-var import_core10 = require("@codelia/core");
-var import_zod9 = require("zod");
-var SkillLoadInputSchema = import_zod9.z.object({
-  name: import_zod9.z.string().min(1).optional().describe("Exact skill name to load."),
-  path: import_zod9.z.string().min(1).optional().describe("Absolute or workspace-relative path to SKILL.md.")
-}).refine((value) => !!value.name || !!value.path, {
-  message: "name or path is required",
-  path: ["name"]
-});
-var createSkillLoadTool = (skillsResolverKey) => (0, import_core10.defineTool)({
-  name: "skill_load",
-  description: "Load full SKILL.md content by exact name or path.",
+  async gc(input) {
+    const ttlMs = Math.max(1, input.idle_ttl_minutes) * 6e4;
+    const now = Date.now();
+    const lanes = await this.registry.list();
+    let closed = 0;
+    let skipped = 0;
+    const errors = [];
+    for (const lane of lanes) {
+      try {
+        const status = await this.status(lane.lane_id);
+        const current = status.lane;
+        if (current.state === "running" || current.state === "closed") {
+          skipped += 1;
+          continue;
+        }
+        if (current.state !== "finished" && current.state !== "error") {
+          skipped += 1;
+          continue;
+        }
+        const idleSince = parseDate(current.last_activity_at) || parseDate(current.updated_at);
+        if (idleSince <= 0 || now - idleSince < ttlMs) {
+          skipped += 1;
+          continue;
+        }
+        await this.close({
+          lane_id: current.lane_id,
+          remove_worktree: input.remove_worktree,
+          force: input.force
+        });
+        closed += 1;
+      } catch (error) {
+        errors.push(`${lane.lane_id}: ${String(error)}`);
+      }
+    }
+    return {
+      checked: lanes.length,
+      closed,
+      skipped,
+      errors
+    };
+  }
+};
+
+// src/tools/lane.ts
+var laneManager = new LaneManager();
+var backendSchema = import_zod8.z.enum(["tmux", "zellij"]);
+var formatError = (error) => {
+  if (error instanceof LaneManagerError) {
+    return new Error(`${error.code}: ${error.message}`);
+  }
+  if (error instanceof Error) return error;
+  return new Error(String(error));
+};
+var shQuote = (value) => {
+  if (!value) return "''";
+  return `'${value.replaceAll("'", "'\\''")}'`;
+};
+var buildLaneHints = (lane) => {
+  const attachCommand = lane.mux_backend === "tmux" ? `tmux attach -t ${shQuote(lane.mux_target)}` : lane.mux_backend === "zellij" ? `zellij attach ${shQuote(lane.mux_target)}` : null;
+  return {
+    attach_command: attachCommand,
+    enter_worktree_command: `cd ${shQuote(lane.worktree_path)}`,
+    status_tool: {
+      name: "lane_status",
+      args: { lane_id: lane.lane_id }
+    },
+    close_tool: {
+      name: "lane_close",
+      args: { lane_id: lane.lane_id }
+    }
+  };
+};
+var createLaneCreateTool = (sandboxKey) => (0, import_core9.defineTool)({
+  name: "lane_create",
+  description: "Create a Task lane (worktree slot) and start autonomous execution in tmux/zellij.",
+  input: import_zod8.z.object({
+    task_id: import_zod8.z.string().describe("Task identifier."),
+    base_ref: import_zod8.z.string().optional().describe("Base git ref. Default: HEAD."),
+    worktree_path: import_zod8.z.string().optional().describe(
+      "Optional worktree path override. Default: ~/.codelia/worktrees/<task-slug>-<lane-id8>."
+    ),
+    mux_backend: backendSchema.optional().describe("Multiplexer backend. Default: tmux."),
+    seed_context: import_zod8.z.string().optional().describe("Optional initial text context.")
+  }),
+  execute: async (input, ctx) => {
+    const sandbox = await getSandboxContext(ctx, sandboxKey);
+    try {
+      const lane = await laneManager.create(
+        {
+          task_id: input.task_id,
+          base_ref: input.base_ref,
+          worktree_path: input.worktree_path,
+          mux_backend: input.mux_backend,
+          seed_context: input.seed_context
+        },
+        { workingDir: sandbox.workingDir }
+      );
+      return {
+        ok: true,
+        lane,
+        hints: buildLaneHints(lane)
+      };
+    } catch (error) {
+      throw formatError(error);
+    }
+  }
+});
+var createLaneListTool = (sandboxKey) => (0, import_core9.defineTool)({
+  name: "lane_list",
+  description: "List Task lanes (worktree slots) and current states.",
+  input: import_zod8.z.object({
+    include_closed: import_zod8.z.boolean().optional().describe("Include closed lanes. Default: false.")
+  }),
+  execute: async (input, ctx) => {
+    await getSandboxContext(ctx, sandboxKey);
+    try {
+      const lanes = await laneManager.list({
+        include_closed: input.include_closed
+      });
+      return {
+        lanes,
+        hints: lanes.map((lane) => ({
+          lane_id: lane.lane_id,
+          ...buildLaneHints(lane)
+        }))
+      };
+    } catch (error) {
+      throw formatError(error);
+    }
+  }
+});
+var createLaneStatusTool = (sandboxKey) => (0, import_core9.defineTool)({
+  name: "lane_status",
+  description: "Get Task lane status and backend liveness.",
+  input: import_zod8.z.object({
+    lane_id: import_zod8.z.string().describe("Lane id.")
+  }),
+  execute: async (input, ctx) => {
+    await getSandboxContext(ctx, sandboxKey);
+    try {
+      const result = await laneManager.status(input.lane_id);
+      return {
+        ...result,
+        hints: buildLaneHints(result.lane)
+      };
+    } catch (error) {
+      throw formatError(error);
+    }
+  }
+});
+var createLaneCloseTool = (sandboxKey) => (0, import_core9.defineTool)({
+  name: "lane_close",
+  description: "Close a Task lane and optionally remove its worktree.",
+  input: import_zod8.z.object({
+    lane_id: import_zod8.z.string().describe("Lane id."),
+    remove_worktree: import_zod8.z.boolean().optional().describe("Remove worktree. Default: true."),
+    force: import_zod8.z.boolean().optional().describe("Force close/cleanup. Default: false.")
+  }),
+  execute: async (input, ctx) => {
+    await getSandboxContext(ctx, sandboxKey);
+    try {
+      const lane = await laneManager.close({
+        lane_id: input.lane_id,
+        remove_worktree: input.remove_worktree,
+        force: input.force
+      });
+      return {
+        ok: true,
+        lane
+      };
+    } catch (error) {
+      throw formatError(error);
+    }
+  }
+});
+var createLaneGcTool = (sandboxKey) => (0, import_core9.defineTool)({
+  name: "lane_gc",
+  description: "Close stale finished/error lanes after idle TTL.",
+  input: import_zod8.z.object({
+    idle_ttl_minutes: import_zod8.z.number().int().positive().describe("Idle TTL in minutes."),
+    remove_worktree: import_zod8.z.boolean().optional().describe("Remove worktree on close. Default: false."),
+    force: import_zod8.z.boolean().optional().describe("Force cleanup for dirty worktrees. Default: false.")
+  }),
+  execute: async (input, ctx) => {
+    await getSandboxContext(ctx, sandboxKey);
+    try {
+      return await laneManager.gc({
+        idle_ttl_minutes: input.idle_ttl_minutes,
+        remove_worktree: input.remove_worktree,
+        force: input.force
+      });
+    } catch (error) {
+      throw formatError(error);
+    }
+  }
+});
+
+// src/tools/read.ts
+var import_node_fs12 = require("fs");
+var import_core10 = require("@codelia/core");
+var import_zod9 = require("zod");
+var DEFAULT_READ_LIMIT = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var MAX_BYTES = 50 * 1024;
+var createReadTool = (sandboxKey) => (0, import_core10.defineTool)({
+  name: "read",
+  description: "Read a text file with optional 0-based line offset and line limit.",
+  input: import_zod9.z.object({
+    file_path: import_zod9.z.string().describe("File path under the sandbox root."),
+    offset: import_zod9.z.number().int().nonnegative().optional().describe("0-based start line. Default 0."),
+    limit: import_zod9.z.number().int().positive().optional().describe("Max lines to read. Default 2000.")
+  }),
+  execute: async (input, ctx) => {
+    let resolved;
+    try {
+      const sandbox = await getSandboxContext(ctx, sandboxKey);
+      resolved = sandbox.resolvePath(input.file_path);
+    } catch (error) {
+      return `Security error: ${String(error)}`;
+    }
+    try {
+      const stat = await import_node_fs12.promises.stat(resolved);
+      if (stat.isDirectory()) {
+        return `Path is a directory: ${input.file_path}`;
+      }
+    } catch {
+      return `File not found: ${input.file_path}`;
+    }
+    try {
+      const content = await import_node_fs12.promises.readFile(resolved, "utf8");
+      const lines = content.split(/\r?\n/);
+      if (lines.length === 0) {
+        return "";
+      }
+      const offset = input.offset ?? 0;
+      const limit = input.limit ?? DEFAULT_READ_LIMIT;
+      if (offset >= lines.length) {
+        return `Offset exceeds file length: ${input.file_path}`;
+      }
+      const raw = [];
+      let bytes = 0;
+      let truncatedByBytes = false;
+      for (let index = offset; index < Math.min(lines.length, offset + limit); index += 1) {
+        const line = lines[index].length > MAX_LINE_LENGTH ? `${lines[index].slice(0, MAX_LINE_LENGTH)}...` : lines[index];
+        const size = Buffer.byteLength(line, "utf8") + (raw.length > 0 ? 1 : 0);
+        if (bytes + size > MAX_BYTES) {
+          truncatedByBytes = true;
+          break;
+        }
+        raw.push(line);
+        bytes += size;
+      }
+      const numbered = raw.map(
+        (line, index) => `${String(index + offset + 1).padStart(5, " ")}  ${line}`
+      );
+      const lastReadLine = offset + raw.length;
+      const hasMoreLines = lines.length > lastReadLine;
+      const truncated = truncatedByBytes || hasMoreLines;
+      let output = numbered.join("\n");
+      if (truncated) {
+        const reason = truncatedByBytes ? `Output truncated at ${MAX_BYTES} bytes.` : "File has more lines.";
+        output += `
+
+${reason} Use offset to read beyond line ${lastReadLine}.`;
+      }
+      return output;
+    } catch (error) {
+      return `Error reading file: ${String(error)}`;
+    }
+  }
+});
+
+// src/tools/skill-load.ts
+var import_core11 = require("@codelia/core");
+var import_zod10 = require("zod");
+var SkillLoadInputSchema = import_zod10.z.object({
+  name: import_zod10.z.string().min(1).optional().describe("Exact skill name to load."),
+  path: import_zod10.z.string().min(1).optional().describe("Absolute or workspace-relative path to SKILL.md.")
+}).refine((value) => !!value.name || !!value.path, {
+  message: "name or path is required",
+  path: ["name"]
+});
+var createSkillLoadTool = (skillsResolverKey) => (0, import_core11.defineTool)({
+  name: "skill_load",
+  description: "Load full SKILL.md content by exact name or path.",
   input: SkillLoadInputSchema,
   execute: async (input, ctx) => {
     try {
@@ -3435,15 +4262,15 @@ var createSkillLoadTool = (skillsResolverKey) => (0, import_core10.defineTool)({
 });
 
 // src/tools/skill-search.ts
-var import_core11 = require("@codelia/core");
-var import_zod10 = require("zod");
-var createSkillSearchTool = (skillsResolverKey) => (0, import_core11.defineTool)({
+var import_core12 = require("@codelia/core");
+var import_zod11 = require("zod");
+var createSkillSearchTool = (skillsResolverKey) => (0, import_core12.defineTool)({
   name: "skill_search",
   description: "Search installed local skills by name, description, or path.",
-  input: import_zod10.z.object({
-    query: import_zod10.z.string().min(1).describe("Search query text."),
-    limit: import_zod10.z.number().int().positive().optional().describe("Optional max result count (clamped by config)."),
-    scope: import_zod10.z.enum(["repo", "user"]).optional().describe("Optional scope filter.")
+  input: import_zod11.z.object({
+    query: import_zod11.z.string().min(1).describe("Search query text."),
+    limit: import_zod11.z.number().int().positive().optional().describe("Optional max result count (clamped by config)."),
+    scope: import_zod11.z.enum(["repo", "user"]).optional().describe("Optional scope filter.")
   }),
   execute: async (input, ctx) => {
     try {
@@ -3466,17 +4293,17 @@ var createSkillSearchTool = (skillsResolverKey) => (0, import_core11.defineTool)
 });
 
 // src/tools/todo-read.ts
-var import_core12 = require("@codelia/core");
-var import_zod11 = require("zod");
+var import_core13 = require("@codelia/core");
+var import_zod12 = require("zod");
 
 // src/tools/todo-store.ts
 var todoStore = /* @__PURE__ */ new Map();
 
 // src/tools/todo-read.ts
-var createTodoReadTool = (sandboxKey) => (0, import_core12.defineTool)({
+var createTodoReadTool = (sandboxKey) => (0, import_core13.defineTool)({
   name: "todo_read",
   description: "Read the in-session todo list.",
-  input: import_zod11.z.object({}),
+  input: import_zod12.z.object({}),
   execute: async (_input, ctx) => {
     const sandbox = await getSandboxContext(ctx, sandboxKey);
     const todos = todoStore.get(sandbox.sessionId) ?? [];
@@ -3489,17 +4316,17 @@ var createTodoReadTool = (sandboxKey) => (0, import_core12.defineTool)({
 });
 
 // src/tools/todo-write.ts
-var import_core13 = require("@codelia/core");
-var import_zod12 = require("zod");
-var createTodoWriteTool = (sandboxKey) => (0, import_core13.defineTool)({
+var import_core14 = require("@codelia/core");
+var import_zod13 = require("zod");
+var createTodoWriteTool = (sandboxKey) => (0, import_core14.defineTool)({
   name: "todo_write",
   description: "Replace the in-session todo list.",
-  input: import_zod12.z.object({
-    todos: import_zod12.z.array(
-      import_zod12.z.object({
-        content: import_zod12.z.string().describe("Todo item text."),
-        status: import_zod12.z.enum(["pending", "in_progress", "completed"]).describe("Todo status."),
-        activeForm: import_zod12.z.string().optional().describe("Optional in-progress phrasing for UI display.")
+  input: import_zod13.z.object({
+    todos: import_zod13.z.array(
+      import_zod13.z.object({
+        content: import_zod13.z.string().describe("Todo item text."),
+        status: import_zod13.z.enum(["pending", "in_progress", "completed"]).describe("Todo status."),
+        activeForm: import_zod13.z.string().optional().describe("Optional in-progress phrasing for UI display.")
       })
     )
   }),
@@ -3516,15 +4343,15 @@ var createTodoWriteTool = (sandboxKey) => (0, import_core13.defineTool)({
 });
 
 // src/tools/tool-output-cache.ts
-var import_core14 = require("@codelia/core");
-var import_zod13 = require("zod");
-var createToolOutputCacheTool = (store) => (0, import_core14.defineTool)({
+var import_core15 = require("@codelia/core");
+var import_zod14 = require("zod");
+var createToolOutputCacheTool = (store) => (0, import_core15.defineTool)({
   name: "tool_output_cache",
   description: "Read cached tool output by ref_id.",
-  input: import_zod13.z.object({
-    ref_id: import_zod13.z.string().describe("Tool output reference ID."),
-    offset: import_zod13.z.number().int().nonnegative().optional().describe("Optional 0-based line offset."),
-    limit: import_zod13.z.number().int().positive().optional().describe("Optional max number of lines to return.")
+  input: import_zod14.z.object({
+    ref_id: import_zod14.z.string().describe("Tool output reference ID."),
+    offset: import_zod14.z.number().int().nonnegative().optional().describe("Optional 0-based line offset."),
+    limit: import_zod14.z.number().int().positive().optional().describe("Optional max number of lines to return.")
   }),
   execute: async (input) => {
     if (!store.read) {
@@ -3540,16 +4367,16 @@ var createToolOutputCacheTool = (store) => (0, import_core14.defineTool)({
     }
   }
 });
-var createToolOutputCacheGrepTool = (store) => (0, import_core14.defineTool)({
+var createToolOutputCacheGrepTool = (store) => (0, import_core15.defineTool)({
   name: "tool_output_cache_grep",
   description: "Search cached tool output by ref_id.",
-  input: import_zod13.z.object({
-    ref_id: import_zod13.z.string().describe("Tool output reference ID."),
-    pattern: import_zod13.z.string().describe("Text or regex pattern to search for."),
-    regex: import_zod13.z.boolean().optional().describe("Interpret pattern as regex when true. Default false."),
-    before: import_zod13.z.number().int().nonnegative().optional().describe("Context lines before each match. Default 0."),
-    after: import_zod13.z.number().int().nonnegative().optional().describe("Context lines after each match. Default 0."),
-    max_matches: import_zod13.z.number().int().positive().optional().describe("Maximum number of matches to return.")
+  input: import_zod14.z.object({
+    ref_id: import_zod14.z.string().describe("Tool output reference ID."),
+    pattern: import_zod14.z.string().describe("Text or regex pattern to search for."),
+    regex: import_zod14.z.boolean().optional().describe("Interpret pattern as regex when true. Default false."),
+    before: import_zod14.z.number().int().nonnegative().optional().describe("Context lines before each match. Default 0."),
+    after: import_zod14.z.number().int().nonnegative().optional().describe("Context lines after each match. Default 0."),
+    max_matches: import_zod14.z.number().int().positive().optional().describe("Maximum number of matches to return.")
   }),
   execute: async (input) => {
     if (!store.grep) {
@@ -3570,16 +4397,16 @@ var createToolOutputCacheGrepTool = (store) => (0, import_core14.defineTool)({
 });
 
 // src/tools/write.ts
-var import_node_fs11 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
-var import_core15 = require("@codelia/core");
-var import_zod14 = require("zod");
-var createWriteTool = (sandboxKey) => (0, import_core15.defineTool)({
+var import_node_fs13 = require("fs");
+var import_node_path12 = __toESM(require("path"), 1);
+var import_core16 = require("@codelia/core");
+var import_zod15 = require("zod");
+var createWriteTool = (sandboxKey) => (0, import_core16.defineTool)({
   name: "write",
   description: "Write text to a file, creating parent directories if needed.",
-  input: import_zod14.z.object({
-    file_path: import_zod14.z.string().describe("File path under the sandbox root."),
-    content: import_zod14.z.string().describe("UTF-8 text content to write.")
+  input: import_zod15.z.object({
+    file_path: import_zod15.z.string().describe("File path under the sandbox root."),
+    content: import_zod15.z.string().describe("UTF-8 text content to write.")
   }),
   execute: async (input, ctx) => {
     let resolved;
@@ -3590,8 +4417,8 @@ var createWriteTool = (sandboxKey) => (0, import_core15.defineTool)({
       return `Security error: ${String(error)}`;
     }
     try {
-      await import_node_fs11.promises.mkdir(import_node_path10.default.dirname(resolved), { recursive: true });
-      await import_node_fs11.promises.writeFile(resolved, input.content, "utf8");
+      await import_node_fs13.promises.mkdir(import_node_path12.default.dirname(resolved), { recursive: true });
+      await import_node_fs13.promises.writeFile(resolved, input.content, "utf8");
       return `Wrote ${input.content.length} bytes to ${input.file_path}`;
     } catch (error) {
       return `Error writing file: ${String(error)}`;
@@ -3616,9 +4443,106 @@ var createTools = (sandboxKey, agentsResolverKey, skillsResolverKey, options = {
   ] : [],
   createTodoReadTool(sandboxKey),
   createTodoWriteTool(sandboxKey),
+  createLaneCreateTool(sandboxKey),
+  createLaneListTool(sandboxKey),
+  createLaneStatusTool(sandboxKey),
+  createLaneCloseTool(sandboxKey),
+  createLaneGcTool(sandboxKey),
   createDoneTool()
 ];
 
+// src/utils/language.ts
+var normalizeLanguage = (value) => {
+  const token = value.trim().toLowerCase();
+  if (!token) return "";
+  switch (token) {
+    case "yml":
+      return "yaml";
+    case "mjs":
+    case "cjs":
+    case "node":
+      return "javascript";
+    case "mts":
+    case "cts":
+    case "ts-node":
+    case "deno":
+      return "typescript";
+    case "py":
+    case "python3":
+      return "python";
+    case "rb":
+      return "ruby";
+    case "zsh":
+    case "sh":
+      return "bash";
+    case "ps1":
+      return "powershell";
+    default:
+      return token;
+  }
+};
+var languageFromFilePath = (filePath) => {
+  if (!filePath) return void 0;
+  const path16 = filePath.trim().replace(/^["']|["']$/g, "");
+  if (!path16 || path16 === "/dev/null") return void 0;
+  const normalizedPath = path16.replace(/^a\//, "").replace(/^b\//, "");
+  const lastSlash = Math.max(
+    normalizedPath.lastIndexOf("/"),
+    normalizedPath.lastIndexOf("\\")
+  );
+  const basename = lastSlash >= 0 ? normalizedPath.slice(lastSlash + 1) : normalizedPath;
+  if (!basename) return void 0;
+  const dotIndex = basename.lastIndexOf(".");
+  if (dotIndex > 0 && dotIndex < basename.length - 1) {
+    return normalizeLanguage(basename.slice(dotIndex + 1));
+  }
+  if (basename === "Dockerfile") return "dockerfile";
+  if (/^Makefile(\..+)?$/i.test(basename)) return "makefile";
+  return void 0;
+};
+var languageFromDiffHeaders = (diff) => {
+  if (!diff) return void 0;
+  for (const line of diff.split("\n")) {
+    if (!line.startsWith("--- ") && !line.startsWith("+++ ")) continue;
+    const rawPath = line.slice(4).trim().split(/\s+/)[0] ?? "";
+    const language = languageFromFilePath(rawPath);
+    if (language) return language;
+  }
+  return void 0;
+};
+var languageFromShebang = (content) => {
+  if (!content) return void 0;
+  const firstLine = content.split("\n", 1)[0]?.trim() ?? "";
+  if (!firstLine.startsWith("#!")) return void 0;
+  const body = firstLine.slice(2).trim();
+  if (!body) return void 0;
+  const parts = body.split(/\s+/).filter(Boolean);
+  if (!parts.length) return void 0;
+  let command = parts[0];
+  if (command.endsWith("/env")) {
+    let index = 1;
+    if (parts[index] === "-S") index += 1;
+    while (index < parts.length && parts[index].includes("=")) {
+      index += 1;
+    }
+    command = parts[index] ?? "";
+  }
+  if (!command) return void 0;
+  const last = command.split("/").pop() ?? command;
+  const simplified = last.replace(/[0-9.]+$/g, "");
+  const normalized = normalizeLanguage(simplified);
+  return normalized || void 0;
+};
+var resolvePreviewLanguageHint = (input) => {
+  const explicit = input.language ? normalizeLanguage(input.language) : "";
+  if (explicit) return explicit;
+  const shebang = languageFromShebang(input.content);
+  if (shebang) return shebang;
+  const fromDiff = languageFromDiffHeaders(input.diff);
+  if (fromDiff) return fromDiff;
+  return languageFromFilePath(input.filePath);
+};
+
 // src/agent-factory.ts
 var requireApiKeyAuth = (provider, auth) => {
   if (auth.method !== "api_key") {
@@ -3631,6 +4555,7 @@ var envTruthy = (value) => {
   const normalized = value.trim().toLowerCase();
   return normalized === "1" || normalized === "true";
 };
+var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
 var buildOpenAiClientOptions = (authResolver, auth) => {
   if (auth.method === "api_key") {
     return { apiKey: auth.api_key };
@@ -3674,6 +4599,22 @@ var buildOpenAiClientOptions = (authResolver, auth) => {
     fetch: fetchWithAccount
   };
 };
+var buildOpenRouterClientOptions = (auth) => {
+  const headers = {};
+  const referer = readEnvValue("OPENROUTER_HTTP_REFERER");
+  if (referer) {
+    headers["HTTP-Referer"] = referer;
+  }
+  const title = readEnvValue("OPENROUTER_X_TITLE");
+  if (title) {
+    headers["X-Title"] = title;
+  }
+  return {
+    apiKey: requireApiKeyAuth("OpenRouter", auth),
+    baseURL: OPENROUTER_BASE_URL,
+    ...Object.keys(headers).length ? { defaultHeaders: headers } : {}
+  };
+};
 var sleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
@@ -3687,6 +4628,41 @@ var waitForUiConfirmSupport = async (state, timeoutMs = 5e3) => {
   }
   return !!state.uiCapabilities?.supports_confirm;
 };
+var MAX_CONFIRM_PREVIEW_LINES = 120;
+var splitLines = (value) => value.split("\n").map((line) => line.replace(/\r$/, ""));
+var buildBoundedDiffPreview = (diff, maxLines = MAX_CONFIRM_PREVIEW_LINES) => {
+  if (!diff.trim()) return { diff: null, truncated: false };
+  const lines = splitLines(diff);
+  if (!lines.length) return { diff: null, truncated: false };
+  if (lines.length <= maxLines) {
+    return { diff: lines.join("\n"), truncated: false };
+  }
+  return {
+    diff: lines.slice(0, maxLines).join("\n"),
+    truncated: true
+  };
+};
+var parseToolArgsObject = (rawArgs) => {
+  try {
+    const parsed = JSON.parse(rawArgs);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var unwrapToolJsonObject = (result) => {
+  if (!result || typeof result !== "object") return null;
+  const typed = result;
+  if (typed.type !== "json") return null;
+  const value = typed.value;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+};
 var requestMcpOAuthTokens = async (state, serverId, oauth2, errorMessage) => {
   const canConfirm = state.uiCapabilities?.supports_confirm ? true : await waitForUiConfirmSupport(state);
   if (!canConfirm) {
@@ -3815,7 +4791,7 @@ var createAgentFactory = (state, options = {}) => {
       const sandboxKey = createSandboxKey(ctx);
       const agentsResolverKey = createAgentsResolverKey(agentsResolver);
       const skillsResolverKey = createSkillsResolverKey(skillsResolver);
-      const toolOutputCacheStore = new import_storage4.ToolOutputCacheStoreImpl();
+      const toolOutputCacheStore = new import_storage5.ToolOutputCacheStoreImpl();
       const localTools = createTools(
         sandboxKey,
         agentsResolverKey,
@@ -3824,6 +4800,9 @@ var createAgentFactory = (state, options = {}) => {
           toolOutputCacheStore
         }
       );
+      const editTool = localTools.find(
+        (tool) => tool.definition.name === "edit"
+      );
       let mcpTools = [];
       if (options.mcpManager) {
         try {
@@ -3845,6 +4824,7 @@ var createAgentFactory = (state, options = {}) => {
         }
       }
       const tools = [...localTools, ...mcpTools];
+      state.tools = tools;
       state.toolDefinitions = tools.map((tool) => tool.definition);
       const baseSystemPrompt = await loadSystemPrompt(ctx.workingDir);
       const withAgentsContext = appendInitialAgentsContext(
@@ -3886,7 +4866,7 @@ var createAgentFactory = (state, options = {}) => {
         case "openai": {
           const reasoningEffort = resolveReasoningEffort(modelConfig.reasoning);
           const textVerbosity = resolveTextVerbosity(modelConfig.verbosity);
-          llm = new import_core16.ChatOpenAI({
+          llm = new import_core17.ChatOpenAI({
             clientOptions: buildOpenAiClientOptions(authResolver, providerAuth),
             ...modelConfig.name ? { model: modelConfig.name } : {},
             ...reasoningEffort ? { reasoningEffort } : {},
@@ -3894,8 +4874,19 @@ var createAgentFactory = (state, options = {}) => {
           });
           break;
         }
+        case "openrouter": {
+          const reasoningEffort = resolveReasoningEffort(modelConfig.reasoning);
+          const textVerbosity = resolveTextVerbosity(modelConfig.verbosity);
+          llm = new import_core17.ChatOpenAI({
+            clientOptions: buildOpenRouterClientOptions(providerAuth),
+            ...modelConfig.name ? { model: modelConfig.name } : {},
+            ...reasoningEffort ? { reasoningEffort } : {},
+            ...textVerbosity ? { textVerbosity } : {}
+          });
+          break;
+        }
         case "anthropic": {
-          llm = new import_core16.ChatAnthropic({
+          llm = new import_core17.ChatAnthropic({
             clientOptions: {
               apiKey: requireApiKeyAuth("Anthropic", providerAuth)
             },
@@ -3906,14 +4897,16 @@ var createAgentFactory = (state, options = {}) => {
         default:
           throw new Error(`Unsupported model.provider: ${provider}`);
       }
-      const modelRegistry = await buildModelRegistry(llm);
-      const agent = new import_core16.Agent({
+      const modelRegistry = await buildModelRegistry(llm, {
+        strict: provider !== "openrouter"
+      });
+      const agent = new import_core17.Agent({
         llm,
         tools,
         systemPrompt,
-        modelRegistry: modelRegistry ?? import_core16.DEFAULT_MODEL_REGISTRY,
+        modelRegistry: modelRegistry ?? import_core17.DEFAULT_MODEL_REGISTRY,
         services: { toolOutputCacheStore },
-        canExecuteTool: async (call, rawArgs) => {
+        canExecuteTool: async (call, rawArgs, toolCtx) => {
           const decision = permissionService.evaluate(
             call.function.name,
             rawArgs
@@ -3935,12 +4928,129 @@ var createAgentFactory = (state, options = {}) => {
             };
           }
           const runId = state.activeRunId ?? void 0;
+          (0, import_logger.debugLog)(
+            `permission.request tool=${call.function.name} args=${rawArgs}`
+          );
           const prompt = permissionService.getConfirmPrompt(
             call.function.name,
             rawArgs
           );
+          let previewDiff = null;
+          let previewSummary = null;
+          let previewTruncated = false;
+          let previewFilePath = null;
+          let previewLanguage = null;
+          if (call.function.name === "write") {
+            const parsed = parseToolArgsObject(rawArgs);
+            const filePath = typeof parsed?.file_path === "string" ? parsed.file_path : "";
+            const content = typeof parsed?.content === "string" ? parsed.content : "";
+            const language = typeof parsed?.language === "string" ? parsed.language : "";
+            if (filePath) {
+              previewFilePath = filePath;
+              previewLanguage = resolvePreviewLanguageHint({
+                language,
+                filePath,
+                content
+              }) ?? previewLanguage;
+              try {
+                const sandbox = await getSandboxContext(toolCtx, sandboxKey);
+                const resolved = sandbox.resolvePath(filePath);
+                let before = "";
+                try {
+                  const stat = await import_node_fs14.promises.stat(resolved);
+                  if (!stat.isDirectory()) {
+                    before = await import_node_fs14.promises.readFile(resolved, "utf8");
+                  }
+                } catch {
+                  before = "";
+                }
+                const preview = buildBoundedDiffPreview(
+                  createUnifiedDiff(filePath, before, content)
+                );
+                previewDiff = preview.diff;
+                previewTruncated = preview.truncated;
+              } catch {
+                previewDiff = null;
+                previewSummary = null;
+                previewTruncated = false;
+              }
+            }
+          } else if (call.function.name === "edit" && editTool) {
+            const parsed = parseToolArgsObject(rawArgs);
+            if (parsed) {
+              const filePath = typeof parsed.file_path === "string" ? parsed.file_path : "";
+              const language = typeof parsed.language === "string" ? parsed.language : "";
+              if (filePath) {
+                previewFilePath = filePath;
+              }
+              previewLanguage = resolvePreviewLanguageHint({
+                language,
+                filePath
+              }) ?? previewLanguage;
+              const dryRunInput = { ...parsed, dry_run: true };
+              try {
+                const result = await editTool.executeRaw(
+                  JSON.stringify(dryRunInput),
+                  toolCtx
+                );
+                if (result && typeof result === "object") {
+                  const obj = unwrapToolJsonObject(result);
+                  if (!obj) {
+                    previewSummary = "Preview unavailable: unexpected dry-run output";
+                  } else {
+                    const resultFilePath = typeof obj.file_path === "string" ? obj.file_path : "";
+                    const resultLanguage = typeof obj.language === "string" ? obj.language : "";
+                    if (!previewFilePath && resultFilePath) {
+                      previewFilePath = resultFilePath;
+                    }
+                    const diff = typeof obj.diff === "string" ? obj.diff : "";
+                    const summary = typeof obj.summary === "string" ? obj.summary : "";
+                    previewLanguage = resolvePreviewLanguageHint({
+                      language: resultLanguage || previewLanguage,
+                      filePath: previewFilePath || resultFilePath,
+                      diff
+                    }) ?? previewLanguage;
+                    const preview = buildBoundedDiffPreview(diff);
+                    previewDiff = preview.diff;
+                    previewTruncated = preview.truncated;
+                    if (!previewDiff) {
+                      previewSummary = summary || "Preview: no diff content";
+                    }
+                  }
+                }
+              } catch {
+                previewSummary = "Preview unavailable: dry-run failed";
+              }
+            }
+          }
           if (runId) {
-            sendRunStatus(runId, "awaiting_ui", "waiting for confirmation");
+            if (previewDiff || previewSummary) {
+              previewLanguage = resolvePreviewLanguageHint({
+                language: previewLanguage,
+                filePath: previewFilePath,
+                diff: previewDiff
+              }) ?? previewLanguage;
+              await sendAgentEventAsync(state, runId, {
+                type: "permission.preview",
+                tool: call.function.name,
+                tool_call_id: call.id,
+                ...previewFilePath ? { file_path: previewFilePath } : {},
+                ...previewLanguage ? { language: previewLanguage } : {},
+                ...previewDiff ? { diff: previewDiff } : {},
+                ...previewSummary ? { summary: previewSummary } : {},
+                ...previewTruncated ? { truncated: true } : {}
+              });
+            }
+            await sendAgentEventAsync(state, runId, {
+              type: "permission.ready",
+              tool: call.function.name,
+              tool_call_id: call.id
+            });
+            await sendRunStatusAsync(
+              runId,
+              "awaiting_ui",
+              "waiting for confirmation"
+            );
           }
           const confirmResult = await requestUiConfirm(state, {
             run_id: runId,
@@ -3994,7 +5104,7 @@ var createAgentFactory = (state, options = {}) => {
 };
 
 // src/mcp/auth-store.ts
-var import_storage5 = require("@codelia/storage");
+var import_storage6 = require("@codelia/storage");
 
 // src/mcp/manager.ts
 var import_protocol = require("@codelia/protocol");
@@ -4277,7 +5387,7 @@ var HttpMcpClient = class {
 };
 
 // src/mcp/stdio-client.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_node_readline = require("readline");
 var StdioMcpClient = class {
   constructor(options) {
@@ -4286,7 +5396,7 @@ var StdioMcpClient = class {
       ...process.env,
       ...options.env ?? {}
     };
-    this.child = (0, import_node_child_process3.spawn)(options.command, options.args, {
+    this.child = (0, import_node_child_process4.spawn)(options.command, options.args, {
       cwd: options.cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4496,8 +5606,8 @@ var parseAuthorizationServerMetadata = (value) => {
 var buildAuthorizationServerMetadataUrl = (issuer) => {
   try {
     const parsed = new URL(issuer);
-    const path14 = parsed.pathname === "/" ? "" : parsed.pathname;
-    const basePath = path14.startsWith("/") ? path14 : `/${path14}`;
+    const path16 = parsed.pathname === "/" ? "" : parsed.pathname;
+    const basePath = path16.startsWith("/") ? path16 : `/${path16}`;
     const metadataPath = `/.well-known/oauth-authorization-server${basePath}`;
     return new URL(metadataPath, `${parsed.origin}/`).toString();
   } catch {
@@ -4594,24 +5704,24 @@ var fetchDiscoveredOAuthConfig = async (serverUrl) => {
 };
 
 // src/mcp/tooling.ts
-var import_node_crypto4 = __toESM(require("crypto"), 1);
+var import_node_crypto5 = __toESM(require("crypto"), 1);
 var MAX_SCHEMA_SIZE_BYTES = 64 * 1024;
 var MAX_TOOL_OUTPUT_CHARS = 1e5;
 var MAX_TOOLS_LIST_PAGES = 100;
 var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isMcpToolDescriptor = (value) => isRecord4(value) && typeof value.name === "string";
-var toSlug = (value) => {
+var toSlug2 = (value) => {
   const slug = value.toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
   return slug || "tool";
 };
-var hash8 = (value) => import_node_crypto4.default.createHash("sha256").update(value).digest("hex").slice(0, 8);
+var hash8 = (value) => import_node_crypto5.default.createHash("sha256").update(value).digest("hex").slice(0, 8);
 var clampToolName = (value) => {
   if (value.length <= 63) return value;
   return value.slice(0, 63);
 };
 var buildToolName = (serverId, toolName) => {
-  const serverSlug = toSlug(serverId);
-  const toolSlug = toSlug(toolName);
+  const serverSlug = toSlug2(serverId);
+  const toolSlug = toSlug2(toolName);
   const fingerprint = hash8(`${serverId}:${toolName}`);
   const maxPrefixLength = 63 - (fingerprint.length + 1);
   const prefix = `mcp_${serverSlug}_${toolSlug}`.slice(0, maxPrefixLength);
@@ -4769,7 +5879,7 @@ var createMcpToolAdapter = (params) => {
 
 // src/mcp/manager.ts
 var OAUTH_TOKEN_EXPIRY_SKEW_MS = 6e4;
-var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var nowIso3 = () => (/* @__PURE__ */ new Date()).toISOString();
 var describeError2 = (error) => error instanceof Error ? error.message : String(error);
 var toListServer = (id, runtime) => ({
   id,
@@ -4791,7 +5901,7 @@ var McpManager = class {
     this.options = options;
   }
   servers = /* @__PURE__ */ new Map();
-  authStore = new import_storage5.McpAuthStore();
+  authStore = new import_storage6.McpAuthStore();
   startPromise = null;
   authFile = { version: 1, servers: {} };
   discoveredOAuth = /* @__PURE__ */ new Map();
@@ -4901,7 +6011,7 @@ var McpManager = class {
         runtime.tools_count = runtime.toolAdapters.length;
         runtime.state = "ready";
         runtime.last_error = void 0;
-        runtime.last_connected_at = nowIso();
+        runtime.last_connected_at = nowIso3();
         connectOptions?.onStatus?.(
           `MCP server ready: ${serverId} (${runtime.tools_count ?? 0} tools)`
         );
@@ -5154,7 +6264,9 @@ var McpManager = class {
 };
 
 // src/rpc/handlers.ts
-var import_storage7 = require("@codelia/storage");
+var import_config_loader3 = require("@codelia/config-loader");
+var import_protocol8 = require("@codelia/protocol");
+var import_storage8 = require("@codelia/storage");
 
 // src/constants.ts
 var SERVER_NAME = "codelia-runtime";
@@ -5162,6 +6274,7 @@ var SERVER_VERSION = "0.1.0";
 var PROTOCOL_VERSION = "0";
 
 // src/rpc/context.ts
+var import_protocol2 = require("@codelia/protocol");
 var createContextHandlers = ({
   state,
   log: log2
@@ -5251,7 +6364,7 @@ var createContextHandlers = ({
       sendResult(id, result);
     } catch (error) {
       sendError(id, {
-        code: -32e3,
+        code: import_protocol2.RPC_ERROR_CODE.RUNTIME_INTERNAL,
         message: `context.inspect failed: ${String(error)}`
       });
     }
@@ -5260,14 +6373,50 @@ var createContextHandlers = ({
 };
 
 // src/rpc/history.ts
-var import_node_fs12 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_node_path13 = __toESM(require("path"), 1);
 var import_node_readline2 = require("readline");
-var import_storage6 = require("@codelia/storage");
+var import_protocol3 = require("@codelia/protocol");
+var import_storage7 = require("@codelia/storage");
 var DEFAULT_HISTORY_RUNS = 20;
 var DEFAULT_HISTORY_EVENTS = 1500;
+var runStartInputToHiddenMessage = (input) => {
+  if (!input) {
+    return "";
+  }
+  if (input.type === "text") {
+    return input.text;
+  }
+  if (!Array.isArray(input.parts)) {
+    return "";
+  }
+  let message = "";
+  for (const part of input.parts) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    if (part.type === "text") {
+      message += part.text;
+      continue;
+    }
+    if (part.type === "image_url") {
+      message += "[image]";
+    }
+  }
+  return message;
+};
+var parseRunHeader = (headerLine) => {
+  try {
+    const header = JSON.parse(headerLine);
+    if (!header || typeof header !== "object") return null;
+    if (header.type !== "header") return null;
+    return header;
+  } catch {
+    return null;
+  }
+};
 var readFirstLine = async (filePath) => {
-  const stream = (0, import_node_fs12.createReadStream)(filePath, { encoding: "utf8" });
+  const stream = (0, import_node_fs15.createReadStream)(filePath, { encoding: "utf8" });
   const reader = (0, import_node_readline2.createInterface)({
     input: stream,
     crlfDelay: Number.POSITIVE_INFINITY
@@ -5282,12 +6431,12 @@ var readFirstLine = async (filePath) => {
     stream.destroy();
   }
 };
-var collectSessionRuns = async (sessionId, maxRuns, log2) => {
-  const paths = (0, import_storage6.resolveStoragePaths)();
+var collectRunCandidates = async (log2) => {
+  const paths = (0, import_storage7.resolveStoragePaths)();
   const sessionsDir = paths.sessionsDir;
   let yearEntries;
   try {
-    yearEntries = await import_node_fs12.promises.readdir(sessionsDir, {
+    yearEntries = await import_node_fs15.promises.readdir(sessionsDir, {
       withFileTypes: true,
       encoding: "utf8"
     });
@@ -5299,10 +6448,10 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
   for (const yearEntry of yearEntries) {
     if (!yearEntry.isDirectory()) continue;
     if (!/^\d{4}$/.test(yearEntry.name)) continue;
-    const yearPath = import_node_path11.default.join(sessionsDir, yearEntry.name);
+    const yearPath = import_node_path13.default.join(sessionsDir, yearEntry.name);
     let monthEntries;
     try {
-      monthEntries = await import_node_fs12.promises.readdir(yearPath, {
+      monthEntries = await import_node_fs15.promises.readdir(yearPath, {
         withFileTypes: true,
         encoding: "utf8"
       });
@@ -5312,10 +6461,10 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
     for (const monthEntry of monthEntries) {
       if (!monthEntry.isDirectory()) continue;
       if (!/^\d{2}$/.test(monthEntry.name)) continue;
-      const monthPath = import_node_path11.default.join(yearPath, monthEntry.name);
+      const monthPath = import_node_path13.default.join(yearPath, monthEntry.name);
       let dayEntries;
       try {
-        dayEntries = await import_node_fs12.promises.readdir(monthPath, {
+        dayEntries = await import_node_fs15.promises.readdir(monthPath, {
           withFileTypes: true,
           encoding: "utf8"
         });
@@ -5325,10 +6474,10 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
       for (const dayEntry of dayEntries) {
         if (!dayEntry.isDirectory()) continue;
         if (!/^\d{2}$/.test(dayEntry.name)) continue;
-        const dayPath = import_node_path11.default.join(monthPath, dayEntry.name);
+        const dayPath = import_node_path13.default.join(monthPath, dayEntry.name);
         let files;
         try {
-          files = await import_node_fs12.promises.readdir(dayPath, {
+          files = await import_node_fs15.promises.readdir(dayPath, {
             withFileTypes: true,
             encoding: "utf8"
           });
@@ -5338,9 +6487,9 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
         for (const file of files) {
           if (!file.isFile()) continue;
           if (!file.name.endsWith(".jsonl")) continue;
-          const filePath = import_node_path11.default.join(dayPath, file.name);
+          const filePath = import_node_path13.default.join(dayPath, file.name);
           try {
-            const stat = await import_node_fs12.promises.stat(filePath);
+            const stat = await import_node_fs15.promises.stat(filePath);
             candidates.push({ path: filePath, mtimeMs: stat.mtimeMs });
           } catch {
           }
@@ -5349,6 +6498,10 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
     }
   }
   candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return candidates;
+};
+var collectSessionRuns = async (sessionId, maxRuns, log2) => {
+  const candidates = await collectRunCandidates(log2);
   const runs = [];
   for (const candidate of candidates) {
     if (runs.length >= maxRuns) break;
@@ -5359,25 +6512,22 @@ var collectSessionRuns = async (sessionId, maxRuns, log2) => {
       continue;
     }
     if (!headerLine) continue;
-    try {
-      const header = JSON.parse(headerLine);
-      if (header.type !== "header") continue;
-      if (header.session_id !== sessionId) continue;
-      const runId = header.run_id ?? import_node_path11.default.basename(candidate.path, ".jsonl");
-      const startedAt = header.started_at ?? new Date(candidate.mtimeMs).toISOString();
-      runs.push({
-        path: candidate.path,
-        run_id: runId,
-        started_at: startedAt
-      });
-    } catch {
-    }
+    const header = parseRunHeader(headerLine);
+    if (!header) continue;
+    if (header.session_id !== sessionId) continue;
+    const runId = header.run_id ?? import_node_path13.default.basename(candidate.path, ".jsonl");
+    const startedAt = header.started_at ?? new Date(candidate.mtimeMs).toISOString();
+    runs.push({
+      path: candidate.path,
+      run_id: runId,
+      started_at: startedAt
+    });
   }
   runs.sort((a, b) => a.started_at.localeCompare(b.started_at));
   return runs;
 };
 var readJsonl = async function* (filePath) {
-  const stream = (0, import_node_fs12.createReadStream)(filePath, { encoding: "utf8" });
+  const stream = (0, import_node_fs15.createReadStream)(filePath, { encoding: "utf8" });
   let buffer = "";
   for await (const chunk of stream) {
     buffer += chunk;
@@ -5419,7 +6569,7 @@ var createHistoryHandlers = ({
       sessions = await sessionStateStore.list();
     } catch (error) {
       sendError(id, {
-        code: -32006,
+        code: import_protocol3.RPC_ERROR_CODE.SESSION_LIST_FAILED,
         message: `session list failed: ${String(error)}`
       });
       return;
@@ -5434,7 +6584,7 @@ var createHistoryHandlers = ({
   const handleSessionHistory = async (id, params) => {
     const sessionId = params?.session_id?.trim();
     if (!sessionId) {
-      sendError(id, { code: -32602, message: "session_id is required" });
+      sendError(id, { code: import_protocol3.RPC_ERROR_CODE.INVALID_PARAMS, message: "session_id is required" });
       return;
     }
     const maxRuns = Math.max(0, params?.max_runs ?? DEFAULT_HISTORY_RUNS);
@@ -5464,7 +6614,7 @@ var createHistoryHandlers = ({
         }
         if (!record || typeof record !== "object") continue;
         if (record.type === "run.start") {
-          const input = record.input?.type === "text" ? record.input.text : "";
+          const input = runStartInputToHiddenMessage(record.input);
           if (input) {
             sendHistoryEvent(record.run_id, -1, {
               type: "hidden_user_message",
@@ -5493,8 +6643,268 @@ var createHistoryHandlers = ({
 
 // src/rpc/model.ts
 var import_config_loader2 = require("@codelia/config-loader");
-var import_core17 = require("@codelia/core");
+var import_core18 = require("@codelia/core");
 var import_model_metadata2 = require("@codelia/model-metadata");
+var import_protocol4 = require("@codelia/protocol");
+var isSupportedProvider = (provider) => provider === "openai" || provider === "anthropic" || provider === "openrouter";
+var resolveProviderModelEntry = (providerEntries, provider, model) => {
+  if (!providerEntries) return null;
+  return providerEntries[model] ?? providerEntries[`${provider}/${model}`] ?? null;
+};
+var parseReleaseTimestamp = (entry) => {
+  const releaseDate = entry?.releaseDate?.trim();
+  if (!releaseDate) return null;
+  const timestamp = Date.parse(releaseDate);
+  if (Number.isNaN(timestamp)) return null;
+  return timestamp;
+};
+var normalizeUsdPer1M = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return void 0;
+  }
+  return value;
+};
+var buildModelListDetail = (entry) => {
+  if (!entry) return null;
+  const detail = {};
+  if (entry.releaseDate?.trim()) {
+    detail.release_date = entry.releaseDate.trim();
+  }
+  const limits = entry.limits;
+  if (typeof limits?.contextWindow === "number" && Number.isFinite(limits.contextWindow) && limits.contextWindow > 0) {
+    detail.context_window = limits.contextWindow;
+  }
+  if (typeof limits?.inputTokens === "number" && Number.isFinite(limits.inputTokens) && limits.inputTokens > 0) {
+    detail.max_input_tokens = limits.inputTokens;
+  }
+  if (typeof limits?.outputTokens === "number" && Number.isFinite(limits.outputTokens) && limits.outputTokens > 0) {
+    detail.max_output_tokens = limits.outputTokens;
+  }
+  const inputCost = normalizeUsdPer1M(entry.cost?.input);
+  if (inputCost !== void 0) {
+    detail.cost_per_1m_input_tokens_usd = inputCost;
+  }
+  const outputCost = normalizeUsdPer1M(entry.cost?.output);
+  if (outputCost !== void 0) {
+    detail.cost_per_1m_output_tokens_usd = outputCost;
+  }
+  return Object.keys(detail).length ? detail : null;
+};
+var sortModelsByReleaseDate = (models, provider, providerEntries) => {
+  const sortable = models.map((model, index) => ({
+    model,
+    index,
+    releaseTimestamp: parseReleaseTimestamp(
+      resolveProviderModelEntry(providerEntries, provider, model)
+    )
+  }));
+  sortable.sort((left, right) => {
+    if (left.releaseTimestamp !== null && right.releaseTimestamp !== null && left.releaseTimestamp !== right.releaseTimestamp) {
+      return right.releaseTimestamp - left.releaseTimestamp;
+    }
+    if (left.releaseTimestamp !== null && right.releaseTimestamp === null) {
+      return -1;
+    }
+    if (left.releaseTimestamp === null && right.releaseTimestamp !== null) {
+      return 1;
+    }
+    return left.index - right.index;
+  });
+  return sortable.map((item) => item.model);
+};
+var loadProviderModelEntries = async (provider) => {
+  const metadataService = new import_model_metadata2.ModelMetadataServiceImpl();
+  const allEntries = await metadataService.getAllModelEntries();
+  return allEntries[provider] ?? null;
+};
+var OPENROUTER_BASE_URL2 = "https://openrouter.ai/api/v1";
+var parseUnixSecondsToDate = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  const date = new Date(Math.floor(value) * 1e3);
+  const timestamp = date.getTime();
+  if (!Number.isFinite(timestamp)) {
+    return void 0;
+  }
+  return date.toISOString().slice(0, 10);
+};
+var parsePositiveNumber = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+};
+var buildOpenRouterHeaders = (apiKey) => {
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${apiKey}`);
+  const referer = readEnvValue("OPENROUTER_HTTP_REFERER");
+  if (referer) {
+    headers.set("HTTP-Referer", referer);
+  }
+  const title = readEnvValue("OPENROUTER_X_TITLE");
+  if (title) {
+    headers.set("X-Title", title);
+  }
+  return headers;
+};
+var resolveOpenRouterApiKey = async () => {
+  const envKey = readEnvValue("OPENROUTER_API_KEY");
+  if (envKey) {
+    return envKey;
+  }
+  const store = new AuthStore();
+  const auth = await store.load();
+  const providerAuth = auth.providers.openrouter;
+  if (providerAuth?.method !== "api_key") {
+    return null;
+  }
+  const value = providerAuth.api_key.trim();
+  return value ? value : null;
+};
+var resolveOpenRouterApiKeyWithPrompt = async ({
+  state,
+  log: log2
+}) => {
+  const existing = await resolveOpenRouterApiKey();
+  if (existing) {
+    return existing;
+  }
+  if (!state) {
+    throw new Error("OpenRouter API key is required");
+  }
+  const authResolver = await AuthResolver.create(state, log2);
+  const auth = await authResolver.resolveProviderAuth("openrouter");
+  if (auth.method !== "api_key") {
+    throw new Error("OpenRouter API key is required");
+  }
+  const value = auth.api_key.trim();
+  if (!value) {
+    throw new Error("OpenRouter API key is required");
+  }
+  return value;
+};
+var parseOpenRouterModel = (value) => {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const entry = value;
+  const id = typeof entry.id === "string" ? entry.id.trim() : "";
+  if (!id) {
+    return null;
+  }
+  const topProvider = entry.top_provider && typeof entry.top_provider === "object" ? entry.top_provider : null;
+  return {
+    id,
+    created: typeof entry.created === "number" && Number.isFinite(entry.created) ? entry.created : void 0,
+    context_length: parsePositiveNumber(entry.context_length),
+    top_provider: topProvider ? {
+      context_length: parsePositiveNumber(topProvider.context_length),
+      max_completion_tokens: parsePositiveNumber(
+        topProvider.max_completion_tokens
+      )
+    } : void 0
+  };
+};
+var fetchOpenRouterModels = async (apiKey) => {
+  const response = await fetch(`${OPENROUTER_BASE_URL2}/models`, {
+    headers: buildOpenRouterHeaders(apiKey)
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    const snippet = body ? body.slice(0, 300) : "(empty)";
+    throw new Error(
+      `OpenRouter models request failed (${response.status}): ${snippet}`
+    );
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object") {
+    throw new Error("OpenRouter models response is not an object");
+  }
+  const data = payload.data;
+  if (!Array.isArray(data)) {
+    throw new Error("OpenRouter models response has no data array");
+  }
+  const models = data.map((entry) => parseOpenRouterModel(entry)).filter((entry) => !!entry);
+  models.sort((left, right) => {
+    const leftCreated = left.created ?? 0;
+    const rightCreated = right.created ?? 0;
+    if (leftCreated !== rightCreated) {
+      return rightCreated - leftCreated;
+    }
+    return left.id.localeCompare(right.id);
+  });
+  return models;
+};
+var buildOpenRouterModelList = async ({
+  includeDetails,
+  state,
+  log: log2
+}) => {
+  const apiKey = await resolveOpenRouterApiKeyWithPrompt({ state, log: log2 });
+  const models = await fetchOpenRouterModels(apiKey);
+  const ids = models.map((model) => model.id);
+  if (!includeDetails) {
+    return { models: ids };
+  }
+  const details = {};
+  for (const model of models) {
+    const detail = {};
+    const releaseDate = parseUnixSecondsToDate(model.created);
+    if (releaseDate) {
+      detail.release_date = releaseDate;
+    }
+    const contextWindow = model.context_length ?? model.top_provider?.context_length;
+    if (contextWindow && contextWindow > 0) {
+      detail.context_window = contextWindow;
+      detail.max_input_tokens = contextWindow;
+    }
+    const maxOutputTokens = model.top_provider?.max_completion_tokens;
+    if (maxOutputTokens && maxOutputTokens > 0) {
+      detail.max_output_tokens = maxOutputTokens;
+    }
+    if (Object.keys(detail).length) {
+      details[model.id] = detail;
+    }
+  }
+  return Object.keys(details).length ? { models: ids, details } : { models: ids };
+};
+var buildProviderModelList = async ({
+  provider,
+  includeDetails,
+  state,
+  log: log2
+}) => {
+  if (provider === "openrouter") {
+    return buildOpenRouterModelList({ includeDetails, state, log: log2 });
+  }
+  let providerEntries = null;
+  try {
+    providerEntries = await loadProviderModelEntries(provider);
+  } catch (error) {
+    if (includeDetails) {
+      log2(`model.list details error: ${error}`);
+    }
+  }
+  const models = sortModelsByReleaseDate(
+    (0, import_core18.listModels)(import_core18.DEFAULT_MODEL_REGISTRY, provider).map((model) => model.id),
+    provider,
+    providerEntries
+  );
+  if (!includeDetails || !providerEntries) {
+    return { models };
+  }
+  const details = {};
+  for (const model of models) {
+    const detail = buildModelListDetail(
+      resolveProviderModelEntry(providerEntries, provider, model)
+    );
+    if (detail) {
+      details[model] = detail;
+    }
+  }
+  return Object.keys(details).length ? { models, details } : { models };
+};
 var createModelHandlers = ({
   state,
   log: log2
@@ -5502,9 +6912,9 @@ var createModelHandlers = ({
   const handleModelList = async (id, params) => {
     const requestedProvider = params?.provider;
     const includeDetails = params?.include_details ?? false;
-    if (requestedProvider && requestedProvider !== "openai" && requestedProvider !== "anthropic") {
+    if (requestedProvider && !isSupportedProvider(requestedProvider)) {
       sendError(id, {
-        code: -32602,
+        code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS,
         message: `unsupported provider: ${requestedProvider}`
       });
       return;
@@ -5518,54 +6928,35 @@ var createModelHandlers = ({
         current = config.name;
       }
     } catch (error) {
-      sendError(id, { code: -32e3, message: String(error) });
+      sendError(id, { code: import_protocol4.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
       return;
     }
     const provider = requestedProvider ?? configuredProvider ?? "openai";
-    if (provider !== "openai" && provider !== "anthropic") {
+    if (!isSupportedProvider(provider)) {
       sendError(id, {
-        code: -32602,
+        code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS,
         message: `unsupported provider: ${provider}`
       });
       return;
     }
-    const models = (0, import_core17.listModels)(import_core17.DEFAULT_MODEL_REGISTRY, provider).map((model) => model.id).sort();
+    let models;
+    let details;
+    try {
+      const result2 = await buildProviderModelList({
+        provider,
+        includeDetails,
+        state,
+        log: log2
+      });
+      models = result2.models;
+      details = result2.details;
+    } catch (error) {
+      sendError(id, { code: import_protocol4.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
+      return;
+    }
     if (current && !models.includes(current)) {
       current = void 0;
     }
-    let details;
-    if (includeDetails) {
-      try {
-        const metadataService = new import_model_metadata2.ModelMetadataServiceImpl();
-        const entries = await metadataService.getAllModelEntries();
-        const providerEntries = entries[provider];
-        if (providerEntries) {
-          const nextDetails = {};
-          for (const model of models) {
-            const limits = providerEntries[model]?.limits;
-            if (!limits) continue;
-            const detail = {};
-            if (typeof limits.contextWindow === "number" && limits.contextWindow > 0) {
-              detail.context_window = limits.contextWindow;
-            }
-            if (typeof limits.inputTokens === "number" && limits.inputTokens > 0) {
-              detail.max_input_tokens = limits.inputTokens;
-            }
-            if (typeof limits.outputTokens === "number" && limits.outputTokens > 0) {
-              detail.max_output_tokens = limits.outputTokens;
-            }
-            if (Object.keys(detail).length > 0) {
-              nextDetails[model] = detail;
-            }
-          }
-          if (Object.keys(nextDetails).length > 0) {
-            details = nextDetails;
-          }
-        }
-      } catch (error) {
-        log2(`model.list details error: ${error}`);
-      }
-    }
     const result = {
       provider,
       models,
@@ -5576,26 +6967,28 @@ var createModelHandlers = ({
   };
   const handleModelSet = async (id, params) => {
     if (state.activeRunId) {
-      sendError(id, { code: -32001, message: "runtime busy" });
+      sendError(id, { code: import_protocol4.RPC_ERROR_CODE.RUNTIME_BUSY, message: "runtime busy" });
       return;
     }
     const provider = params?.provider ?? "openai";
     const name = params?.name?.trim();
     if (!name) {
-      sendError(id, { code: -32602, message: "model name is required" });
+      sendError(id, { code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS, message: "model name is required" });
       return;
     }
-    if (provider !== "openai" && provider !== "anthropic") {
+    if (provider !== "openai" && provider !== "anthropic" && provider !== "openrouter") {
       sendError(id, {
-        code: -32602,
+        code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS,
         message: `unsupported provider: ${provider}`
       });
       return;
     }
-    const spec = (0, import_core17.resolveModel)(import_core17.DEFAULT_MODEL_REGISTRY, name, provider);
-    if (!spec) {
-      sendError(id, { code: -32602, message: `unknown model: ${name}` });
-      return;
+    if (provider !== "openrouter") {
+      const spec = (0, import_core18.resolveModel)(import_core18.DEFAULT_MODEL_REGISTRY, name, provider);
+      if (!spec) {
+        sendError(id, { code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS, message: `unknown model: ${name}` });
+        return;
+      }
     }
     try {
       const configPath = resolveConfigPath();
@@ -5605,17 +6998,21 @@ var createModelHandlers = ({
       sendResult(id, result);
       log2(`model.set ${provider}/${name}`);
     } catch (error) {
-      sendError(id, { code: -32e3, message: String(error) });
+      sendError(id, { code: import_protocol4.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
     }
   };
   return { handleModelList, handleModelSet };
 };
 
+// src/rpc/run.ts
+var import_protocol5 = require("@codelia/protocol");
+
 // src/rpc/run-debug.ts
-var import_core18 = require("@codelia/core");
+var import_core19 = require("@codelia/core");
 var DEBUG_MAX_CONTENT_CHARS = 2e3;
 var DEBUG_MAX_LOG_CHARS = 2e4;
 var DEBUG_MAX_EVENT_RESULT_CHARS = 500;
+var DEBUG_MAX_EVENT_ARGS_CHARS = 2e3;
 var truncateText2 = (value, maxChars) => {
   if (value.length <= maxChars) return value;
   return `${value.slice(0, maxChars)}...[truncated]`;
@@ -5628,7 +7025,7 @@ var stringifyUnknown = (value) => {
   }
 };
 var contentToDebugText = (content, maxChars) => {
-  const text = (0, import_core18.stringifyContent)(content, {
+  const text = (0, import_core19.stringifyContent)(content, {
     mode: "log",
     joiner: "\n",
     includeOtherPayload: true
@@ -5687,7 +7084,9 @@ var summarizeRunEvent = (event) => {
     case "tool_call": {
       const tool = typeof event.tool === "string" ? event.tool : "unknown";
       const toolCallId = typeof event.tool_call_id === "string" ? event.tool_call_id : "unknown";
-      return `type=tool_call tool=${tool} tool_call_id=${toolCallId}`;
+      const rawArgs = typeof event.raw_args === "string" ? event.raw_args : stringifyUnknown(event.args);
+      const rawArgsSnippet = truncateText2(rawArgs, DEBUG_MAX_EVENT_ARGS_CHARS);
+      return `type=tool_call tool=${tool} tool_call_id=${toolCallId} raw_args=${stringifyUnknown(rawArgsSnippet)}`;
     }
     case "tool_result": {
       const tool = typeof event.tool === "string" ? event.tool : "unknown";
@@ -5722,7 +7121,7 @@ var logRunDebug = (log2, runId, message) => {
   if (!(0, import_logger.isDebugEnabled)()) return;
   log2(`run debug run_id=${runId} ${message}`);
 };
-var normalizeCancelledHistory = (messages) => {
+var normalizeToolCallHistory = (messages) => {
   const assistantCallIds = /* @__PURE__ */ new Set();
   const toolOutputCallIds = /* @__PURE__ */ new Set();
   for (const message of messages) {
@@ -5806,8 +7205,92 @@ var prepareRunInputText = (inputText) => {
   return `${inputText}${buildSkillMentionHint(mentions)}`;
 };
 
+// src/rpc/run-input.ts
+var isRunInputImageMediaType = (value) => value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+var isRunInputImageDetail = (value) => value === "auto" || value === "low" || value === "high";
+var normalizeRunInputTextPart = (part) => {
+  if (typeof part.text !== "string") {
+    throw new Error("run.start input.parts[text].text must be a string");
+  }
+  return {
+    type: "text",
+    text: prepareRunInputText(part.text)
+  };
+};
+var normalizeRunInputImagePart = (part) => {
+  const imageUrl = part.image_url;
+  if (!imageUrl || typeof imageUrl !== "object") {
+    throw new Error("run.start input.parts[image_url].image_url is required");
+  }
+  if (typeof imageUrl.url !== "string" || imageUrl.url.length === 0) {
+    throw new Error(
+      "run.start input.parts[image_url].image_url.url must be a non-empty string"
+    );
+  }
+  if (imageUrl.media_type !== void 0 && !isRunInputImageMediaType(imageUrl.media_type)) {
+    throw new Error(
+      "run.start input.parts[image_url].image_url.media_type must be png/jpeg/webp/gif"
+    );
+  }
+  if (imageUrl.detail !== void 0 && !isRunInputImageDetail(imageUrl.detail)) {
+    throw new Error(
+      "run.start input.parts[image_url].image_url.detail must be auto/low/high"
+    );
+  }
+  return {
+    type: "image_url",
+    image_url: {
+      url: imageUrl.url,
+      ...imageUrl.media_type ? { media_type: imageUrl.media_type } : {},
+      ...imageUrl.detail ? { detail: imageUrl.detail } : {}
+    }
+  };
+};
+var normalizeRunInput = (input) => {
+  if (input.type === "text") {
+    if (typeof input.text !== "string") {
+      throw new Error("run.start input.text must be a string");
+    }
+    return prepareRunInputText(input.text);
+  }
+  if (!Array.isArray(input.parts)) {
+    throw new Error("run.start input.parts must be an array");
+  }
+  return input.parts.map((part) => {
+    if (!part || typeof part !== "object") {
+      throw new Error("run.start input.parts entry must be an object");
+    }
+    if (part.type === "text") {
+      return normalizeRunInputTextPart(part);
+    }
+    if (part.type === "image_url") {
+      return normalizeRunInputImagePart(part);
+    }
+    throw new Error(
+      `run.start input.parts type is not supported: ${String(part.type)}`
+    );
+  });
+};
+var runInputLengthForDebug = (input) => {
+  if (typeof input === "string") {
+    return input.length;
+  }
+  let total = 0;
+  for (const part of input) {
+    if (part.type === "text") {
+      total += part.text.length;
+      continue;
+    }
+    if (part.type === "image_url") {
+      total += part.image_url.url.length;
+    }
+  }
+  return total;
+};
+
 // src/rpc/run.ts
-var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
+var nowIso4 = () => (/* @__PURE__ */ new Date()).toISOString();
+var SESSION_STATE_SAVE_DEBOUNCE_MS = 1500;
 var createSessionAppender = (store, onError) => {
   let chain = Promise.resolve();
   return (record) => {
@@ -5819,7 +7302,7 @@ var createSessionAppender = (store, onError) => {
 var buildSessionState = (sessionId, runId, messages, invokeSeq) => ({
   schema_version: 1,
   session_id: sessionId,
-  updated_at: nowIso2(),
+  updated_at: nowIso4(),
   run_id: runId,
   invoke_seq: invokeSeq,
   messages
@@ -5830,18 +7313,26 @@ var createRunHandlers = ({
   log: log2,
   runEventStoreFactory,
   sessionStateStore,
-  appendSession
+  appendSession,
+  beforeRunStart
 }) => {
   let activeRunAbort = null;
   let runStartQueue = Promise.resolve();
   const normalizeRunHistoryAfterCancel = (runId, runtimeAgent) => {
     const currentMessages = runtimeAgent.getHistoryMessages();
-    const normalizedMessages = normalizeCancelledHistory(currentMessages);
+    const normalizedMessages = normalizeToolCallHistory(currentMessages);
     if (normalizedMessages !== currentMessages) {
       runtimeAgent.replaceHistoryMessages(normalizedMessages);
       log2(`run.cancel normalized history ${runId}`);
     }
   };
+  const normalizeRestoredSessionMessages = (messages, sessionId) => {
+    const normalizedMessages = normalizeToolCallHistory(messages);
+    if (normalizedMessages !== messages) {
+      log2(`session restore normalized history ${sessionId}`);
+    }
+    return normalizedMessages;
+  };
   const emitRunStatus = (runId, status, message) => {
     sendRunStatus(runId, status, message);
     const suffix = message ? ` message=${message}` : "";
@@ -5849,7 +7340,7 @@ var createRunHandlers = ({
     appendSession({
       type: "run.status",
       run_id: runId,
-      ts: nowIso2(),
+      ts: nowIso4(),
       status,
       ...message ? { message } : {}
     });
@@ -5858,22 +7349,43 @@ var createRunHandlers = ({
     appendSession({
       type: "run.end",
       run_id: runId,
-      ts: nowIso2(),
+      ts: nowIso4(),
       outcome,
       ...final !== void 0 ? { final } : {}
     });
   };
   const handleRunStart = (id, params) => {
     const run = async () => {
+      let normalizedInput;
+      try {
+        normalizedInput = normalizeRunInput(params.input);
+      } catch (error) {
+        sendError(id, {
+          code: import_protocol5.RPC_ERROR_CODE.INVALID_PARAMS,
+          message: String(error)
+        });
+        return;
+      }
+      if (beforeRunStart) {
+        try {
+          await beforeRunStart();
+        } catch (error) {
+          sendError(id, {
+            code: import_protocol5.RPC_ERROR_CODE.RUNTIME_INTERNAL,
+            message: `startup onboarding failed: ${String(error)}`
+          });
+          return;
+        }
+      }
       if (state.activeRunId) {
-        sendError(id, { code: -32001, message: "runtime busy" });
+        sendError(id, { code: import_protocol5.RPC_ERROR_CODE.RUNTIME_BUSY, message: "runtime busy" });
         return;
       }
       let runtimeAgent;
       try {
         runtimeAgent = await getAgent();
       } catch (error) {
-        sendError(id, { code: -32e3, message: String(error) });
+        sendError(id, { code: import_protocol5.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
         return;
       }
       const requestedSessionId = params.session_id?.trim() || void 0;
@@ -5884,16 +7396,20 @@ var createRunHandlers = ({
           resumeState = await sessionStateStore.load(requestedSessionId);
         } catch (error) {
           sendError(id, {
-            code: -32005,
+            code: import_protocol5.RPC_ERROR_CODE.SESSION_LOAD_FAILED,
             message: `session load failed: ${String(error)}`
           });
           return;
         }
         if (!resumeState) {
-          sendError(id, { code: -32004, message: "session not found" });
+          sendError(id, { code: import_protocol5.RPC_ERROR_CODE.SESSION_NOT_FOUND, message: "session not found" });
           return;
         }
-        const messages = Array.isArray(resumeState.messages) ? resumeState.messages : [];
+        const restoredMessages = Array.isArray(resumeState.messages) ? resumeState.messages : [];
+        const messages = normalizeRestoredSessionMessages(
+          restoredMessages,
+          requestedSessionId
+        );
         runtimeAgent.replaceHistoryMessages(messages);
         sessionId = requestedSessionId;
         state.sessionId = sessionId;
@@ -5901,17 +7417,25 @@ var createRunHandlers = ({
         try {
           resumeState = await sessionStateStore.load(state.sessionId);
         } catch (error) {
-          log2(`session state reload error: ${String(error)}`);
+          sendError(id, {
+            code: import_protocol5.RPC_ERROR_CODE.SESSION_LOAD_FAILED,
+            message: `session reload failed: ${String(error)}`
+          });
+          return;
         }
         if (resumeState) {
-          const messages = Array.isArray(resumeState.messages) ? resumeState.messages : [];
+          const restoredMessages = Array.isArray(resumeState.messages) ? resumeState.messages : [];
+          const messages = normalizeRestoredSessionMessages(
+            restoredMessages,
+            state.sessionId
+          );
           runtimeAgent.replaceHistoryMessages(messages);
         }
       } else if (!state.sessionId) {
         state.sessionId = sessionId;
       }
       const runId = state.nextRunId();
-      const startedAt = nowIso2();
+      const startedAt = nowIso4();
       state.beginRun(runId, params.ui_context ?? state.lastUiContext);
       const runAbortController = new AbortController();
       activeRunAbort = { runId, controller: runAbortController };
@@ -5961,7 +7485,7 @@ var createRunHandlers = ({
         type: "run.start",
         run_id: runId,
         session_id: sessionId,
-        ts: nowIso2(),
+        ts: nowIso4(),
         input: params.input,
         ui_context: params.ui_context,
         meta: params.meta
@@ -5972,25 +7496,58 @@ var createRunHandlers = ({
       emitRunStatus(runId, "running");
       void (async () => {
         let finalResponse;
-        let cancelledWhileStreaming = false;
-        const preparedInputText = prepareRunInputText(params.input.text);
+        let sessionSaveChain = Promise.resolve();
+        let lastSessionSaveAt = 0;
+        const queueSessionSave = async (reason) => {
+          sessionSaveChain = sessionSaveChain.then(async () => {
+            if (!sessionId) return;
+            const messages = runtimeAgent.getHistoryMessages();
+            const snapshotMessages = normalizeToolCallHistory(messages);
+            if (snapshotMessages !== messages) {
+              logRunDebug(
+                log2,
+                runId,
+                `session.save normalized reason=${reason}`
+              );
+            }
+            const snapshot = buildSessionState(
+              sessionId,
+              runId,
+              snapshotMessages,
+              session.invoke_seq
+            );
+            await sessionStateStore.save(snapshot);
+            logRunDebug(log2, runId, `session.save ${reason}`);
+          }).catch((error) => {
+            log2(`Error: session-state save failed: ${String(error)}`);
+          });
+          await sessionSaveChain;
+        };
+        const maybeDebouncedSessionSave = () => {
+          const now = Date.now();
+          if (now - lastSessionSaveAt < SESSION_STATE_SAVE_DEBOUNCE_MS) {
+            return;
+          }
+          lastSessionSaveAt = now;
+          void queueSessionSave("debounced");
+        };
         try {
           logRunDebug(
             log2,
             runId,
-            `stream.start input_chars=${preparedInputText.length}`
+            `stream.start input_chars=${runInputLengthForDebug(normalizedInput)}`
           );
-          for await (const event of runtimeAgent.runStream(preparedInputText, {
+          for await (const event of runtimeAgent.runStream(normalizedInput, {
             session,
             signal: runAbortController.signal,
             forceCompaction: params.force_compaction
           })) {
             if (state.cancelRequested) {
-              cancelledWhileStreaming = true;
               break;
             }
             if (event.type === "final") {
               finalResponse = event.content;
+              await queueSessionSave("final");
             }
             if (event.type === "compaction_complete") {
               logCompactionSnapshot(log2, runId, runtimeAgent, event.compacted);
@@ -6014,7 +7571,7 @@ var createRunHandlers = ({
               appendSession({
                 type: "agent.event",
                 run_id: runId,
-                ts: nowIso2(),
+                ts: nowIso4(),
                 seq,
                 event
               });
@@ -6025,14 +7582,16 @@ var createRunHandlers = ({
               appendSession({
                 type: "run.context",
                 run_id: runId,
-                ts: nowIso2(),
+                ts: nowIso4(),
                 context_left_percent: contextLeftPercent
               });
             }
+            maybeDebouncedSessionSave();
           }
-          if (cancelledWhileStreaming) {
+          if (state.cancelRequested) {
             normalizeRunHistoryAfterCancel(runId, runtimeAgent);
           }
+          await queueSessionSave("terminal");
           const status = state.cancelRequested ? "cancelled" : "completed";
           emitRunStatus(runId, status);
           emitRunEnd(
@@ -6044,15 +7603,17 @@ var createRunHandlers = ({
           const err = error instanceof Error ? error : new Error(String(error));
           if (state.cancelRequested || isAbortLikeError(err)) {
             normalizeRunHistoryAfterCancel(runId, runtimeAgent);
+            await queueSessionSave("cancelled");
             emitRunStatus(runId, "cancelled", err.message || "cancelled");
             emitRunEnd(runId, "cancelled", finalResponse);
             return;
           }
+          await queueSessionSave("error");
           emitRunStatus(runId, "error", err.message);
           appendSession({
             type: "run.error",
             run_id: runId,
-            ts: nowIso2(),
+            ts: nowIso4(),
             error: {
               name: err.name,
               message: err.message,
@@ -6062,18 +7623,10 @@ var createRunHandlers = ({
           emitRunEnd(runId, "error");
         } finally {
           logRunDebug(log2, runId, "stream.finally");
-          if (state.sessionId) {
-            const messages = runtimeAgent.getHistoryMessages();
-            const snapshot = buildSessionState(
-              sessionId,
-              runId,
-              messages,
-              session.invoke_seq
-            );
-            void sessionStateStore.save(snapshot).catch((error) => {
-              log2(`session-state error: ${String(error)}`);
-            });
+          if (state.cancelRequested) {
+            normalizeRunHistoryAfterCancel(runId, runtimeAgent);
           }
+          await queueSessionSave("finally");
           if (activeRunAbort?.runId === runId) {
             activeRunAbort = null;
           }
@@ -6099,19 +7652,20 @@ var createRunHandlers = ({
       log2(`run.cancel ${params.run_id} (${params.reason ?? "no reason"})`);
       return;
     }
-    sendError(id, { code: -32002, message: "run not found" });
+    sendError(id, { code: import_protocol5.RPC_ERROR_CODE.RUN_NOT_FOUND, message: "run not found" });
   };
   return { handleRunStart, handleRunCancel };
 };
 
 // src/rpc/skills.ts
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
+var import_protocol6 = require("@codelia/protocol");
 var createSkillsHandlers = ({
   state,
   log: log2
 }) => {
   const handleSkillsList = async (id, params) => {
-    const requestedCwd = params?.cwd ? import_node_path12.default.resolve(params.cwd) : void 0;
+    const requestedCwd = params?.cwd ? import_node_path14.default.resolve(params.cwd) : void 0;
     const workingDir = requestedCwd ?? state.runtimeWorkingDir ?? state.lastUiContext?.cwd ?? process.cwd();
     const forceReload = params?.force_reload ?? false;
     if (!forceReload) {
@@ -6135,7 +7689,7 @@ var createSkillsHandlers = ({
         });
       } catch (error) {
         sendError(id, {
-          code: -32e3,
+          code: import_protocol6.RPC_ERROR_CODE.RUNTIME_INTERNAL,
           message: `skills resolver init failed: ${String(error)}`
         });
         return;
@@ -6157,7 +7711,7 @@ var createSkillsHandlers = ({
     } catch (error) {
       log2(`skills.list error: ${String(error)}`);
       sendError(id, {
-        code: -32e3,
+        code: import_protocol6.RPC_ERROR_CODE.RUNTIME_INTERNAL,
         message: `skills list failed: ${String(error)}`
       });
     }
@@ -6165,6 +7719,75 @@ var createSkillsHandlers = ({
   return { handleSkillsList };
 };
 
+// src/rpc/tool.ts
+var import_protocol7 = require("@codelia/protocol");
+var normalizeToolResult = (result) => {
+  switch (result.type) {
+    case "json":
+      return result.value;
+    case "text":
+      return result.text;
+    case "parts":
+      return result.parts;
+  }
+};
+var createToolContext = () => {
+  const deps = /* @__PURE__ */ Object.create(null);
+  const cache = /* @__PURE__ */ new Map();
+  const resolve = async (key) => {
+    if (cache.has(key.id)) {
+      return cache.get(key.id);
+    }
+    const value = await key.create();
+    cache.set(key.id, value);
+    return value;
+  };
+  return {
+    deps,
+    resolve,
+    now: () => /* @__PURE__ */ new Date()
+  };
+};
+var createToolHandlers = ({
+  state,
+  getAgent
+}) => {
+  const handleToolCall = async (id, params) => {
+    const toolName = params?.name;
+    if (!toolName) {
+      sendError(id, { code: import_protocol7.RPC_ERROR_CODE.INVALID_PARAMS, message: "tool name is required" });
+      return;
+    }
+    if (!state.tools) {
+      await getAgent();
+    }
+    const tool = state.tools?.find((entry) => entry.name === toolName);
+    if (!tool) {
+      sendError(id, { code: import_protocol7.RPC_ERROR_CODE.INVALID_PARAMS, message: `unknown tool: ${toolName}` });
+      return;
+    }
+    try {
+      const result = await tool.executeRaw(
+        JSON.stringify(params?.arguments ?? {}),
+        createToolContext()
+      );
+      const response = {
+        ok: true,
+        result: normalizeToolResult(result)
+      };
+      sendResult(id, response);
+    } catch (error) {
+      sendError(id, {
+        code: import_protocol7.RPC_ERROR_CODE.RUNTIME_INTERNAL,
+        message: `tool call failed: ${String(error)}`
+      });
+    }
+  };
+  return {
+    handleToolCall
+  };
+};
+
 // src/rpc/handlers.ts
 var createRuntimeHandlers = ({
   state,
@@ -6172,31 +7795,132 @@ var createRuntimeHandlers = ({
   log: log2,
   mcpManager: injectedMcpManager,
   sessionStateStore: injectedSessionStateStore,
-  runEventStoreFactory: injectedRunEventStoreFactory
+  runEventStoreFactory: injectedRunEventStoreFactory,
+  buildProviderModelList: injectedBuildProviderModelList
 }) => {
-  const sessionStateStore = injectedSessionStateStore ?? new import_storage7.SessionStateStoreImpl({
+  const sessionStateStore = injectedSessionStateStore ?? new import_storage8.SessionStateStoreImpl({
     onError: (error, context) => {
       log2(
         `session-state ${context.action} error${context.detail ? ` (${context.detail})` : ""}: ${String(error)}`
       );
     }
   });
-  const runEventStoreFactory = injectedRunEventStoreFactory ?? new import_storage7.RunEventStoreFactoryImpl();
+  const runEventStoreFactory = injectedRunEventStoreFactory ?? new import_storage8.RunEventStoreFactoryImpl();
   const mcpManager = injectedMcpManager ?? {
     start: async () => void 0,
     list: () => ({ servers: [] })
   };
+  const buildProviderModelList2 = injectedBuildProviderModelList ?? buildProviderModelList;
+  let startupOnboardingPromise = null;
+  let startupOnboardingStarted = false;
   const appendSession = (record) => {
     if (!state.sessionAppend) return;
     state.sessionAppend(record);
   };
+  const formatUsdPer1M = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+      return null;
+    }
+    const fixed = value.toFixed(4);
+    return fixed.replace(/\.?0+$/, "");
+  };
+  const buildModelPickDetail = (details) => {
+    const parts = [];
+    if (details?.release_date) {
+      parts.push(`released ${details.release_date}`);
+    }
+    const inputCost = formatUsdPer1M(details?.cost_per_1m_input_tokens_usd);
+    const outputCost = formatUsdPer1M(details?.cost_per_1m_output_tokens_usd);
+    if (inputCost !== null || outputCost !== null) {
+      parts.push(
+        `cost in/out ${inputCost ?? "-"}/${outputCost ?? "-"} USD per 1M`
+      );
+    }
+    return parts.join(" \u2022 ");
+  };
+  const runStartupOnboarding = async () => {
+    const supportsPick = !!state.uiCapabilities?.supports_pick;
+    const supportsPrompt = !!state.uiCapabilities?.supports_prompt;
+    if (!supportsPick || !supportsPrompt) {
+      return;
+    }
+    const authResolver = await AuthResolver.create(state, log2);
+    if (authResolver.hasAnyAvailableAuth()) {
+      return;
+    }
+    const providerPick = await requestUiPick(state, {
+      title: "Let's set up your provider to get started.",
+      items: SUPPORTED_PROVIDERS.map((provider2) => ({
+        id: provider2,
+        label: provider2,
+        detail: provider2 === "openai" ? "OAuth (ChatGPT Plus/Pro) or API key" : provider2 === "openrouter" ? "API key (OpenRouter)" : "API key"
+      })),
+      multi: false
+    });
+    const pickedProvider = providerPick?.ids?.[0];
+    if (!pickedProvider || !SUPPORTED_PROVIDERS.includes(pickedProvider)) {
+      log2("startup onboarding skipped (provider not selected)");
+      return;
+    }
+    const provider = pickedProvider;
+    try {
+      await authResolver.resolveProviderAuth(provider);
+    } catch (error) {
+      log2(`startup onboarding auth failed: ${String(error)}`);
+      return;
+    }
+    const { models, details } = await buildProviderModelList2({
+      provider,
+      includeDetails: true,
+      state,
+      log: log2
+    });
+    if (!models.length) {
+      log2(`startup onboarding model list returned no models for ${provider}`);
+      return;
+    }
+    const modelPick = await requestUiPick(state, {
+      title: `Select model (${provider})`,
+      items: models.map((model) => ({
+        id: model,
+        label: model,
+        detail: buildModelPickDetail(details?.[model]) || void 0
+      })),
+      multi: false
+    });
+    const selectedModel = modelPick?.ids?.[0];
+    if (!selectedModel || !models.includes(selectedModel)) {
+      log2("startup onboarding skipped (model not selected)");
+      return;
+    }
+    const configPath = resolveConfigPath();
+    await (0, import_config_loader3.updateModelConfig)(configPath, { provider, name: selectedModel });
+    state.agent = null;
+    log2(`startup onboarding completed: ${provider}/${selectedModel}`);
+  };
+  const launchStartupOnboarding = () => {
+    if (startupOnboardingStarted) {
+      return;
+    }
+    startupOnboardingStarted = true;
+    startupOnboardingPromise = runStartupOnboarding().catch((error) => {
+      log2(`startup onboarding failed: ${String(error)}`);
+    }).finally(() => {
+      startupOnboardingPromise = null;
+    });
+  };
+  const waitForStartupOnboarding = async () => {
+    if (!startupOnboardingPromise) return;
+    await startupOnboardingPromise;
+  };
   const { handleRunStart, handleRunCancel } = createRunHandlers({
     state,
     getAgent,
     log: log2,
     runEventStoreFactory,
     sessionStateStore,
-    appendSession
+    appendSession,
+    beforeRunStart: waitForStartupOnboarding
   });
   const { handleSessionList, handleSessionHistory } = createHistoryHandlers({
     sessionStateStore,
@@ -6214,6 +7938,10 @@ var createRuntimeHandlers = ({
     state,
     log: log2
   });
+  const { handleToolCall } = createToolHandlers({
+    state,
+    getAgent
+  });
   const handleInitialize = (id, params) => {
     const result = {
       protocol_version: PROTOCOL_VERSION,
@@ -6223,13 +7951,16 @@ var createRuntimeHandlers = ({
         supports_ui_requests: true,
         supports_mcp_list: true,
         supports_skills_list: true,
-        supports_context_inspect: true
+        supports_context_inspect: true,
+        supports_tool_call: true,
+        supports_permission_preflight_events: true
       }
     };
     sendResult(id, result);
     log2(`initialize from ${params.client?.name ?? "unknown"}`);
     state.lastClientInfo = params.client ?? null;
     state.setUiCapabilities(params.ui_capabilities);
+    launchStartupOnboarding();
   };
   const handleUiContextUpdate = (params) => {
     state.updateUiContext(params);
@@ -6239,7 +7970,7 @@ var createRuntimeHandlers = ({
   };
   const handleAuthLogout = async (id, params) => {
     if (state.activeRunId) {
-      sendError(id, { code: -32001, message: "runtime busy" });
+      sendError(id, { code: import_protocol8.RPC_ERROR_CODE.RUNTIME_BUSY, message: "runtime busy" });
       return;
     }
     const clearSession = params?.clear_session ?? true;
@@ -6247,7 +7978,7 @@ var createRuntimeHandlers = ({
       const supportsConfirm = !!state.uiCapabilities?.supports_confirm;
       if (!supportsConfirm) {
         sendError(id, {
-          code: -32e3,
+          code: import_protocol8.RPC_ERROR_CODE.RUNTIME_INTERNAL,
           message: "UI confirmation is required for logout"
         });
         return;
@@ -6289,7 +8020,7 @@ var createRuntimeHandlers = ({
       log2(`auth.logout session_cleared=${clearSession}`);
     } catch (error) {
       sendError(id, {
-        code: -32e3,
+        code: import_protocol8.RPC_ERROR_CODE.RUNTIME_INTERNAL,
         message: `auth logout failed: ${String(error)}`
       });
     }
@@ -6312,6 +8043,8 @@ var createRuntimeHandlers = ({
         return handleModelList(req.id, req.params);
       case "model.set":
         return handleModelSet(req.id, req.params);
+      case "tool.call":
+        return handleToolCall(req.id, req.params);
       case "mcp.list":
         await mcpManager.start?.();
         return sendResult(
@@ -6323,7 +8056,7 @@ var createRuntimeHandlers = ({
       case "context.inspect":
         return handleContextInspect(req.id, req.params);
       default:
-        return sendError(req.id, { code: -32601, message: "method not found" });
+        return sendError(req.id, { code: import_protocol8.RPC_ERROR_CODE.METHOD_NOT_FOUND, message: "method not found" });
     }
   };
   const handleNotification = (note) => {
@@ -6350,7 +8083,7 @@ var createRuntimeHandlers = ({
 };
 
 // src/runtime-state.ts
-var import_node_crypto5 = __toESM(require("crypto"), 1);
+var import_node_crypto6 = __toESM(require("crypto"), 1);
 var RuntimeState = class {
   runSeq = /* @__PURE__ */ new Map();
   uiRequestCounter = 0;
@@ -6363,6 +8096,7 @@ var RuntimeState = class {
   uiCapabilities = null;
   systemPrompt = null;
   toolDefinitions = null;
+  tools = null;
   sessionId = null;
   sessionAppend = null;
   agent = null;
@@ -6373,10 +8107,10 @@ var RuntimeState = class {
   runtimeWorkingDir = null;
   runtimeSandboxRoot = null;
   nextRunId() {
-    return import_node_crypto5.default.randomUUID();
+    return import_node_crypto6.default.randomUUID();
   }
   nextSessionId() {
-    return import_node_crypto5.default.randomUUID();
+    return import_node_crypto6.default.randomUUID();
   }
   beginRun(runId, uiContext) {
     this.activeRunId = runId;
@@ -6466,42 +8200,59 @@ var RuntimeState = class {
 
 // src/runtime.ts
 var startRuntime = () => {
-  const state = new RuntimeState();
-  const workingDir = process.env.CODELIA_SANDBOX_ROOT ? import_node_path13.default.resolve(process.env.CODELIA_SANDBOX_ROOT) : process.cwd();
-  state.runtimeWorkingDir = workingDir;
-  state.runtimeSandboxRoot = workingDir;
-  const mcpManager = new McpManager({ workingDir, log: import_logger.log });
-  void mcpManager.start({
-    onStatus: (message) => (0, import_logger.log)(`mcp: ${message}`),
-    requestOAuthTokens: ({ server_id, oauth: oauth2, error }) => requestMcpOAuthTokensWithRunStatus(state, server_id, oauth2, error)
-  });
-  const getAgent = createAgentFactory(state, { mcpManager });
-  const { processMessage } = createRuntimeHandlers({
-    state,
-    getAgent,
-    log: import_logger.log,
-    mcpManager
-  });
-  (0, import_logger.log)("runtime started");
-  process.stdin.setEncoding("utf8");
-  let buffer = "";
-  process.stdin.on("data", (chunk) => {
-    buffer += chunk;
-    let index = buffer.indexOf("\n");
-    while (index >= 0) {
-      const line = buffer.slice(0, index).trim();
-      buffer = buffer.slice(index + 1);
-      if (line) {
-        try {
-          const msg = JSON.parse(line);
-          processMessage(msg);
-        } catch (error) {
-          (0, import_logger.log)(`invalid json: ${String(error)}`);
-        }
+  void (async () => {
+    const state = new RuntimeState();
+    const workingDir = process.env.CODELIA_SANDBOX_ROOT ? import_node_path15.default.resolve(process.env.CODELIA_SANDBOX_ROOT) : process.cwd();
+    state.runtimeWorkingDir = workingDir;
+    state.runtimeSandboxRoot = workingDir;
+    const sessionStateStore = new import_storage9.SessionStateStoreImpl({
+      onError: (error, context) => {
+        (0, import_logger.log)(
+          `Error: session-state ${context.action} error${context.detail ? ` (${context.detail})` : ""}: ${String(error)}`
+        );
       }
-      index = buffer.indexOf("\n");
+    });
+    try {
+      await sessionStateStore.list();
+    } catch (error) {
+      (0, import_logger.log)(`Error: session index database is not available: ${String(error)}`);
+      process.exit(1);
+      return;
     }
-  });
+    const mcpManager = new McpManager({ workingDir, log: import_logger.log });
+    void mcpManager.start({
+      onStatus: (message) => (0, import_logger.log)(`mcp: ${message}`),
+      requestOAuthTokens: ({ server_id, oauth: oauth2, error }) => requestMcpOAuthTokensWithRunStatus(state, server_id, oauth2, error)
+    });
+    const getAgent = createAgentFactory(state, { mcpManager });
+    const { processMessage } = createRuntimeHandlers({
+      state,
+      getAgent,
+      log: import_logger.log,
+      mcpManager,
+      sessionStateStore
+    });
+    (0, import_logger.log)("runtime started");
+    process.stdin.setEncoding("utf8");
+    let buffer = "";
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+      let index = buffer.indexOf("\n");
+      while (index >= 0) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (line) {
+          try {
+            const msg = JSON.parse(line);
+            processMessage(msg);
+          } catch (error) {
+            (0, import_logger.log)(`invalid json: ${String(error)}`);
+          }
+        }
+        index = buffer.indexOf("\n");
+      }
+    });
+  })();
 };
 
 // src/index.ts