@serendb/serendesktop 0.1.20 → 0.1.21

package/dist/server.js

@@ -4,8 +4,8 @@ import { exec as exec2 } from "child_process";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { createServer as createServer2 } from "http";
 import { request as httpsRequest } from "https";
-import { homedir as homedir6, platform as platform4 } from "os";
-import { join as join7, extname as extname2 } from "path";
+import { homedir as homedir8, platform as platform4 } from "os";
+import { join as join9, extname as extname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire as createRequire2 } from "module";
 import { WebSocketServer } from "ws";
@@ -201,42 +201,1149 @@ async function handleMessage(raw) {
   }
 }
 
+// src/services/orchestrator.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// src/services/rlm.ts
+var PUBLISHER_SLUG = "seren-models";
+var RLM_THRESHOLD = 0.85;
+var CHUNK_TARGET_FRACTION = 0.45;
+var CHUNK_OVERLAP_CHARS = 800;
+var REQUEST_TIMEOUT_MS = 6e5;
+function modelContextLimitChars(modelId) {
+  let tokens;
+  if (modelId.includes("gemini-1.5") || modelId.includes("gemini-2") || modelId.includes("gemini-3")) {
+    tokens = 1e6;
+  } else if (modelId.includes("claude")) {
+    tokens = 2e5;
+  } else if (modelId.includes("gpt-4")) {
+    tokens = 128e3;
+  } else {
+    tokens = 1e5;
+  }
+  return tokens * 4;
+}
+function needsRlm(inputChars, modelId) {
+  const limit = modelContextLimitChars(modelId);
+  const threshold = Math.floor(limit * RLM_THRESHOLD);
+  return inputChars > threshold;
+}
+async function processRlm(query, content, model, apiBase, apiKey, onEvent) {
+  const limit = modelContextLimitChars(model);
+  const chunkBudget = Math.floor(limit * CHUNK_TARGET_FRACTION);
+  let strategy;
+  try {
+    strategy = await classifyTask(query, apiBase, apiKey);
+  } catch (err) {
+    strategy = "sequential";
+  }
+  const chunks = chunkContent(content, chunkBudget);
+  onEvent?.({ type: "rlm_start", data: { index: 0, total: chunks.length } });
+  let finalAnswer;
+  if (strategy === "synthesis") {
+    finalAnswer = await processMapReduce(
+      chunks,
+      query,
+      model,
+      apiBase,
+      apiKey,
+      onEvent
+    );
+  } else {
+    finalAnswer = await processSequential(
+      chunks,
+      query,
+      model,
+      apiBase,
+      apiKey,
+      onEvent
+    );
+  }
+  return finalAnswer;
+}
+async function classifyTask(query, apiBase, apiKey) {
+  const url = `${apiBase}/publishers/${PUBLISHER_SLUG}/chat/completions`;
+  const system = "You are a task classifier. Respond with exactly one word.";
+  const user = [
+    'Classify this task as either "synthesis" (requires reasoning across a whole document:',
+    'summarize, analyze, compare, find themes) or "sequential" (can be done chunk by chunk:',
+    "translate, reformat, extract).",
+    "",
+    `Task: ${query}`,
+    "",
+    "Respond with exactly one word: synthesis or sequential"
+  ].join("\n");
+  const body = {
+    model: "anthropic/claude-sonnet-4",
+    // cheap model for classification
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: user }
+    ],
+    stream: false,
+    max_tokens: 10
+  };
+  const response = await fetchWithTimeout(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Classify HTTP ${response.status}: ${text}`);
+  }
+  const json = await response.json();
+  const answer = (json?.choices?.[0]?.message?.content ?? "").trim().toLowerCase();
+  return answer.includes("sequential") ? "sequential" : "synthesis";
+}
+function chunkContent(content, budget) {
+  const raw = splitAtBudget(content, budget);
+  const total = raw.length;
+  return raw.map((text, i) => ({ index: i, total, text }));
+}
+function overlapStartFor(tailStart) {
+  return tailStart > CHUNK_OVERLAP_CHARS ? tailStart - CHUNK_OVERLAP_CHARS : tailStart;
+}
+function splitAtBudget(text, budget) {
+  if (text.length <= budget) {
+    return [text];
+  }
+  const windowStart = Math.floor(budget / 2);
+  const searchRegion = text.slice(0, Math.min(budget, text.length));
+  const headingPos = findHeadingBoundary(searchRegion, windowStart);
+  if (headingPos !== -1) {
+    const head2 = text.slice(0, headingPos);
+    const tailWithOverlap2 = text.slice(overlapStartFor(head2.length));
+    return [head2, ...splitAtBudget(tailWithOverlap2, budget)];
+  }
+  const dblNewlinePos = rfindInRange(searchRegion, "\n\n", windowStart);
+  if (dblNewlinePos !== -1) {
+    const splitPos = dblNewlinePos + 2;
+    const head2 = text.slice(0, splitPos);
+    const tailWithOverlap2 = text.slice(overlapStartFor(head2.length));
+    return [head2, ...splitAtBudget(tailWithOverlap2, budget)];
+  }
+  const newlinePos = rfindInRange(searchRegion, "\n", windowStart);
+  if (newlinePos !== -1) {
+    const splitPos = newlinePos + 1;
+    const head2 = text.slice(0, splitPos);
+    const tailWithOverlap2 = text.slice(overlapStartFor(head2.length));
+    return [head2, ...splitAtBudget(tailWithOverlap2, budget)];
+  }
+  for (const sep of [". ", "! ", "? "]) {
+    const sentPos = rfindInRange(searchRegion, sep, windowStart);
+    if (sentPos !== -1) {
+      const splitPos = sentPos + sep.length;
+      const head2 = text.slice(0, splitPos);
+      const tailWithOverlap2 = text.slice(overlapStartFor(head2.length));
+      return [head2, ...splitAtBudget(tailWithOverlap2, budget)];
+    }
+  }
+  const head = text.slice(0, budget);
+  const tailWithOverlap = text.slice(overlapStartFor(head.length));
+  return [head, ...splitAtBudget(tailWithOverlap, budget)];
+}
+function rfindInRange(haystack, needle, minPos) {
+  const lastIdx = haystack.lastIndexOf(needle);
+  return lastIdx >= minPos ? lastIdx : -1;
+}
+function findHeadingBoundary(text, minPos) {
+  let idx = text.indexOf("\n", minPos);
+  while (idx !== -1 && idx + 1 < text.length) {
+    const nextChar = text[idx + 1];
+    if (nextChar === "#" || nextChar >= "0" && nextChar <= "9") {
+      return idx + 1;
+    }
+    idx = text.indexOf("\n", idx + 1);
+  }
+  return -1;
+}
+async function processMapReduce(chunks, query, model, apiBase, apiKey, onEvent) {
+  const promises = chunks.map(async (chunk) => {
+    const prompt = [
+      `Question: ${query}`,
+      "",
+      `Document section ${chunk.index + 1}/${chunk.total}:`,
+      "",
+      chunk.text,
+      "",
+      "Answer the question based only on the content in this section. If the section does not contain relevant information, say so briefly."
+    ].join("\n");
+    const summary = await callSimple(prompt, model, apiBase, apiKey);
+    onEvent?.({
+      type: "rlm_chunk_complete",
+      data: { index: chunk.index, total: chunk.total, summary }
+    });
+    return { index: chunk.index, total: chunk.total, summary };
+  });
+  const results = await Promise.all(promises);
+  results.sort((a, b) => a.index - b.index);
+  const mergePrompt = buildMergePrompt(query, results.map((r) => r.summary));
+  return callSimple(mergePrompt, model, apiBase, apiKey);
+}
+async function processSequential(chunks, query, model, apiBase, apiKey, onEvent) {
+  let runningSummary = "";
+  let lastAnswer = "";
+  for (const chunk of chunks) {
+    let prompt;
+    if (!runningSummary) {
+      prompt = [
+        `Question: ${query}`,
+        "",
+        `Document section ${chunk.index + 1}/${chunk.total}:`,
+        "",
+        chunk.text
+      ].join("\n");
+    } else {
+      prompt = [
+        `Question: ${query}`,
+        "",
+        `Progress so far:`,
+        runningSummary,
+        "",
+        `Document section ${chunk.index + 1}/${chunk.total}:`,
+        "",
+        chunk.text
+      ].join("\n");
+    }
+    const answer = await callSimple(prompt, model, apiBase, apiKey);
+    onEvent?.({
+      type: "rlm_chunk_complete",
+      data: { index: chunk.index, total: chunk.total, summary: answer }
+    });
+    runningSummary = answer;
+    lastAnswer = answer;
+  }
+  return lastAnswer;
+}
+async function callSimple(prompt, model, apiBase, apiKey) {
+  const url = `${apiBase}/publishers/${PUBLISHER_SLUG}/chat/completions`;
+  const messages = [
+    { role: "system", content: "You are a helpful AI assistant." },
+    { role: "user", content: prompt }
+  ];
+  const body = { model, messages, stream: false };
+  const response = await fetchWithTimeout(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`RLM sub-call HTTP ${response.status}: ${text}`);
+  }
+  const json = await response.json();
+  const content = json?.choices?.[0]?.message?.content;
+  if (typeof content !== "string") {
+    throw new Error(`No content in RLM response: ${JSON.stringify(json)}`);
+  }
+  return content;
+}
+async function fetchWithTimeout(url, init) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+function buildMergePrompt(question, summaries) {
+  const parts = summaries.map(
+    (s, i) => `Section ${i + 1} answer:
+${s}`
+  );
+  return [
+    `Question: ${question}`,
+    "",
+    `I processed a large document in ${summaries.length} sections. Here are the answers from each section:`,
+    "",
+    parts.join("\n\n"),
+    "",
+    "Synthesize these section answers into a single, coherent final answer to the question."
+  ].join("\n");
+}
+function splitContentAndQuestion(prompt) {
+  const trimmed = prompt.trim();
+  const lastDoubleNewline = trimmed.lastIndexOf("\n\n");
+  if (lastDoubleNewline !== -1) {
+    const content = trimmed.slice(0, lastDoubleNewline).trim();
+    const question = trimmed.slice(lastDoubleNewline + 2).trim();
+    if (content && question) {
+      return [content, question];
+    }
+  }
+  return [trimmed, trimmed];
+}
+
+// src/services/tool-relevance.ts
+var K1 = 1.5;
+var B = 0.75;
+var AVG_TOOL_WORDS = 60;
+var CHARS_PER_TOKEN = 4;
+var TOOL_TOKEN_BUDGET = 2e3;
+var MIN_TOOLS = 3;
+var MAX_TOOLS = 20;
+var HARD_BYTE_BUDGET = 400 * 1024;
+function selectRelevantTools(query, tools) {
+  const totalBytes = JSON.stringify(tools).length;
+  if (totalBytes <= HARD_BYTE_BUDGET && tools.length <= MAX_TOOLS) {
+    return [...tools];
+  }
+  if (tools.length === 0) {
+    return [];
+  }
+  const queryTerms = tokenize(query);
+  if (queryTerms.length === 0) {
+    return applyHardBudget(tools);
+  }
+  const docs = tools.map(toolText);
+  const scores = bm25Scores(queryTerms, docs);
+  const ranked = scores.map((score, idx) => [idx, score]).sort((a, b) => b[1] - a[1]);
+  const selectedIndices = [];
+  let tokenCount = 0;
+  for (const [idx] of ranked) {
+    if (selectedIndices.length >= MAX_TOOLS) {
+      break;
+    }
+    const toolTokens = approximateTokens(docs[idx]);
+    const budgetExceeded = tokenCount + toolTokens > TOOL_TOKEN_BUDGET && selectedIndices.length >= MIN_TOOLS;
+    if (budgetExceeded) {
+      break;
+    }
+    selectedIndices.push(idx);
+    tokenCount += toolTokens;
+  }
+  selectedIndices.sort((a, b) => a - b);
+  const result = selectedIndices.map((i) => tools[i]);
+  console.log(
+    `[ToolRelevance] Selected ${result.length} of ${tools.length} tools (~${tokenCount} tokens)`
+  );
+  return applyHardBudget(result);
+}
+function toolText(tool) {
+  const parts = [];
+  if (tool.function?.name) {
+    parts.push(tool.function.name);
+  }
+  if (tool.function?.description) {
+    parts.push(tool.function.description);
+  }
+  const props = tool.function?.parameters?.properties;
+  if (props) {
+    for (const [key, val] of Object.entries(props)) {
+      parts.push(key);
+      if (val?.description) {
+        parts.push(val.description);
+      }
+    }
+  }
+  return parts.join(" ").toLowerCase();
+}
+function tokenize(text) {
+  return text.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 1).map((t) => t.toLowerCase());
+}
+function bm25Scores(queryOrTerms, docs) {
+  const queryTerms = typeof queryOrTerms === "string" ? tokenize(queryOrTerms) : queryOrTerms;
+  const n = docs.length;
+  const tokenizedDocs = docs.map((d) => tokenize(d));
+  const dfMap = /* @__PURE__ */ new Map();
+  for (const term of queryTerms) {
+    if (dfMap.has(term)) continue;
+    let df = 0;
+    for (const doc of tokenizedDocs) {
+      if (doc.includes(term)) {
+        df++;
+      }
+    }
+    dfMap.set(term, df);
+  }
+  return tokenizedDocs.map((docTerms) => {
+    const dl = docTerms.length;
+    const lengthNorm = K1 * (1 - B + B * dl / AVG_TOOL_WORDS);
+    let score = 0;
+    for (const term of queryTerms) {
+      const tf = docTerms.filter((t) => t === term).length;
+      if (tf === 0) continue;
+      const dfT = dfMap.get(term) ?? 0;
+      const idf = Math.log((n - dfT + 0.5) / (dfT + 0.5) + 1);
+      const tfNorm = tf * (K1 + 1) / (tf + lengthNorm);
+      score += idf * tfNorm;
+    }
+    return score;
+  });
+}
+function approximateTokens(text) {
+  return Math.max(Math.floor(text.length / CHARS_PER_TOKEN), 1);
+}
+function applyHardBudget(tools, budget = HARD_BYTE_BUDGET) {
+  const total = JSON.stringify(tools).length;
+  if (total <= budget) {
+    return [...tools];
+  }
+  const result = [];
+  let running = 2;
+  for (const tool of tools) {
+    const bytes = JSON.stringify(tool).length + 1;
+    if (running + bytes > budget) {
+      break;
+    }
+    running += bytes;
+    result.push(tool);
+  }
+  console.warn(
+    `[ToolRelevance] Hard byte budget applied: keeping ${result.length} of ${tools.length} tools (${running} bytes)`
+  );
+  return result;
+}
+
+// src/services/router.ts
+var CODE_PREFERRED_MODELS = [
+  "anthropic/claude-opus-4-6",
+  "openai/gpt-5.3"
+];
+var SIMPLE_PREFERRED_MODELS = [
+  "minimax/minimax-m2.5",
+  "google/gemini-3-flash-preview",
+  "google/gemini-2.5-flash",
+  "anthropic/claude-haiku-4.5",
+  "moonshot/kimi-k2.5",
+  "thudm/glm-4.7",
+  "anthropic/claude-sonnet-4"
+];
+var LARGE_CONTEXT_FALLBACK_MODELS = [
+  "google/gemini-3.1-pro-preview",
+  "google/gemini-3-flash-preview",
+  "anthropic/claude-opus-4.6"
+];
+var REROUTABLE_STATUS_CODES = [408, 429, 502, 503, 504];
+var MAX_REROUTE_ATTEMPTS = 2;
+var MODEL_DISPLAY_NAMES = {
+  "anthropic/claude-opus-4-6": "Claude Opus",
+  "anthropic/claude-opus-4.5": "Claude Opus",
+  "anthropic/claude-sonnet-4": "Claude Sonnet",
+  "anthropic/claude-haiku-4.5": "Claude Haiku",
+  "openai/gpt-5.3": "GPT-5.3",
+  "openai/gpt-5": "GPT-5",
+  "openai/gpt-4o": "GPT-4o",
+  "openai/gpt-4o-mini": "GPT-4o Mini",
+  "anthropic/claude-opus-4.6": "Claude Opus 4.6",
+  "anthropic/claude-sonnet-4.6": "Claude Sonnet 4.6",
+  "google/gemini-3.1-pro-preview": "Gemini 3.1 Pro",
+  "google/gemini-2.5-pro": "Gemini Pro",
+  "google/gemini-2.5-flash": "Gemini Flash",
+  "google/gemini-3-flash-preview": "Gemini 3 Flash",
+  "moonshot/kimi-k2.5": "Kimi K2.5",
+  "thudm/glm-4.7": "GLM-4.7",
+  "thudm/glm-4": "GLM-4"
+};
+function humanizeModelId(modelId) {
+  return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
+}
+function humanizeTaskType(taskType) {
+  return taskType.replace(/_/g, " ");
+}
+function route(classification, capabilities, query) {
+  const workerType = selectWorkerType(classification, capabilities);
+  const modelId = selectModel(classification, capabilities);
+  const selectedSkills = resolveSkills(classification, capabilities);
+  const reason = buildReason(classification, workerType, modelId);
+  const publisherSlug = extractPublisherSlug(workerType, capabilities, query);
+  const delegation = workerType === "local_agent" ? "full_handoff" : "in_loop";
+  return {
+    worker_type: workerType,
+    model_id: modelId,
+    delegation,
+    reason,
+    selected_skills: selectedSkills,
+    publisher_slug: publisherSlug,
+    reasoning_effort: capabilities.reasoning_effort
+  };
+}
+function selectWorkerType(classification, capabilities) {
+  if (classification.task_type === "code_generation" && classification.requires_file_system && capabilities.has_local_agent && capabilities.active_agent_session_id) {
+    return "local_agent";
+  }
+  if (classification.requires_tools && !classification.requires_file_system && hasAnyGatewayTool(capabilities)) {
+    return "mcp_publisher";
+  }
+  return "chat_model";
+}
+function selectModel(classification, capabilities) {
+  if (capabilities.selected_model) {
+    return capabilities.selected_model;
+  }
+  if (capabilities.model_rankings.length > 0) {
+    for (const [modelId] of capabilities.model_rankings) {
+      if (capabilities.available_models.includes(modelId)) {
+        return modelId;
+      }
+    }
+  }
+  let preferred;
+  if (classification.task_type === "code_generation") {
+    preferred = CODE_PREFERRED_MODELS;
+  } else if (classification.complexity === "complex" || classification.complexity === "moderate") {
+    preferred = CODE_PREFERRED_MODELS;
+  } else {
+    preferred = SIMPLE_PREFERRED_MODELS;
+  }
+  for (const model of preferred) {
+    if (capabilities.available_models.includes(model)) {
+      return model;
+    }
+  }
+  return capabilities.available_models[0] ?? "anthropic/claude-sonnet-4";
+}
+function parseGatewaySlug(toolName) {
+  if (!toolName.startsWith("gateway__")) return null;
+  const rest = toolName.slice("gateway__".length);
+  const slugEnd = rest.indexOf("__");
+  if (slugEnd === -1) return null;
+  return rest.slice(0, slugEnd);
+}
+function hasAnyGatewayTool(capabilities) {
+  return capabilities.available_tools.some((t) => parseGatewaySlug(t) !== null);
+}
+function extractGatewaySlug(capabilities, query) {
+  const slugTools = /* @__PURE__ */ new Map();
+  for (const toolName of capabilities.available_tools) {
+    const slug = parseGatewaySlug(toolName);
+    if (slug) {
+      if (!slugTools.has(slug)) slugTools.set(slug, []);
+      slugTools.get(slug).push(toolName);
+    }
+  }
+  if (slugTools.size === 0) return void 0;
+  if (slugTools.size === 1) return slugTools.keys().next().value;
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+  if (queryTerms.length === 0) return slugTools.keys().next().value;
+  let bestSlug;
+  let bestScore = 0;
+  for (const [slug, tools] of slugTools) {
+    let score = 0;
+    const slugLower = slug.toLowerCase();
+    for (const term of queryTerms) {
+      if (slugLower.includes(term)) score += 10;
+    }
+    for (const toolName of tools) {
+      const toolLower = toolName.toLowerCase();
+      for (const term of queryTerms) {
+        if (toolLower.includes(term)) score += 1;
+      }
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestSlug = slug;
+    }
+  }
+  return bestSlug ?? slugTools.keys().next().value;
+}
+function extractPublisherSlug(workerType, capabilities, query) {
+  if (workerType !== "mcp_publisher") return void 0;
+  return extractGatewaySlug(capabilities, query);
+}
+function resolveSkills(classification, capabilities) {
+  return classification.relevant_skills.map((slug) => capabilities.installed_skills.find((s) => s.slug === slug)).filter((s) => s !== void 0);
+}
+function buildReason(classification, workerType, modelId) {
+  const modelName = humanizeModelId(modelId);
+  const taskDesc = humanizeTaskType(classification.task_type);
+  switch (workerType) {
+    case "local_agent":
+      return `Working with agent on ${taskDesc}`;
+    case "mcp_publisher":
+      return `Working with publisher on ${taskDesc}`;
+    case "chat_model":
+    default:
+      return `Working with ${modelName} on ${taskDesc}`;
+  }
+}
+function isContextOverflowError(errorMessage) {
+  return errorMessage.includes("prompt is too long") || errorMessage.includes("context_length_exceeded") || errorMessage.includes("maximum context length");
+}
+function isReroutableError(errorMessage) {
+  if (isContextOverflowError(errorMessage)) return true;
+  if (errorMessage.includes("401") || errorMessage.includes("403") || errorMessage.includes("400") || errorMessage.includes("API key") || errorMessage.includes("Insufficient credits")) {
+    return false;
+  }
+  return REROUTABLE_STATUS_CODES.some(
+    (code) => errorMessage.includes(String(code))
+  );
+}
+function getLargeContextFallback(triedModels) {
+  return LARGE_CONTEXT_FALLBACK_MODELS.find((m) => !triedModels.includes(m));
+}
+function rerouteOnFailure(classification, triedModels, availableModels) {
+  const preferred = classification.task_type === "code_generation" || classification.complexity === "complex" || classification.complexity === "moderate" ? CODE_PREFERRED_MODELS : SIMPLE_PREFERRED_MODELS;
+  for (const model of preferred) {
+    if (!triedModels.includes(model) && availableModels.includes(model)) {
+      const reason = `Rerouted to ${humanizeModelId(model)} for ${humanizeTaskType(classification.task_type)}`;
+      return [model, reason];
+    }
+  }
+  for (const model of availableModels) {
+    if (!triedModels.includes(model)) {
+      const reason = `Rerouted to ${humanizeModelId(model)} (fallback)`;
+      return [model, reason];
+    }
+  }
+  return void 0;
+}
+
+// src/services/orchestrator.ts
+var PUBLISHER_SLUG2 = "seren-models";
+var DEFAULT_GATEWAY_BASE = "https://api.serendb.com";
+var REQUEST_TIMEOUT_MS2 = 6e5;
+var activeSessions = /* @__PURE__ */ new Map();
+function cancelOrchestration(conversationId) {
+  const controller = activeSessions.get(conversationId);
+  if (controller) {
+    controller.abort();
+    activeSessions.delete(conversationId);
+    console.log(`[Orchestrator] Cancelled orchestration for ${conversationId}`);
+    return true;
+  }
+  return false;
+}
+async function orchestrate(params) {
+  const {
+    conversationId,
+    prompt,
+    history,
+    capabilities,
+    images = [],
+    authToken
+  } = params;
+  const gatewayBase = params.gatewayBase ?? DEFAULT_GATEWAY_BASE;
+  console.log(
+    `[Orchestrator] Starting orchestration for conversation ${conversationId}`
+  );
+  const abortController = new AbortController();
+  activeSessions.set(conversationId, abortController);
+  try {
+    const modelForLimit = capabilities.selected_model || "anthropic/claude-sonnet-4";
+    const totalInputChars = prompt.length + history.reduce((acc, m) => acc + (m.content?.length ?? 0), 0) + images.length * 1e3;
+    if (needsRlm(totalInputChars, modelForLimit)) {
+      console.log(
+        "[Orchestrator] Input exceeds context threshold \u2014 activating RLM"
+      );
+      const [content, question] = splitContentAndQuestion(prompt);
+      const rlmAnswer = await processRlm(
+        question,
+        content,
+        modelForLimit,
+        gatewayBase,
+        authToken,
+        (event) => {
+          const workerEvent = event.type === "rlm_start" ? { type: "rlm_start", chunk_count: event.data.total } : {
+            type: "rlm_chunk_complete",
+            index: event.data.index,
+            total: event.data.total,
+            summary: event.data.summary ?? ""
+          };
+          emitOrchestratorEvent(conversationId, workerEvent);
+        }
+      );
+      const completeEvent = {
+        type: "complete",
+        final_content: rlmAnswer
+      };
+      emitOrchestratorEvent(conversationId, completeEvent);
+      return;
+    }
+    const classification = classifyTask2(prompt, capabilities);
+    console.log(
+      `[Orchestrator] Classification: type=${classification.task_type}, complexity=${classification.complexity}`
+    );
+    const routing = route(classification, capabilities, prompt);
+    console.log(
+      `[Orchestrator] Routed to ${routing.worker_type} with model ${routing.model_id}`
+    );
+    await executeWithReroute({
+      conversationId,
+      prompt,
+      history,
+      capabilities,
+      images,
+      classification,
+      routing,
+      gatewayBase,
+      authToken,
+      abortSignal: abortController.signal
+    });
+  } catch (err) {
+    if (abortController.signal.aborted) {
+      console.log(
+        `[Orchestrator] Orchestration cancelled for ${conversationId}`
+      );
+      return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[Orchestrator] Error: ${message}`);
+    const errorEvent = { type: "error", message };
+    emitOrchestratorEvent(conversationId, errorEvent);
+  } finally {
+    activeSessions.delete(conversationId);
+  }
+}
+async function executeWithReroute(params) {
+  const {
+    conversationId,
+    prompt,
+    history,
+    capabilities,
+    images,
+    classification,
+    gatewayBase,
+    authToken,
+    abortSignal
+  } = params;
+  let routing = { ...params.routing };
+  const triedModels = [routing.model_id];
+  let rerouteCount = 0;
+  const userExplicitlySelected = Boolean(capabilities.selected_model);
+  while (true) {
+    if (abortSignal.aborted) {
+      console.log(
+        `[Orchestrator] Cancelled before execution for ${conversationId}`
+      );
+      return;
+    }
+    const skillContent = await loadSkillContent(routing.selected_skills);
+    const relevantTools = selectRelevantTools(
+      prompt,
+      capabilities.tool_definitions
+    );
+    const transition = {
+      conversation_id: conversationId,
+      model_name: routing.model_id,
+      task_description: routing.reason
+    };
+    emit("orchestrator://transition", transition);
+    const messages = buildMessages(
+      prompt,
+      history,
+      skillContent,
+      images,
+      routing
+    );
+    try {
+      await streamChatCompletion({
+        conversationId,
+        messages,
+        model: routing.model_id,
+        tools: relevantTools,
+        gatewayBase,
+        authToken,
+        abortSignal,
+        reasoningEffort: routing.reasoning_effort,
+        publisherSlug: routing.publisher_slug
+      });
+      console.log(
+        `[Orchestrator] Completed orchestration for conversation ${conversationId}`
+      );
+      return;
+    } catch (err) {
+      if (abortSignal.aborted) return;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      console.error(`[Orchestrator] Worker error: ${errorMessage}`);
+      if (!isReroutableError(errorMessage)) {
+        const errorEvent = {
+          type: "error",
+          message: errorMessage
+        };
+        emitOrchestratorEvent(conversationId, errorEvent);
+        return;
+      }
+      if (rerouteCount >= MAX_REROUTE_ATTEMPTS) {
+        console.warn(
+          `[Orchestrator] Max reroute attempts (${MAX_REROUTE_ATTEMPTS}) exhausted`
+        );
+        const errorEvent = {
+          type: "error",
+          message: errorMessage
+        };
+        emitOrchestratorEvent(conversationId, errorEvent);
+        return;
+      }
+      if (isContextOverflowError(errorMessage)) {
+        const fallback = getLargeContextFallback(triedModels);
+        if (fallback) {
+          const fromModel2 = routing.model_id;
+          console.log(
+            `[Orchestrator] Context overflow on ${fromModel2}, falling back to ${fallback}`
+          );
+          const rerouteEvent2 = {
+            type: "reroute",
+            from_model: fromModel2,
+            to_model: fallback,
+            reason: "Switched to larger context model \u2014 conversation exceeded model limit"
+          };
+          emitOrchestratorEvent(conversationId, rerouteEvent2);
+          routing = { ...routing, model_id: fallback };
+          triedModels.push(fallback);
+          rerouteCount++;
+          continue;
+        }
+        console.warn(
+          "[Orchestrator] Context overflow but all large-context fallbacks exhausted"
+        );
+        const errorEvent = {
+          type: "error",
+          message: errorMessage
+        };
+        emitOrchestratorEvent(conversationId, errorEvent);
+        return;
+      }
+      if (userExplicitlySelected) {
+        const errorEvent = {
+          type: "error",
+          message: errorMessage
+        };
+        emitOrchestratorEvent(conversationId, errorEvent);
+        return;
+      }
+      const fallbackResult = rerouteOnFailure(
+        classification,
+        triedModels,
+        capabilities.available_models
+      );
+      if (!fallbackResult) {
+        console.warn("[Orchestrator] No fallback models available for reroute");
+        const errorEvent = {
+          type: "error",
+          message: errorMessage
+        };
+        emitOrchestratorEvent(conversationId, errorEvent);
+        return;
+      }
+      const [fallbackModel, reason] = fallbackResult;
+      const fromModel = routing.model_id;
+      console.log(
+        `[Orchestrator] Rerouting from ${fromModel} to ${fallbackModel}: ${reason}`
+      );
+      const rerouteEvent = {
+        type: "reroute",
+        from_model: fromModel,
+        to_model: fallbackModel,
+        reason
+      };
+      emitOrchestratorEvent(conversationId, rerouteEvent);
+      routing = { ...routing, model_id: fallbackModel };
+      triedModels.push(fallbackModel);
+      rerouteCount++;
+    }
+  }
+}
+async function streamChatCompletion(params) {
+  const {
+    conversationId,
+    messages,
+    model,
+    tools,
+    gatewayBase,
+    authToken,
+    abortSignal,
+    reasoningEffort
+  } = params;
+  const publisherSlug = params.publisherSlug ?? PUBLISHER_SLUG2;
+  const url = `${gatewayBase}/publishers/${publisherSlug}/chat/completions`;
+  const body = {
+    model,
+    messages,
+    stream: true
+  };
+  if (tools.length > 0) {
+    body.tools = tools;
+  }
+  if (reasoningEffort) {
+    body.reasoning_effort = reasoningEffort;
+  }
+  const timeoutId = setTimeout(() => {
+    if (!abortSignal.aborted) {
+      const controller = activeSessions.get(conversationId);
+      controller?.abort();
+    }
+  }, REQUEST_TIMEOUT_MS2);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(body),
+      signal: abortSignal
+    });
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (abortSignal.aborted) return;
+    throw err;
+  }
+  if (!response.ok) {
+    clearTimeout(timeoutId);
+    const text = await response.text().catch(() => "");
+    throw new Error(`Gateway HTTP ${response.status}: ${text}`);
+  }
+  if (!response.body) {
+    clearTimeout(timeoutId);
+    throw new Error("No response body from Gateway");
+  }
+  try {
+    await processSSEStream(conversationId, response.body, abortSignal);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function processSSEStream(conversationId, body, abortSignal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let fullContent = "";
+  let fullThinking = "";
+  let totalCost = 0;
+  try {
+    while (true) {
+      if (abortSignal.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (typeof chunk.cost === "number") {
+          totalCost = chunk.cost;
+        }
+        const choices = chunk.choices;
+        if (!choices || choices.length === 0) continue;
+        const delta = choices[0].delta;
+        if (!delta) continue;
+        if (typeof delta.content === "string" && delta.content) {
+          fullContent += delta.content;
+          emitOrchestratorEvent(conversationId, {
+            type: "content",
+            text: delta.content
+          });
+        }
+        if (typeof delta.thinking === "string" && delta.thinking) {
+          fullThinking += delta.thinking;
+          emitOrchestratorEvent(conversationId, {
+            type: "thinking",
+            text: delta.thinking
+          });
+        }
+        const toolCalls = delta.tool_calls;
+        if (toolCalls) {
+          for (const tc of toolCalls) {
+            const fn = tc.function;
+            if (fn?.name) {
+              emitOrchestratorEvent(conversationId, {
+                type: "tool_call",
+                tool_call_id: tc.id ?? "",
+                name: fn.name,
+                arguments: fn.arguments ?? "{}",
+                title: fn.name ?? ""
+              });
+            }
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const completeEvent = {
+    type: "complete",
+    final_content: fullContent,
+    thinking: fullThinking || void 0,
+    cost: totalCost || void 0
+  };
+  emitOrchestratorEvent(conversationId, completeEvent);
+}
+function buildMessages(prompt, history, skillContent, images, routing) {
+  const messages = [];
+  const systemParts = ["You are a helpful AI assistant."];
+  if (skillContent) {
+    systemParts.push(
+      "",
+      "## Relevant Skills",
+      "",
+      skillContent
+    );
+  }
+  messages.push({ role: "system", content: systemParts.join("\n") });
+  for (const msg of history) {
+    messages.push({ role: msg.role, content: msg.content });
+  }
+  if (images.length > 0) {
+    const contentParts = [
+      { type: "text", text: prompt }
+    ];
+    for (const img of images) {
+      contentParts.push({
+        type: "image_url",
+        image_url: {
+          url: `data:${img.mime_type};base64,${img.base64}`
+        }
+      });
+    }
+    messages.push({ role: "user", content: contentParts });
+  } else {
+    messages.push({ role: "user", content: prompt });
+  }
+  return messages;
+}
+async function loadSkillContent(skills) {
+  if (skills.length === 0) return "";
+  const parts = [];
+  for (const skill of skills) {
+    try {
+      const skillPath = join(skill.path, "SKILL.md");
+      const content = await readFile(skillPath, "utf-8");
+      parts.push(`### ${skill.name}
+
+${content}`);
+    } catch (err) {
+      console.warn(
+        `[Orchestrator] Failed to load skill ${skill.slug}: ${err instanceof Error ? err.message : err}`
+      );
+    }
+  }
+  return parts.join("\n\n---\n\n");
+}
+function classifyTask2(prompt, capabilities) {
+  const lower = prompt.toLowerCase();
+  let taskType = "general";
+  let requiresTools = false;
+  let requiresFileSystem = false;
+  const codeSignals = [
+    "write code",
+    "create a function",
+    "implement",
+    "build a",
+    "code",
+    "program",
+    "script",
+    "refactor",
+    "debug",
+    "fix the bug",
+    "add a feature",
+    "create a file",
+    "write a file",
+    "edit the file",
+    "modify the code"
+  ];
+  if (codeSignals.some((s) => lower.includes(s))) {
+    taskType = "code_generation";
+    requiresFileSystem = true;
+  }
+  const toolSignals = [
+    "search the web",
+    "browse",
+    "crawl",
+    "scrape",
+    "fetch",
+    "look up",
+    "find online",
+    "perplexity",
+    "firecrawl"
+  ];
+  if (toolSignals.some((s) => lower.includes(s))) {
+    requiresTools = true;
+    if (taskType === "general") taskType = "tool_use";
+  }
+  let complexity = "simple";
+  const wordCount = prompt.split(/\s+/).length;
+  if (wordCount > 200 || lower.includes("step by step") || lower.includes("detailed")) {
+    complexity = "complex";
+  } else if (wordCount > 50) {
+    complexity = "moderate";
+  }
+  const relevantSkills = [];
+  for (const skill of capabilities.installed_skills) {
+    const skillText = `${skill.name} ${skill.description} ${skill.tags.join(" ")}`.toLowerCase();
+    const promptTerms = lower.split(/\s+/).filter((t) => t.length > 3);
+    const overlap = promptTerms.filter((t) => skillText.includes(t)).length;
+    if (overlap >= 2) {
+      relevantSkills.push(skill.slug);
+    }
+  }
+  return {
+    task_type: taskType,
+    requires_tools: requiresTools,
+    requires_file_system: requiresFileSystem,
+    complexity,
+    relevant_skills: relevantSkills
+  };
+}
+function emitOrchestratorEvent(conversationId, workerEvent, subtaskId) {
+  const event = {
+    conversation_id: conversationId,
+    worker_event: workerEvent,
+    subtask_id: subtaskId
+  };
+  emit("orchestrator://event", event);
+}
+
 // src/handlers/acp.ts
 import * as acp from "@agentclientprotocol/sdk";
-import { spawn, execFile } from "child_process";
+import { spawn, spawnSync, execFile } from "child_process";
 import { Readable, Writable } from "stream";
-import { existsSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
+import { existsSync, readdirSync } from "fs";
+import { readFile as readFile2, writeFile } from "fs/promises";
 import { randomUUID } from "crypto";
-import { resolve } from "path";
-import { platform } from "os";
+import path, { resolve } from "path";
+import { platform, homedir } from "os";
 function isAuthError(message) {
   const lower = message.toLowerCase();
-  return lower.includes("invalid api key") || lower.includes("authentication required") || lower.includes("auth required") || lower.includes("please run /login") || lower.includes("authrequired");
+  return lower.includes("invalid api key") || lower.includes("authentication required") || lower.includes("auth required") || lower.includes("please run /login") || lower.includes("authrequired") || lower.includes("failed to authenticate") || lower.includes("login required") || lower.includes("not logged in") || lower.includes("please login again") || lower.includes("please sign in") || lower.includes("session expired") || lower.includes("does not have access") || lower.includes("re-authenticate");
 }
 function authErrorMessage(agentType) {
   if (agentType === "claude-code") {
     return "Claude Code login required. A terminal window has been opened \u2014 please complete the login there, then try starting the agent again.";
   }
+  if (agentType === "codex") {
+    return "Codex login required. A terminal window has been opened \u2014 please complete the login there, then try starting the agent again.";
+  }
   return "Agent authentication required. Please log in via the agent CLI first.";
 }
-function launchClaudeLogin() {
-  const os2 = platform();
+function launchLoginCommand(command) {
+  const loginCommand = `${command} login`;
+  const currentPlatform = platform();
   try {
-    if (os2 === "darwin") {
+    if (currentPlatform === "darwin") {
       spawn("osascript", [
         "-e",
-        'tell application "Terminal" to do script "claude login"',
+        `tell application "Terminal" to do script "${loginCommand}"`,
         "-e",
         'tell application "Terminal" to activate'
       ], { detached: true, stdio: "ignore" }).unref();
-    } else if (os2 === "win32") {
-      spawn("cmd", ["/c", "start", "cmd", "/c", "claude login"], {
+    } else if (currentPlatform === "win32") {
+      spawn("cmd", ["/c", "start", "cmd", "/c", loginCommand], {
         detached: true,
         stdio: "ignore"
       }).unref();
     } else {
-      spawn("x-terminal-emulator", ["-e", "claude", "login"], {
+      spawn("x-terminal-emulator", ["-e", command, "login"], {
         detached: true,
         stdio: "ignore"
       }).unref();
@@ -244,6 +1351,160 @@ function launchClaudeLogin() {
   } catch {
   }
 }
+function launchClaudeLogin() {
+  launchLoginCommand("claude");
+}
+function killChildTree(child) {
+  if (platform() === "win32" && child.pid !== void 0) {
+    try {
+      spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        stdio: "ignore"
+      });
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill();
+  } catch {
+  }
+}
+function buildExtendedPath() {
+  const sep = platform() === "win32" ? ";" : ":";
+  const base2 = process.env.PATH ?? "";
+  if (platform() === "win32") return base2;
+  const home3 = homedir();
+  const extra = [
+    // nvm (most common)
+    path.join(home3, ".nvm", "versions", "node"),
+    // fnm
+    path.join(home3, ".local", "share", "fnm", "aliases", "default", "bin"),
+    path.join(home3, "Library", "Application Support", "fnm", "aliases", "default", "bin"),
+    // Volta
+    path.join(home3, ".volta", "bin"),
+    // Homebrew (Apple Silicon + Intel)
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    // Common Linux paths
+    "/usr/bin"
+  ];
+  const nvmDir = extra[0];
+  if (existsSync(nvmDir)) {
+    try {
+      const versions = readdirSync(nvmDir).sort().reverse();
+      for (const ver of versions) {
+        const binDir = path.join(nvmDir, ver, "bin");
+        if (existsSync(binDir)) {
+          extra[0] = binDir;
+          break;
+        }
+      }
+    } catch {
+      extra[0] = "";
+    }
+  } else {
+    extra[0] = "";
+  }
+  const additions = extra.filter((p) => p && !base2.includes(p));
+  return additions.length > 0 ? `${additions.join(sep)}${sep}${base2}` : base2;
+}
+function resolveNpmCliScript() {
+  const nodeDir = path.dirname(process.execPath);
+  if (platform() === "win32") {
+    const candidate = path.join(nodeDir, "node_modules", "npm", "bin", "npm-cli.js");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  } else {
+    const prefix = path.dirname(nodeDir);
+    const candidate = path.join(prefix, "lib", "node_modules", "npm", "bin", "npm-cli.js");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function ensureGlobalNpmPackage({
+  command,
+  packageName,
+  label
+}) {
+  if (await isCommandAvailable(command)) {
+    return command;
+  }
+  emit("provider://cli-install-progress", {
+    stage: "installing",
+    message: `Installing ${label} CLI...`
+  });
+  const npmCliScript = resolveNpmCliScript();
+  if (npmCliScript) {
+    await new Promise((resolvePromise, rejectPromise) => {
+      execFile(
+        process.execPath,
+        [npmCliScript, "install", "-g", packageName],
+        (error, stdout, stderr) => {
+          if (error) {
+            rejectPromise(new Error(stderr || error.message));
+            return;
+          }
+          resolvePromise(stdout.trim());
+        }
+      );
+    });
+  } else {
+    const npmCommand = platform() === "win32" ? "npm.cmd" : "npm";
+    await new Promise((resolvePromise, rejectPromise) => {
+      execFile(
+        npmCommand,
+        ["install", "-g", packageName],
+        (error, stdout, stderr) => {
+          if (error) {
+            rejectPromise(new Error(stderr || error.message));
+            return;
+          }
+          resolvePromise(stdout.trim());
+        }
+      );
+    });
+  }
+  emit("provider://cli-install-progress", {
+    stage: "complete",
+    message: `${label} CLI installed successfully`
+  });
+  return command;
+}
+async function ensureClaudeCodeViaNativeInstaller() {
+  if (await isCommandAvailable("claude")) {
+    return "claude";
+  }
+  emit("provider://cli-install-progress", {
+    stage: "installing",
+    message: "Installing Claude Code CLI via official installer..."
+  });
+  await new Promise((resolvePromise, rejectPromise) => {
+    let cmd;
+    let args;
+    if (platform() === "win32") {
+      cmd = "powershell";
+      args = ["-NoProfile", "-Command", "irm https://claude.ai/install.ps1 | iex"];
+    } else {
+      cmd = "bash";
+      args = ["-c", "curl -fsSL https://claude.ai/install.sh | bash"];
+    }
+    execFile(cmd, args, { timeout: 12e4 }, (error, stdout, stderr) => {
+      if (error) {
+        rejectPromise(new Error(stderr || error.message));
+        return;
+      }
+      resolvePromise(stdout.trim());
+    });
+  });
+  emit("provider://cli-install-progress", {
+    stage: "complete",
+    message: "Claude Code CLI installed successfully"
+  });
+  return "claude";
+}
 var sessions = /* @__PURE__ */ new Map();
 function createClient(sessionId) {
   return {
@@ -257,8 +1518,8 @@ function createClient(sessionId) {
         toolCall: params.toolCall,
         options: params.options
       });
-      const optionId = await new Promise((resolve4, reject) => {
-        session.pendingPermissions.set(requestId, resolve4);
+      const optionId = await new Promise((resolve5, reject) => {
+        session.pendingPermissions.set(requestId, resolve5);
         setTimeout(() => {
           session.pendingPermissions.delete(requestId);
           reject(new Error("Permission request timed out"));
@@ -272,7 +1533,7 @@ function createClient(sessionId) {
       handleSessionUpdate(sessionId, params);
     },
     async readTextFile(params) {
-      const content = await readFile(params.path, "utf-8");
+      const content = await readFile2(params.path, "utf-8");
       return { content };
     },
     async writeTextFile(params) {
@@ -280,7 +1541,7 @@ function createClient(sessionId) {
       if (!session) throw new Error("Session not found");
       let oldText = "";
       try {
-        oldText = await readFile(params.path, "utf-8");
+        oldText = await readFile2(params.path, "utf-8");
       } catch {
       }
       const proposalId = randomUUID();
@@ -291,8 +1552,8 @@ function createClient(sessionId) {
         oldText,
         newText: params.content
       });
-      const accepted = await new Promise((resolve4, reject) => {
-        session.pendingDiffProposals.set(proposalId, resolve4);
+      const accepted = await new Promise((resolve5, reject) => {
+        session.pendingDiffProposals.set(proposalId, resolve5);
         setTimeout(() => {
           session.pendingDiffProposals.delete(proposalId);
           reject(new Error("Diff proposal timed out"));
@@ -381,21 +1642,21 @@ function findAgentCommand(agentType) {
 function findAgentBinary(binBase) {
   const ext = platform() === "win32" ? ".exe" : "";
   const binName = `${binBase}${ext}`;
-  const home2 = process.env.HOME ?? "~";
+  const home3 = process.env.HOME ?? "~";
   const candidates = [
     // 1. runtime/bin/ (bundled with seren-local — dist/ is one level below bin/)
     resolve(import.meta.dirname, "../bin", binName),
     // 2. ~/.seren-local/bin/ (user install location)
-    resolve(home2, ".seren-local/bin", binName),
+    resolve(home3, ".seren-local/bin", binName),
     // 3. Seren Desktop embedded-runtime (development)
-    resolve(home2, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", binName)
+    resolve(home3, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", binName)
   ];
   if (binBase === "seren-acp-claude") {
     const legacyName = `acp_agent${ext}`;
     candidates.push(
       resolve(import.meta.dirname, "../bin", legacyName),
-      resolve(home2, ".seren-local/bin", legacyName),
-      resolve(home2, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", legacyName)
+      resolve(home3, ".seren-local/bin", legacyName),
+      resolve(home3, "Projects/Seren_Projects/seren-desktop/src-tauri/embedded-runtime/bin", legacyName)
     );
   }
   for (const candidate of candidates) {
@@ -411,8 +1672,8 @@ ${candidates.map((p) => `  - ${p}`).join("\n")}`
 }
 async function isCommandAvailable(command) {
   const which = platform() === "win32" ? "where" : "which";
-  return new Promise((resolve4) => {
-    execFile(which, [command], (err) => resolve4(!err));
+  return new Promise((resolve5) => {
+    execFile(which, [command], (err) => resolve5(!err));
   });
 }
 async function acpSpawn(params) {
@@ -424,10 +1685,12 @@ async function acpSpawn(params) {
   if (sandboxMode) {
     args.push("--sandbox", sandboxMode);
   }
+  const extendedPath = buildExtendedPath();
   const agentProcess = spawn(command, args, {
     cwd: resolvedCwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: { ...process.env }
+    env: { ...process.env, PATH: extendedPath },
+    shell: platform() === "win32"
   });
   if (!agentProcess.stdin || !agentProcess.stdout) {
     throw new Error("Failed to create agent process stdio");
@@ -462,6 +1725,18 @@ async function acpSpawn(params) {
     cancelling: false
   };
   sessions.set(sessionId, session);
+  agentProcess.on("error", (spawnError) => {
+    console.error(`[ACP] Spawn error: ${spawnError.message}`);
+    sessions.delete(sessionId);
+    emit("acp://error", {
+      sessionId,
+      error: spawnError.code === "ENOENT" ? `Agent binary not found at "${command}". Ensure the agent is installed.` : `Failed to start agent: ${spawnError.message}`
+    });
+    emit("acp://session-status", {
+      sessionId,
+      status: "terminated"
+    });
+  });
   agentProcess.on("exit", (code, signal) => {
     session.status = "terminated";
     emit("acp://session-status", {
@@ -500,7 +1775,13 @@ async function acpSpawn(params) {
     session.status = "error";
     const rawMessage = err instanceof Error ? err.message : JSON.stringify(err);
     const authDetected = isAuthError(rawMessage);
-    if (authDetected) launchClaudeLogin();
+    if (authDetected) {
+      if (agentType === "codex") {
+        launchLoginCommand("codex");
+      } else {
+        launchClaudeLogin();
+      }
+    }
     const errorMsg = authDetected ? authErrorMessage(agentType) : `Failed to initialize agent: ${rawMessage}`;
     emit("acp://error", {
       sessionId,
@@ -577,7 +1858,7 @@ async function acpTerminate(params) {
   const { sessionId } = params;
   const session = sessions.get(sessionId);
   if (!session) throw new Error(`Session not found: ${sessionId}`);
-  session.process.kill();
+  killChildTree(session.process);
   sessions.delete(sessionId);
   session.status = "terminated";
   emit("acp://session-status", { sessionId, status: "terminated" });
@@ -621,20 +1902,38 @@ async function acpRespondToDiffProposal(params) {
 }
 async function acpGetAvailableAgents() {
   const agents = [
-    { type: "claude-code", name: "Claude Code", description: "AI coding assistant by Anthropic", command: "seren-acp-claude" },
-    { type: "codex", name: "Codex", description: "AI coding assistant powered by OpenAI Codex", command: "seren-acp-codex" }
-  ];
-  return agents.map((agent) => {
-    let available = false;
-    let unavailableReason;
-    try {
-      findAgentCommand(agent.type);
-      available = true;
-    } catch (err) {
-      unavailableReason = err.message;
+    {
+      type: "claude-code",
+      name: "Claude Code",
+      description: "Anthropic Claude Code via direct provider runtime",
+      command: "claude"
+    },
+    {
+      type: "codex",
+      name: "Codex",
+      description: "OpenAI Codex via direct App Server integration",
+      command: "codex"
     }
-    return { ...agent, available, unavailableReason };
-  });
+  ];
+  return Promise.all(
+    agents.map(async (agent) => {
+      let hasSidecar = false;
+      try {
+        findAgentCommand(agent.type);
+        hasSidecar = true;
+      } catch {
+      }
+      const cliInstalled = await isCommandAvailable(agent.command);
+      const installed = hasSidecar || cliInstalled;
+      return {
+        ...agent,
+        available: true,
+        ...installed ? {} : {
+          unavailableReason: `${agent.name} CLI is not installed yet. Seren can install it automatically on first launch.`
+        }
+      };
+    })
+  );
 }
 async function acpCheckAgentAvailable(params) {
   try {
@@ -645,29 +1944,39 @@ async function acpCheckAgentAvailable(params) {
   }
 }
 async function acpEnsureClaudeCli() {
-  if (await isCommandAvailable("claude")) {
-    return "claude";
-  }
-  const npmCmd = platform() === "win32" ? "npm.cmd" : "npm";
-  return new Promise((resolve4, reject) => {
-    const proc = execFile(
-      npmCmd,
-      ["install", "-g", "@anthropic-ai/claude-code"],
-      (err, stdout, stderr) => {
-        if (err) {
-          reject(
-            new Error(
-              `Failed to install Claude Code CLI: ${stderr || err.message}`
-            )
-          );
-          return;
-        }
-        console.log(`[ACP] Claude Code CLI installed: ${stdout}`);
-        resolve4("claude");
-      }
-    );
+  return ensureClaudeCodeViaNativeInstaller();
+}
+async function acpEnsureCodexCli() {
+  return ensureGlobalNpmPackage({
+    command: "codex",
+    packageName: "@openai/codex",
+    label: "Codex"
   });
 }
+async function acpEnsureAgentCli(params) {
+  const { agentType } = params;
+  if (agentType === "claude-code") {
+    return ensureClaudeCodeViaNativeInstaller();
+  }
+  if (agentType === "codex") {
+    return ensureGlobalNpmPackage({
+      command: "codex",
+      packageName: "@openai/codex",
+      label: "Codex"
+    });
+  }
+  throw new Error(`Unknown agent type for CLI install: ${agentType}`);
+}
+async function acpLaunchLogin(params) {
+  const { agentType } = params;
+  if (agentType === "claude-code") {
+    launchLoginCommand("claude");
+  } else if (agentType === "codex") {
+    launchLoginCommand("codex");
+  } else {
+    throw new Error(`Unknown agent type for login: ${agentType}`);
+  }
+}
 
 // src/handlers/dialogs.ts
 import { execFile as execFile2 } from "child_process";
@@ -675,17 +1984,17 @@ import { platform as platform2 } from "os";
 import { dirname } from "path";
 var os = platform2();
 function exec(cmd, args) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     execFile2(cmd, args, { timeout: 6e4 }, (err, stdout) => {
       if (err) {
         if (err.code === 1 || err.killed) {
-          resolve4("");
+          resolve5("");
           return;
         }
         reject(err);
         return;
       }
-      resolve4(stdout.trim());
+      resolve5(stdout.trim());
     });
   });
 }
@@ -774,9 +2083,9 @@ import {
   stat
 } from "fs/promises";
 import { realpathSync as realpathSyncNative } from "fs";
-import { homedir, tmpdir } from "os";
-import { join, resolve as resolve2 } from "path";
-var home = homedir();
+import { homedir as homedir2, tmpdir } from "os";
+import { join as join2, resolve as resolve2 } from "path";
+var home = homedir2();
 var tmp = tmpdir();
 var homeReal;
 var tmpReal;
@@ -816,11 +2125,11 @@ async function listDirectory(params) {
   const entries = await readdir(dir, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    path: join(dir, entry.name),
+    path: join2(dir, entry.name),
     is_directory: entry.isDirectory()
   }));
 }
-async function readFile2(params) {
+async function readFile3(params) {
   const filePath = await validatePathReal(params.path);
   return fsReadFile(filePath, "utf-8");
 }
@@ -874,22 +2183,22 @@ import Database2 from "better-sqlite3";
 import * as sqliteVec from "sqlite-vec";
 import { createHash } from "crypto";
 import { mkdirSync, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 var EMBEDDING_DIM = 1536;
 function getDataDir() {
-  return join2(homedir2(), ".seren-local", "data");
+  return join3(homedir3(), ".seren-local", "data");
 }
 function getVectorDbPath(projectPath) {
   const hash = createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
-  return join2(getDataDir(), "indexes", `${hash}.db`);
+  return join3(getDataDir(), "indexes", `${hash}.db`);
 }
 function hasIndex(projectPath) {
   return existsSync2(getVectorDbPath(projectPath));
 }
 function openDb(projectPath) {
   const dbPath = getVectorDbPath(projectPath);
-  const dir = join2(getDataDir(), "indexes");
+  const dir = join3(getDataDir(), "indexes");
   if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -1049,8 +2358,8 @@ function fileNeedsReindex(projectPath, filePath, currentHash) {
 }
 
 // src/services/chunker.ts
-import { readFileSync, readdirSync, statSync } from "fs";
-import { join as join3, extname, relative } from "path";
+import { readFileSync, readdirSync as readdirSync2, statSync } from "fs";
+import { join as join4, extname, relative } from "path";
 import { createHash as createHash2 } from "crypto";
 var MAX_CHUNK_LINES = 100;
 var MIN_CHUNK_LINES = 5;
@@ -1148,25 +2457,25 @@ function discoverFiles(projectPath) {
 function discoverRecursive(root, current, files) {
   let entries;
   try {
-    entries = readdirSync(current);
+    entries = readdirSync2(current);
   } catch {
     return;
   }
   for (const name of entries) {
     if (shouldIgnore(name)) continue;
-    const fullPath = join3(current, name);
-    let stat2;
+    const fullPath = join4(current, name);
+    let stat3;
     try {
-      stat2 = statSync(fullPath);
+      stat3 = statSync(fullPath);
     } catch {
       continue;
     }
-    if (stat2.isDirectory()) {
+    if (stat3.isDirectory()) {
       discoverRecursive(root, fullPath, files);
-    } else if (stat2.isFile()) {
+    } else if (stat3.isFile()) {
       const language = detectLanguage(fullPath);
       if (!language) continue;
-      if (stat2.size > MAX_FILE_SIZE) continue;
+      if (stat3.size > MAX_FILE_SIZE) continue;
       let content;
       try {
         content = readFileSync(fullPath, "utf-8");
@@ -1177,7 +2486,7 @@ function discoverRecursive(root, current, files) {
         path: fullPath,
         relative_path: relative(root, fullPath),
         language,
-        size: stat2.size,
+        size: stat3.size,
         hash: computeHash(content)
       });
     }
@@ -1444,7 +2753,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 var processes = /* @__PURE__ */ new Map();
 function sendRequest(proc, method, params) {
   const id = randomUUID2();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const timeout = setTimeout(() => {
       proc.pendingRequests.delete(id);
       reject(new Error(`MCP request timeout: ${method}`));
@@ -1452,7 +2761,7 @@ function sendRequest(proc, method, params) {
     proc.pendingRequests.set(id, {
       resolve: (v) => {
         clearTimeout(timeout);
-        resolve4(v);
+        resolve5(v);
       },
       reject: (e) => {
         clearTimeout(timeout);
@@ -1482,14 +2791,14 @@ async function mcpReadResource(params) {
 import { execFile as execFile3, spawn as spawn2 } from "child_process";
 import { createServer } from "net";
 import {
-  readFile as readFile3,
+  readFile as readFile4,
   writeFile as writeFile3,
   mkdir as mkdir2,
   access as access2,
   constants
 } from "fs/promises";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 import { randomBytes } from "crypto";
 import WebSocket from "ws";
 var childProcess = null;
@@ -1505,19 +2814,19 @@ var channels = [];
 var trustSettings = /* @__PURE__ */ new Map();
 var approvedIds = /* @__PURE__ */ new Set();
 var MAX_RESTART_ATTEMPTS = 3;
-var OPENCLAW_DIR = join4(homedir3(), ".openclaw");
-var CONFIG_PATH = join4(OPENCLAW_DIR, "openclaw.json");
-var SETTINGS_PATH = join4(homedir3(), ".seren-local", "settings.json");
+var OPENCLAW_DIR = join5(homedir4(), ".openclaw");
+var CONFIG_PATH = join5(OPENCLAW_DIR, "openclaw.json");
+var SETTINGS_PATH = join5(homedir4(), ".seren-local", "settings.json");
 async function loadSettings() {
   try {
-    const data = await readFile3(SETTINGS_PATH, "utf-8");
+    const data = await readFile4(SETTINGS_PATH, "utf-8");
     return JSON.parse(data);
   } catch {
     return {};
   }
 }
 async function saveSettings(settings) {
-  await mkdir2(join4(homedir3(), ".seren-local"), { recursive: true });
+  await mkdir2(join5(homedir4(), ".seren-local"), { recursive: true });
   await writeFile3(SETTINGS_PATH, JSON.stringify(settings, null, 2), "utf-8");
 }
 async function getSetting(params) {
@@ -1530,13 +2839,13 @@ async function setSetting(params) {
   await saveSettings(settings);
 }
 function findAvailablePort() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const server = createServer();
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
       if (addr && typeof addr === "object") {
         const p = addr.port;
-        server.close(() => resolve4(p));
+        server.close(() => resolve5(p));
       } else {
         server.close(() => reject(new Error("Failed to get port")));
       }
@@ -1547,7 +2856,7 @@ function findAvailablePort() {
 async function getOrCreateToken() {
   if (hookToken) return hookToken;
   try {
-    const config2 = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+    const config2 = JSON.parse(await readFile4(CONFIG_PATH, "utf-8"));
     if (config2.hookToken) {
       hookToken = config2.hookToken;
       return hookToken;
@@ -1558,7 +2867,7 @@ async function getOrCreateToken() {
   await mkdir2(OPENCLAW_DIR, { recursive: true });
   let config = {};
   try {
-    config = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+    config = JSON.parse(await readFile4(CONFIG_PATH, "utf-8"));
   } catch {
   }
   config.hookToken = hookToken;
@@ -1570,19 +2879,19 @@ async function getOrCreateToken() {
 async function findOpenClawEntrypoint() {
   const candidates = [
     // Global npm install
-    join4(homedir3(), ".seren-local", "lib", "node_modules", "openclaw", "openclaw.mjs"),
+    join5(homedir4(), ".seren-local", "lib", "node_modules", "openclaw", "openclaw.mjs"),
     // Development
-    join4(homedir3(), ".openclaw", "openclaw.mjs")
+    join5(homedir4(), ".openclaw", "openclaw.mjs")
   ];
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
-    const path = await new Promise((resolve4, reject) => {
+    const path2 = await new Promise((resolve5, reject) => {
       execFile3(cmd, ["openclaw"], (err, stdout) => {
         if (err) reject(err);
-        else resolve4(stdout.trim());
+        else resolve5(stdout.trim());
       });
     });
-    if (path) candidates.unshift(path);
+    if (path2) candidates.unshift(path2);
   } catch {
   }
   for (const candidate of candidates) {
@@ -1708,7 +3017,7 @@ async function openclawStart(_params) {
       emit("openclaw://status-changed", { status: "crashed" });
     }
   });
-  await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+  await new Promise((resolve5) => setTimeout(resolve5, 1e3));
   if (childProcess && !childProcess.killed) {
     processStatus = "running";
     startedAt = Date.now();
@@ -1749,7 +3058,7 @@ async function openclawStop(_params) {
 }
 async function openclawRestart(_params) {
   await openclawStop({});
-  await new Promise((resolve4) => setTimeout(resolve4, 500));
+  await new Promise((resolve5) => setTimeout(resolve5, 500));
   await openclawStart({});
 }
 async function openclawStatus(_params) {
@@ -1764,7 +3073,7 @@ async function openclawStatus(_params) {
 async function openclawListChannels(_params) {
   if (processStatus !== "running") return [];
   const entrypoint = await findOpenClawEntrypoint();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     execFile3(
       "node",
       [entrypoint, "channels", "status", "--json"],
@@ -1772,7 +3081,7 @@ async function openclawListChannels(_params) {
       (err, stdout) => {
         if (err) {
           console.error("[OpenClaw] Failed to list channels:", err);
-          resolve4([]);
+          resolve5([]);
           return;
         }
         try {
@@ -1791,9 +3100,9 @@ async function openclawListChannels(_params) {
           }
           channels.length = 0;
           channels.push(...result);
-          resolve4(result);
+          resolve5(result);
         } catch {
-          resolve4([]);
+          resolve5([]);
         }
       }
     );
@@ -1818,7 +3127,7 @@ async function openclawConnectChannel(params) {
   }
   let config = {};
   try {
-    config = JSON.parse(await readFile3(CONFIG_PATH, "utf-8"));
+    config = JSON.parse(await readFile4(CONFIG_PATH, "utf-8"));
   } catch {
   }
   if (!config.channels) config.channels = {};
@@ -1864,14 +3173,14 @@ async function openclawConnectChannel(params) {
 async function openclawDisconnectChannel(params) {
   const { channelId } = params;
   const entrypoint = await findOpenClawEntrypoint();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     execFile3(
       "node",
       [entrypoint, "channels", "remove", "--channel", channelId, "--delete"],
       { cwd: OPENCLAW_DIR, timeout: 1e4 },
       (err) => {
         if (err) reject(new Error(`Failed to disconnect: ${err.message}`));
-        else resolve4();
+        else resolve5();
       }
     );
   });
@@ -1926,7 +3235,7 @@ async function openclawGrantApproval(params) {
 async function openclawGetQr(params) {
   const { platform: plat } = params;
   const entrypoint = await findOpenClawEntrypoint();
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     execFile3(
       "node",
       [entrypoint, "channels", "qr", "--platform", plat, "--json"],
@@ -1936,9 +3245,9 @@ async function openclawGetQr(params) {
         else {
           try {
             const data = JSON.parse(stdout);
-            resolve4(data.qr || data.qrCode || stdout.trim());
+            resolve5(data.qr || data.qrCode || stdout.trim());
           } catch {
-            resolve4(stdout.trim());
+            resolve5(stdout.trim());
           }
         }
       }
@@ -2012,7 +3321,7 @@ async function stopWatching() {
 
 // src/handlers/updater.ts
 import { spawn as spawn3 } from "child_process";
-import { platform as platform3, homedir as homedir4 } from "os";
+import { platform as platform3, homedir as homedir5 } from "os";
 import { resolve as resolve3 } from "path";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -2044,8 +3353,8 @@ async function checkForUpdate() {
   }
 }
 async function installUpdate() {
-  const home2 = homedir4();
-  const serenDir = resolve3(home2, ".seren-local");
+  const home3 = homedir5();
+  const serenDir = resolve3(home3, ".seren-local");
   const nodeDir = resolve3(serenDir, "node");
   const binDir = resolve3(serenDir, "bin");
   const isWin = platform3() === "win32";
@@ -2092,11 +3401,253 @@ function isNewer(a, b) {
   return false;
 }
 
+// src/handlers/skills.ts
+import {
+  mkdir as mkdir3,
+  readFile as fsReadFile2,
+  readdir as readdir2,
+  rename as rename2,
+  rm as rm2,
+  stat as stat2,
+  symlink,
+  lstat,
+  writeFile as fsWriteFile2
+} from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname2, isAbsolute, join as join6, normalize, resolve as resolve4 } from "path";
+var home2 = homedir6();
+function serenConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && isAbsolute(xdg)) {
+    return join6(xdg, "seren");
+  }
+  return join6(home2, ".config", "seren");
+}
+async function ensureDir(dir) {
+  await mkdir3(dir, { recursive: true });
+}
+function isSafeRelativePath(p) {
+  if (isAbsolute(p)) return false;
+  const normalized = normalize(p);
+  if (normalized.startsWith("..")) return false;
+  const parts = normalized.split(/[\\/]/);
+  return !parts.some((part) => part === "..");
+}
+async function getSerenSkillsDir() {
+  const dir = join6(serenConfigDir(), "skills");
+  await ensureDir(dir);
+  return dir;
+}
+async function getClaudeSkillsDir() {
+  const dir = join6(home2, ".claude", "skills");
+  await ensureDir(dir);
+  return dir;
+}
+async function getProjectSkillsDir(params) {
+  const { projectRoot } = params;
+  if (!projectRoot) return null;
+  const root = resolve4(projectRoot);
+  try {
+    const s = await stat2(root);
+    if (!s.isDirectory()) return null;
+  } catch {
+    return null;
+  }
+  const localSkillsDir = join6(root, "skills");
+  try {
+    const s = await stat2(localSkillsDir);
+    if (s.isDirectory()) return localSkillsDir;
+  } catch {
+  }
+  return null;
+}
+async function readSkillFile(params) {
+  const { skillsDir, slug, relativePath } = params;
+  if (!isSafeRelativePath(relativePath)) {
+    throw new Error(
+      `Invalid skill-relative path (must be relative, no ..): ${relativePath}`
+    );
+  }
+  const skillDir = join6(resolve4(skillsDir), slug);
+  const filePath = join6(skillDir, relativePath);
+  return fsReadFile2(filePath, "utf-8");
+}
+async function writeSkillFile(params) {
+  const { skillsDir, slug, relativePath, content } = params;
+  if (!isSafeRelativePath(relativePath)) {
+    throw new Error(
+      `Invalid skill-relative path (must be relative, no ..): ${relativePath}`
+    );
+  }
+  const skillDir = join6(resolve4(skillsDir), slug);
+  const filePath = join6(skillDir, relativePath);
+  await ensureDir(dirname2(filePath));
+  await fsWriteFile2(filePath, content, "utf-8");
+  if (relativePath.endsWith(".sh") || relativePath.endsWith(".py")) {
+    const { chmod } = await import("fs/promises");
+    await chmod(filePath, 493).catch(() => {
+    });
+  }
+}
+async function listSkillFiles(params) {
+  const { skillsDir } = params;
+  const dirPath = resolve4(skillsDir);
+  try {
+    await stat2(dirPath);
+  } catch {
+    return [];
+  }
+  const entries = await readdir2(dirPath, { withFileTypes: true });
+  const slugs = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith(".")) continue;
+    const entryPath = join6(dirPath, entry.name);
+    try {
+      const skillFile = join6(entryPath, "SKILL.md");
+      const s = await stat2(skillFile);
+      if (s.isFile()) {
+        slugs.push(entry.name);
+        continue;
+      }
+    } catch {
+    }
+    try {
+      const subEntries = await readdir2(entryPath, { withFileTypes: true });
+      for (const subEntry of subEntries) {
+        if (!subEntry.isDirectory()) continue;
+        const subSkillFile = join6(entryPath, subEntry.name, "SKILL.md");
+        try {
+          const s = await stat2(subSkillFile);
+          if (s.isFile()) {
+            slugs.push(`${entry.name}-${subEntry.name}`);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  slugs.sort();
+  return [...new Set(slugs)];
+}
+async function writeSkillTree(params) {
+  const { skillsDir, slug, content, extraFiles = [] } = params;
+  const dirPath = resolve4(skillsDir);
+  const skillDir = join6(dirPath, slug);
+  const tempDir = join6(dirPath, `.${slug}.installing.${process.pid}.${Date.now()}`);
+  let backupDir = null;
+  try {
+    await ensureDir(tempDir);
+    await fsWriteFile2(join6(tempDir, "SKILL.md"), content, "utf-8");
+    for (const file of extraFiles) {
+      if (!isSafeRelativePath(file.path)) {
+        throw new Error(
+          `Invalid file path (must be relative, no ..): ${file.path}`
+        );
+      }
+      const target = join6(tempDir, file.path);
+      await ensureDir(dirname2(target));
+      await fsWriteFile2(target, file.content, "utf-8");
+      if (file.path.endsWith(".sh") || file.path.endsWith(".py")) {
+        const { chmod } = await import("fs/promises");
+        await chmod(target, 493).catch(() => {
+        });
+      }
+    }
+    try {
+      const s = await stat2(skillDir);
+      if (s.isDirectory()) {
+        backupDir = join6(dirPath, `.${slug}.backup.${process.pid}.${Date.now()}`);
+        await rename2(skillDir, backupDir);
+      }
+    } catch {
+    }
+    await rename2(tempDir, skillDir);
+  } catch (error) {
+    await rm2(tempDir, { recursive: true, force: true }).catch(() => {
+    });
+    if (backupDir) {
+      try {
+        await stat2(skillDir);
+      } catch {
+        await rename2(backupDir, skillDir).catch(() => {
+        });
+      }
+    }
+    throw error;
+  }
+  if (backupDir) {
+    await rm2(backupDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  return join6(skillDir, "SKILL.md");
+}
+async function createSkillsSymlink(params) {
+  const { projectRoot } = params;
+  const root = resolve4(projectRoot);
+  try {
+    const s = await stat2(root);
+    if (!s.isDirectory()) throw new Error("Project root is not a directory");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error("Project root does not exist");
+    }
+    throw err;
+  }
+  const claudeDir = join6(root, ".claude");
+  const symlinkPath = join6(claudeDir, "skills");
+  const skillsDir = join6(root, "skills");
+  try {
+    const s = await stat2(skillsDir);
+    if (!s.isDirectory()) {
+      throw new Error(
+        `Could not find a skills directory. Expected ${skillsDir}`
+      );
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new Error(
+        `Could not find a skills directory. Expected ${skillsDir}`
+      );
+    }
+    throw err;
+  }
+  await ensureDir(claudeDir);
+  try {
+    const linkStat = await lstat(symlinkPath);
+    if (linkStat.isSymbolicLink()) {
+      const { unlink } = await import("fs/promises");
+      await unlink(symlinkPath);
+    } else {
+      throw new Error(
+        ".claude/skills exists but is not a symlink. Please remove it manually."
+      );
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  const relativeTarget = join6("..", "skills");
+  await symlink(relativeTarget, symlinkPath);
+}
+function registerSkillsHandlers(register) {
+  register("get_seren_skills_dir", getSerenSkillsDir);
+  register("get_claude_skills_dir", getClaudeSkillsDir);
+  register("get_project_skills_dir", getProjectSkillsDir);
+  register("read_skill_file", readSkillFile);
+  register("write_skill_file", writeSkillFile);
+  register("list_skill_files", listSkillFiles);
+  register("write_skill_tree", writeSkillTree);
+  register("create_skills_symlink", createSkillsSymlink);
+}
+
 // src/handlers/wallet.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { join as join7 } from "path";
+import { homedir as homedir7 } from "os";
 import {
   privateKeyToAccount
 } from "viem/accounts";
@@ -2109,20 +3660,20 @@ import {
   getAddress
 } from "viem";
 import { base } from "viem/chains";
-var SEREN_DIR = join5(homedir5(), ".seren-local");
-var WALLET_FILE = join5(SEREN_DIR, "data", "crypto-wallet.json");
+var SEREN_DIR = join7(homedir7(), ".seren-local");
+var WALLET_FILE = join7(SEREN_DIR, "data", "crypto-wallet.json");
 var USDC_CONTRACT_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 var BASE_RPC_URL = "https://mainnet.base.org";
 async function loadStore() {
   try {
-    const data = await readFile4(WALLET_FILE, "utf-8");
+    const data = await readFile5(WALLET_FILE, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
   }
 }
 async function saveStore(store) {
-  await mkdir3(join5(SEREN_DIR, "data"), { recursive: true });
+  await mkdir4(join7(SEREN_DIR, "data"), { recursive: true });
   await writeFile4(WALLET_FILE, JSON.stringify(store), "utf-8");
 }
 async function clearStore() {
@@ -2210,9 +3761,9 @@ var transferWithAuthorizationTypes = {
     { name: "nonce", type: "bytes32" }
   ]
 };
-function getExtra(option, ...path) {
+function getExtra(option, ...path2) {
   let current = option.extra;
-  for (const key of path) {
+  for (const key of path2) {
     if (current == null || typeof current !== "object") return void 0;
     current = current[key];
   }
@@ -2367,7 +3918,7 @@ async function getCryptoUsdcBalance() {
 // src/handlers/index.ts
 function registerAllHandlers() {
   registerHandler("list_directory", listDirectory);
-  registerHandler("read_file", readFile2);
+  registerHandler("read_file", readFile3);
   registerHandler("read_file_base64", readFileBase64);
   registerHandler("write_file", writeFile2);
   registerHandler("path_exists", pathExists);
@@ -2391,6 +3942,9 @@ function registerAllHandlers() {
   registerHandler("acp_get_available_agents", acpGetAvailableAgents);
   registerHandler("acp_check_agent_available", acpCheckAgentAvailable);
   registerHandler("acp_ensure_claude_cli", acpEnsureClaudeCli);
+  registerHandler("acp_ensure_codex_cli", acpEnsureCodexCli);
+  registerHandler("acp_ensure_agent_cli", acpEnsureAgentCli);
+  registerHandler("acp_launch_login", acpLaunchLogin);
   registerHandler("openclaw_start", openclawStart);
   registerHandler("openclaw_stop", openclawStop);
   registerHandler("openclaw_restart", openclawRestart);
@@ -2427,6 +3981,7 @@ function registerAllHandlers() {
   registerHandler("mcp_read_resource", mcpReadResource);
   registerHandler("check_for_update", checkForUpdate);
   registerHandler("install_update", installUpdate);
+  registerSkillsHandlers(registerHandler);
   registerHandler("create_conversation", createConversation);
   registerHandler("get_conversations", getConversations);
   registerHandler("get_conversation", getConversation);
@@ -2435,17 +3990,35 @@ function registerAllHandlers() {
   registerHandler("delete_conversation", deleteConversation);
   registerHandler("save_message", saveMessage);
   registerHandler("get_messages", getMessages);
+  registerHandler("orchestrate", async (params) => {
+    orchestrate({
+      conversationId: params.conversationId,
+      prompt: params.prompt,
+      history: params.history,
+      capabilities: params.capabilities,
+      images: params.images,
+      gatewayBase: params.gatewayBase,
+      authToken: params.authToken
+    }).catch((err) => {
+      console.error("[Orchestrator] Unhandled error:", err);
+    });
+    return { accepted: true };
+  });
+  registerHandler("cancel_orchestration", async (params) => {
+    const cancelled = cancelOrchestration(params.conversationId);
+    return { cancelled };
+  });
 }
 
 // src/update-check.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join6, dirname as dirname2 } from "path";
+import { join as join8, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-var __dirname = dirname2(fileURLToPath(import.meta.url));
+var __dirname = dirname3(fileURLToPath(import.meta.url));
 function getInstalledVersion() {
   try {
     const pkg2 = JSON.parse(
-      readFileSync2(join6(__dirname, "..", "package.json"), "utf-8")
+      readFileSync2(join8(__dirname, "..", "package.json"), "utf-8")
     );
     return pkg2.version ?? "0.0.0";
   } catch {
@@ -2498,10 +4071,10 @@ var PORT = Number(process.env.SEREN_PORT) || 19420;
 var NO_OPEN = process.argv.includes("--no-open");
 var AUTH_TOKEN = process.env.SEREN_RUNTIME_TOKEN || randomBytes3(32).toString("hex");
 var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
-var PUBLIC_DIR = join7(__dirname2, "..", "public");
+var PUBLIC_DIR = join9(__dirname2, "..", "public");
 function computeBuildHash() {
   try {
-    const indexPath = join7(PUBLIC_DIR, "index.html");
+    const indexPath = join9(PUBLIC_DIR, "index.html");
     const content = readFileSync3(indexPath, "utf-8");
     return createHash3("sha256").update(content).digest("hex").slice(0, 12);
   } catch {
@@ -2526,7 +4099,7 @@ var MIME_TYPES = {
   ".wasm": "application/wasm"
 };
 function serveHtml(res) {
-  const indexPath = join7(PUBLIC_DIR, "index.html");
+  const indexPath = join9(PUBLIC_DIR, "index.html");
   try {
     let html = readFileSync3(indexPath, "utf-8");
     html = html.replace(
@@ -2550,13 +4123,13 @@ function serveStatic(urlPath, res) {
   if (safePath === "/" || safePath === "/index.html") {
     return serveHtml(res);
   }
-  const filePath = join7(PUBLIC_DIR, safePath);
+  const filePath = join9(PUBLIC_DIR, safePath);
   if (!filePath.startsWith(PUBLIC_DIR)) {
     return false;
   }
   try {
-    const stat2 = statSync2(filePath);
-    if (stat2.isFile()) {
+    const stat3 = statSync2(filePath);
+    if (stat3.isFile()) {
       const ext = extname2(filePath).toLowerCase();
       const mime = MIME_TYPES[ext] || "application/octet-stream";
       const content = readFileSync3(filePath);
@@ -2701,13 +4274,13 @@ wss.on("connection", (ws, req) => {
     console.log("[Seren Local] Browser disconnected");
   });
 });
-var dataDir = join7(homedir6(), ".seren-local");
+var dataDir = join9(homedir8(), ".seren-local");
 mkdirSync2(dataDir, { recursive: true });
-initChatDb(join7(dataDir, "conversations.db"));
+initChatDb(join9(dataDir, "conversations.db"));
 registerAllHandlers();
 httpServer.listen(PORT, "127.0.0.1", () => {
   const url = `http://127.0.0.1:${PORT}`;
-  const hasSpa = existsSync3(join7(PUBLIC_DIR, "index.html"));
+  const hasSpa = existsSync3(join9(PUBLIC_DIR, "index.html"));
   console.log(`[Seren Local] Listening on ${url}`);
   if (hasSpa) {
     console.log(`[Seren Local] Serving app at ${url}`);