replicas-engine 0.1.653 → 0.1.655

package/dist/src/index.js

@@ -38,6 +38,7 @@ import {
   DEFAULT_CLAUDE_MODEL,
   DEFAULT_CODEX_MODEL,
   DEFAULT_CURSOR_MODEL,
+  DEFAULT_DEEPSEEK_MODEL,
   DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS,
   DEFAULT_OPENCODE_MODEL,
   DEFAULT_PI_MODEL,
@@ -80,6 +81,7 @@ import {
   TaskAccumulator,
   USER_MESSAGE_ID_PAYLOAD_KEY,
   VALID_AGENT_PROVIDERS,
+  VALID_RELAY_SUBAGENT_PROVIDERS,
   VALID_THINKING_LEVELS,
   agentCredentialSnapshotSchema,
   applyCodexAspTranscriptDelta,
@@ -120,6 +122,7 @@ import {
   getChatHistoryPageWindow,
   getClaudeModelContextWindow,
   getCodexAspTurnResponse,
+  getDeepseekAssistantMessageText,
   getDefaultAgentModel,
   getEventTimestampMs,
   getGoalCommand,
@@ -173,12 +176,12 @@ import {
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-KWNVQJRM.js";
+} from "./chunk-542J7B2X.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { randomUUID as randomUUID8 } from "crypto";
 import { connect } from "net";
 
@@ -1817,6 +1820,22 @@ import { homedir as homedir5 } from "os";
 import { join as join8 } from "path";
 var OPENCODE_AUTH_PATH = join8(homedir5(), ".local", "share", "opencode", "auth.json");
 var PI_AUTH_PATH = join8(homedir5(), ".pi", "agent", "auth.json");
+var DEEPSEEK_AUTH_PATH = join8(homedir5(), ".replicas", "deepseek-auth.json");
+
+// src/managers/deepseek-auth.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { z } from "zod";
+var authSchema = z.object({
+  openrouter: z.object({ type: z.literal("api"), key: z.string().min(1) })
+});
+function getDeepseekApiKey() {
+  try {
+    const parsed = authSchema.safeParse(JSON.parse(readFileSync4(DEEPSEEK_AUTH_PATH, "utf8")));
+    return parsed.success ? parsed.data.openrouter.key : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/services/environment-details-service.ts
 var REPLICAS_DIR = join9(homedir6(), ".replicas");
@@ -1856,6 +1875,9 @@ function detectCursorAuthMethod() {
 function detectOpencodeAuthMethod() {
   return existsSync2(OPENCODE_AUTH_PATH) ? "api_key" : "none";
 }
+function detectDeepseekAuthMethod() {
+  return getDeepseekApiKey() ? "api_key" : "none";
+}
 function detectPiAuthMethod() {
   return existsSync2(PI_AUTH_PATH) ? "api_key" : "none";
 }
@@ -1914,6 +1936,7 @@ function createDefaultDetails() {
     claudeAuthMethod: "none",
     codexAuthMethod: "none",
     cursorAuthMethod: "none",
+    deepseekAuthMethod: "none",
     opencodeAuthMethod: "none",
     piAuthMethod: "none",
     lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -1953,6 +1976,7 @@ var EnvironmentDetailsService = class {
     details.claudeAuthMethod = detectClaudeAuthMethod();
     details.codexAuthMethod = detectCodexAuthMethod();
     details.cursorAuthMethod = detectCursorAuthMethod();
+    details.deepseekAuthMethod = detectDeepseekAuthMethod();
     details.opencodeAuthMethod = detectOpencodeAuthMethod();
     details.piAuthMethod = detectPiAuthMethod();
     details.credentialFallbacks = listCredentialFallbacks();
@@ -2707,10 +2731,10 @@ async function registerDesktopPreview() {
 }
 
 // src/services/chat/chat-service.ts
-import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile4, copyFile, mkdir as mkdir15, readFile as readFile15, rename as rename3, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { appendFile as appendFile4, copyFile, mkdir as mkdir16, readFile as readFile15, rename as rename3, rm as rm2 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/managers/claude-manager.ts
@@ -3228,7 +3252,7 @@ async function removeTempImageFiles(paths) {
 }
 
 // src/managers/coding-agent-manager.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { join as join15 } from "path";
 
 // src/managers/auth-fallback.ts
@@ -3687,7 +3711,7 @@ var CodingAgentManager = class {
   buildMemoryInstruction() {
     const readSummary = (scope) => {
       try {
-        return readFileSync4(join15(MEMORY_ROOT, scope, MEMORY_SUMMARY_FILENAME), "utf8").trim();
+        return readFileSync5(join15(MEMORY_ROOT, scope, MEMORY_SUMMARY_FILENAME), "utf8").trim();
       } catch {
         return "";
       }
@@ -4950,12 +4974,14 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       await this.recordEvent(userMessage);
     }
     const combinedInstructions = this.buildCombinedInstructions(customInstructions, true);
+    const systemPrompt = this.systemPromptOverride?.(combinedInstructions);
     const resolvedModel = normalizeClaudeModel(model) || DEFAULT_CLAUDE_MODEL;
     const claudeCodeModel = toClaudeCodeModel(resolvedModel);
     const resolvedPermissionMode = planMode ? "plan" : "bypassPermissions";
     const resolvedFastMode = Boolean(fastMode && canUseClaudeFastMode(resolvedModel));
     const signature = {
       combinedInstructions,
+      systemPrompt,
       thinkingLevel,
       // enableInteractiveTools only matters in plan mode; the session signature
       // tracks the effective flag so a mode change can hot-swap via setPermissionMode
@@ -4965,6 +4991,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     };
     await this.ensureSession({
       signature,
+      systemPrompt,
       combinedInstructions,
       resolvedModel,
       claudeCodeModel,
@@ -4989,6 +5016,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   async ensureSession(args) {
     const {
       signature,
+      systemPrompt,
       combinedInstructions,
       resolvedModel,
       claudeCodeModel,
@@ -5021,6 +5049,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     }
     await this.startSession({
       combinedInstructions,
+      systemPrompt,
       resolvedModel,
       claudeCodeModel,
       resolvedPermissionMode,
@@ -5030,7 +5059,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     });
   }
   sessionSignaturesMatch(a, b) {
-    return a.combinedInstructions === b.combinedInstructions && a.thinkingLevel === b.thinkingLevel && a.enableInteractiveTools === b.enableInteractiveTools && a.fastMode === b.fastMode;
+    return a.combinedInstructions === b.combinedInstructions && a.systemPrompt === b.systemPrompt && a.thinkingLevel === b.thinkingLevel && a.enableInteractiveTools === b.enableInteractiveTools && a.fastMode === b.fastMode;
   }
   /** Query inputs shared by real sessions and slash-command discovery. */
   async buildSharedQueryOptions() {
@@ -5050,6 +5079,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   async startSession(args) {
     const {
       combinedInstructions,
+      systemPrompt,
       resolvedModel,
       claudeCodeModel,
       resolvedPermissionMode,
@@ -5059,7 +5089,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     } = args;
     const ultracode = thinkingLevel === "ultracode";
     const effort = thinkingLevel === "ultra" || ultracode ? "xhigh" : thinkingLevel;
-    const systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(combinedInstructions) : {
+    const resolvedSystemPrompt = systemPrompt ?? {
       type: "preset",
       preset: "claude_code",
       append: combinedInstructions
@@ -5089,7 +5119,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
         ...allowedTools ? { allowedTools } : {},
         ...disallowedTools.length > 0 ? { disallowedTools } : {},
         settingSources: ["user", "project", "local"],
-        systemPrompt,
+        systemPrompt: resolvedSystemPrompt,
         ...this.mcpServersConfig ? { mcpServers: this.mcpServersConfig } : {},
         ...shared.plugins.length > 0 ? { plugins: shared.plugins } : {},
         ...shared.enableAllSkills ? { skills: "all" } : {},
@@ -5685,7 +5715,7 @@ var CodexQuotaStatusTracker = class {
 };
 
 // src/managers/codex-asp/mappers.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 var localImageCache = /* @__PURE__ */ new Map();
 var DEFAULT_MODEL = DEFAULT_CODEX_MODEL;
 var THREAD_START_METHOD = "thread/start";
@@ -5813,7 +5843,7 @@ function userImageForLocalPath(path6) {
   const image = {
     type: "image",
     mediaType: inferMediaType(path6),
-    data: readFileSync5(path6).toString("base64")
+    data: readFileSync6(path6).toString("base64")
   };
   if (image.data.length > 0) localImageCache.set(path6, image);
   return image;
@@ -6317,11 +6347,13 @@ var CODEX_HISTORY_DIR = join18(ENGINE_DIR2, "codex-histories");
 var CURSOR_HISTORY_DIR = join18(ENGINE_DIR2, "cursor-histories");
 var OPENCODE_HISTORY_DIR = join18(ENGINE_DIR2, "opencode-histories");
 var PI_HISTORY_DIR = join18(ENGINE_DIR2, "pi-histories");
+var DEEPSEEK_HISTORY_DIR = join18(ENGINE_DIR2, "deepseek-histories");
 var HISTORY_DIR_BY_PROVIDER = {
   claude: CLAUDE_HISTORY_DIR,
   relay: RELAY_HISTORY_DIR,
   codex: CODEX_HISTORY_DIR,
   cursor: CURSOR_HISTORY_DIR,
+  deepseek: DEEPSEEK_HISTORY_DIR,
   opencode: OPENCODE_HISTORY_DIR,
   pi: PI_HISTORY_DIR
 };
@@ -8060,26 +8092,416 @@ ${instructions}
   }
 };
 
-// src/managers/opencode-manager.ts
+// src/managers/deepseek-manager.ts
+import { spawn as spawn3 } from "child_process";
+import { createRequire } from "module";
+import { dirname as dirname6, join as join21 } from "path";
+import { fileURLToPath } from "url";
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir12, readFile as readFile11 } from "fs/promises";
-import { delimiter, dirname as dirname6, join as join21 } from "path";
+import { mkdir as mkdir12 } from "fs/promises";
+import { z as z2 } from "zod";
+import WebSocket from "ws";
+import { AbstractApiClient } from "@deepseek-ai/dsh-host-apiproxy/client";
+import { hostFrameSchema, muxFrameSchema } from "@deepseek-ai/dsh-host-apiproxy/api/events.schema";
+import { serverRequestSchema } from "@deepseek-ai/dsh-host-apiproxy/api/rpc.schema";
+import { sessionIdSchema } from "@deepseek-ai/dsh-host-apiproxy/api/sessions.schema";
+var questionSelectionSchema = z2.record(z2.string(), z2.object({
+  options: z2.array(z2.string()).optional(),
+  custom: z2.string().optional()
+}));
+var require2 = createRequire(import.meta.url);
+var DSH_BIN = join21(dirname6(require2.resolve("@deepseek-ai/dsh/package.json")), "lib", "bin.js");
+var MANAGER_DIR = dirname6(fileURLToPath(import.meta.url));
+var DSH_PATCH = [
+  join21(MANAGER_DIR, "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml"),
+  join21(MANAGER_DIR, "..", "..", "..", "scripts", "deepseek", "replicas.cordis.patch.yml")
+].find(existsSync6) ?? "";
+var DeepseekApiClient = class extends AbstractApiClient {
+  constructor(baseUrl) {
+    super(3e4);
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  doFetch(input, init) {
+    return fetch(input, init);
+  }
+  resolveBase() {
+    return this.baseUrl;
+  }
+  openMux(_payload, signal, onOpen) {
+    return this.readWebSocket("/api/events.mux", signal, muxFrameSchema, onOpen);
+  }
+  openHost(_payload, signal, onOpen) {
+    return this.readWebSocket("/api/events.host", signal, hostFrameSchema, onOpen);
+  }
+  async *readWebSocket(path6, signal, schema, onOpen) {
+    const url = new URL(path6, this.baseUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const socket = new WebSocket(url);
+    const inbox = [];
+    let wake;
+    const enqueue = (item) => {
+      inbox.push(item);
+      wake?.();
+      wake = void 0;
+    };
+    const abort = () => socket.close();
+    socket.on("open", onOpen ?? (() => {
+    }));
+    socket.on("message", (data) => {
+      try {
+        const envelope = serverRequestSchema.parse(JSON.parse(data.toString()));
+        enqueue({ rpcId: envelope.rpcId, payload: schema.parse(envelope.payload) });
+      } catch (error) {
+        console.error("[DeepseekManager] Dropped malformed WebSocket frame:", error);
+      }
+    });
+    socket.once("close", () => enqueue(null));
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      while (true) {
+        while (inbox.length > 0) {
+          const item = inbox.shift();
+          if (item === null) return;
+          if (item) yield item;
+        }
+        await new Promise((resolve5) => {
+          wake = resolve5;
+        });
+      }
+    } finally {
+      signal.removeEventListener("abort", abort);
+      socket.close();
+    }
+  }
+};
+function unwrap(response) {
+  if (!response.result.ok) throw new Error(response.result.error.message);
+  return response.result.value;
+}
+function reasoningEffort(level) {
+  if (!level) return void 0;
+  if (level === "low") return "off";
+  return level === "medium" || level === "high" ? "high" : "max";
+}
+async function getOpenRouterKey() {
+  const apiKey = getDeepseekApiKey();
+  if (!apiKey) {
+    throw new Error("OpenRouter authentication is missing for DeepSeek Harness. Add an API key in Settings \u2192 Coding agents.");
+  }
+  return apiKey;
+}
+var DeepseekManager = class extends CodingAgentManager {
+  historyFilePath;
+  historyFile;
+  process = null;
+  client = null;
+  sessionId;
+  streamController = null;
+  turnCompletion = null;
+  resolveTurnCompletion = null;
+  pendingResponses = /* @__PURE__ */ new Map();
+  contextPressure = {};
+  contextBreakdown = {};
+  tokenUsage = {};
+  selectedModel = DEFAULT_DEEPSEEK_MODEL;
+  constructor(options) {
+    super(options);
+    this.sessionId = options.initialSessionId ? sessionIdSchema.parse(options.initialSessionId) : null;
+    this.historyFilePath = options.historyFilePath ?? join21(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek", "history.jsonl");
+    this.historyFile = new CodexHistoryFile(this.historyFilePath);
+    this.initializeManager(this.processMessageInternal.bind(this));
+  }
+  async initialize() {
+    await mkdir12(dirname6(this.historyFilePath), { recursive: true });
+  }
+  getHistorySink() {
+    return this.historyFile;
+  }
+  async interruptActiveTurn() {
+    if (this.client && this.sessionId) unwrap(await this.client.sessions.cancel({ sessionId: this.sessionId }));
+  }
+  async steerRequest(request) {
+    if (!this.client || !this.sessionId || !this.isProcessing()) return false;
+    unwrap(await this.client.sessions.prompt({
+      sessionId: this.sessionId,
+      mode: "steer",
+      content: [{ type: "text", text: request.message }]
+    }));
+    this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
+    return true;
+  }
+  async getHistory(page = {}) {
+    await this.historyFile.flush();
+    return { thread_id: this.sessionId ?? this.initialSessionId, ...await this.historyFile.loadEventsPage(page), goal: null };
+  }
+  async listSlashCommands() {
+    await this.initialized;
+    const client = await this.ensureClient();
+    if (!this.sessionId) {
+      this.sessionId = unwrap(await client.sessions.create({ cwd: this.workingDirectory })).sessionId;
+      await this.onSaveSessionId(this.sessionId);
+    }
+    const { skills } = unwrap(await client.skills.list({ sessionId: this.sessionId }));
+    return mergeSlashCommands(skills.map((skill) => createProviderSlashCommand("deepseek", skill.name, skill.description)).filter((command) => Boolean(command)));
+  }
+  isAwaitingInput() {
+    return this.pendingResponses.size > 0;
+  }
+  async respondToToolInput(requestId, selectionId) {
+    const pending = this.pendingResponses.get(requestId);
+    if (!pending || !this.client || !this.sessionId) return false;
+    let result;
+    if (pending.frame.type === "approval/requested") {
+      result = { ok: true, value: { sessionId: this.sessionId, outcome: selectionId === "allow" ? "allowed-once" : "rejected" } };
+    } else {
+      const parsed = questionSelectionSchema.safeParse(selectionId === "declined" ? {} : JSON.parse(selectionId));
+      if (!parsed.success) return false;
+      result = {
+        ok: true,
+        value: {
+          sessionId: this.sessionId,
+          answer: {
+            answers: pending.frame.questions.map((question) => {
+              const answer = parsed.data[question.id];
+              return {
+                id: question.id,
+                selected: (answer?.options ?? []).map((option) => option.startsWith(`${question.id}:`) ? option.slice(question.id.length + 1) : option),
+                ...answer?.custom ? { custom: answer.custom } : {}
+              };
+            })
+          }
+        }
+      };
+    }
+    const receipt = await this.client.respond({ type: "client-response", rpcId: pending.rpcId, result });
+    if (!receipt.accepted) return false;
+    this.pendingResponses.delete(requestId);
+    return true;
+  }
+  dispose() {
+    this.streamController?.abort();
+    this.process?.kill("SIGTERM");
+    this.process = null;
+    this.client = null;
+  }
+  async ensureClient() {
+    if (this.client) return this.client;
+    if (!DSH_PATCH) throw new Error("DeepSeek Harness configuration is missing from the engine package.");
+    const apiKey = await getOpenRouterKey();
+    const child = spawn3(process.execPath, [DSH_BIN, "--profile", "web", "--patch", DSH_PATCH, "--host", "127.0.0.1", "--port", "0"], {
+      cwd: this.workingDirectory,
+      env: {
+        ...process.env,
+        DEEPSEEK_API_KEY: apiKey,
+        DEEPSEEK_BASE_URL: "https://openrouter.ai/api/v1",
+        DSH_HOME: join21(ENGINE_ENV.HOME_DIR, ".replicas", "deepseek"),
+        DSH_PERMISSION_MODE: "workspace-write",
+        DSH_TELEMETRY_DISABLED: "true"
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.process = child;
+    const baseUrl = await new Promise((resolve5, reject) => {
+      let stdout = "";
+      let stderr = "";
+      const timeout = setTimeout(() => {
+        child.kill("SIGTERM");
+        reject(new Error(`DeepSeek Harness startup timed out: ${stderr.trim()}`));
+      }, 3e4);
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+        const match = stdout.match(/dsh web:\s+(http:\/\/[^\s]+)/);
+        if (!match?.[1]) return;
+        clearTimeout(timeout);
+        resolve5(match[1]);
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr = (stderr + chunk.toString()).slice(-8e3);
+      });
+      child.once("exit", (code) => {
+        clearTimeout(timeout);
+        reject(new Error(`DeepSeek Harness exited during startup (${code}): ${stderr.trim()}`));
+      });
+      child.once("error", reject);
+    });
+    const client = new DeepseekApiClient(baseUrl);
+    this.client = client;
+    await this.startStreams(client);
+    return client;
+  }
+  async startStreams(client) {
+    const controller = new AbortController();
+    this.streamController = controller;
+    const muxReady = Promise.withResolvers();
+    const hostReady = Promise.withResolvers();
+    void (async () => {
+      for await (const envelope of client.events.mux({}, controller.signal, muxReady.resolve)) this.handleMuxFrame(envelope.rpcId, envelope.payload);
+    })().catch((error) => {
+      muxReady.reject(error);
+      if (!controller.signal.aborted) this.recordHistoryEvent("deepseek-error", { message: String(error) }, this.historyFile);
+    });
+    void (async () => {
+      for await (const envelope of client.events.host({}, controller.signal, hostReady.resolve)) this.handleHostFrame(envelope.payload);
+    })().catch((error) => {
+      hostReady.reject(error);
+      if (!controller.signal.aborted) this.recordHistoryEvent("deepseek-error", { message: String(error) }, this.historyFile);
+    });
+    await Promise.all([muxReady.promise, hostReady.promise]);
+  }
+  handleMuxFrame(rpcId, frame) {
+    if ("sessionId" in frame && this.sessionId && frame.sessionId !== this.sessionId) return;
+    if (frame.type === "session/event") {
+      this.recordHistoryEvent("deepseek-session-event", { event: frame.event, view: frame.view }, this.historyFile);
+      return;
+    }
+    if (frame.type === "session/jobs") {
+      this.recordHistoryEvent("deepseek-jobs", { jobs: frame.jobs }, this.historyFile);
+      return;
+    }
+    if (frame.type === "session/projection") {
+      if (frame.key === "contextPressure" && isRecord2(frame.value)) this.contextPressure = frame.value;
+      else if (frame.key === "contextBreakdown" && isRecord2(frame.value)) this.contextBreakdown = frame.value;
+      else if (frame.key === "tokenUsage" && isRecord2(frame.value)) this.tokenUsage = frame.value;
+      else return;
+      this.emitDeepseekContextUsage();
+      return;
+    }
+    if (frame.type === "approval/resolved" || frame.type === "question/resolved") {
+      const requestId2 = frame.type === "approval/resolved" ? `approval:${frame.approvalId}` : `question:${frame.questionRpcId}`;
+      this.pendingResponses.delete(requestId2);
+      this.recordHistoryEvent("deepseek-input-resolved", {
+        requestId: requestId2,
+        status: frame.type === "question/resolved" && frame.outcome === "cancelled" ? "aborted" : "resolved"
+      }, this.historyFile);
+      return;
+    }
+    if (frame.type !== "approval/requested" && frame.type !== "question/requested") return;
+    const requestId = frame.type === "approval/requested" ? `approval:${frame.approvalId}` : `question:${rpcId}`;
+    this.pendingResponses.set(requestId, { rpcId, frame });
+    this.recordHistoryEvent("deepseek-input-request", {
+      requestId,
+      kind: frame.type === "approval/requested" ? "approval" : "question",
+      ...frame.type === "approval/requested" ? { toolName: frame.toolName, reason: frame.reason } : { questions: frame.questions }
+    }, this.historyFile);
+  }
+  handleHostFrame(frame) {
+    if (!("sessionId" in frame) || !this.sessionId || frame.sessionId !== this.sessionId) return;
+    if (frame.type === "host/agent-error") {
+      this.recordHistoryEvent("deepseek-error", { message: frame.message }, this.historyFile);
+    }
+    if (frame.type === "host/session-status" && !frame.running) {
+      this.resolveTurnCompletion?.();
+      this.resolveTurnCompletion = null;
+    }
+  }
+  emitDeepseekContextUsage() {
+    const totalTokens = typeof this.contextPressure.projectedTokens === "number" ? this.contextPressure.projectedTokens : this.contextPressure.pressureTokens;
+    if (typeof totalTokens !== "number") return;
+    const maxTokens = typeof this.contextPressure.contextWindow === "number" ? this.contextPressure.contextWindow : null;
+    const categories = [
+      ["System", this.contextBreakdown.systemTokens],
+      ["Tools", this.contextBreakdown.toolsTokens],
+      ["Messages", this.contextBreakdown.messageTokens]
+    ].flatMap(([name, tokens]) => typeof tokens === "number" ? [{ name: String(name), tokens, percentage: percentage(tokens, maxTokens) }] : []);
+    this.emitContextUsage({
+      provider: "deepseek",
+      source: "provider_usage",
+      model: this.selectedModel,
+      totalTokens,
+      maxTokens,
+      percentage: percentage(totalTokens, maxTokens),
+      compactsAutomatically: true,
+      categories,
+      apiUsage: {
+        inputTokens: typeof this.tokenUsage.uncachedInputTokens === "number" ? this.tokenUsage.uncachedInputTokens : void 0,
+        outputTokens: typeof this.tokenUsage.outputTokens === "number" ? this.tokenUsage.outputTokens : void 0,
+        cacheCreationInputTokens: typeof this.tokenUsage.cacheWriteTokens === "number" ? this.tokenUsage.cacheWriteTokens : void 0,
+        cacheReadInputTokens: typeof this.tokenUsage.cacheReadTokens === "number" ? this.tokenUsage.cacheReadTokens : void 0
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async processMessageInternal(request) {
+    try {
+      const client = await this.ensureClient();
+      if (!this.sessionId) {
+        this.sessionId = unwrap(await client.sessions.create({ cwd: this.workingDirectory })).sessionId;
+        await this.onSaveSessionId(this.sessionId);
+      }
+      const model = request.model ?? DEFAULT_DEEPSEEK_MODEL;
+      this.selectedModel = model;
+      const current = unwrap(await client.sessions.models({ sessionId: this.sessionId })).current;
+      const effort = reasoningEffort(request.thinkingLevel);
+      if (current.model !== model || current.reasoningEffort !== effort) {
+        unwrap(await client.sessions.selectModel({
+          sessionId: this.sessionId,
+          provider: "deepseek-official",
+          model,
+          ...effort ? { reasoningEffort: effort } : {}
+        }));
+      }
+      this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
+      this.turnCompletion = new Promise((resolve5) => {
+        this.resolveTurnCompletion = resolve5;
+      });
+      const images = await normalizeImages(request.images ?? []);
+      const combinedInstructions = this.buildCombinedInstructions(request.customInstructions);
+      const prompt = combinedInstructions ? `<system_instructions>
+${combinedInstructions}
+</system_instructions>
+
+${request.message}` : request.message;
+      if (!request.planMode) {
+        unwrap(await client.sessions.prompt({
+          sessionId: this.sessionId,
+          mode: "queue",
+          content: [{ type: "text", text: "/plan off" }]
+        }));
+      }
+      unwrap(await client.sessions.prompt({
+        sessionId: this.sessionId,
+        mode: "queue",
+        content: [
+          { type: "text", text: request.planMode ? `/plan ${prompt}` : prompt },
+          ...images.map((image) => ({
+            type: "image",
+            mediaType: image.source.media_type,
+            data: image.source.data
+          }))
+        ]
+      }));
+      await this.turnCompletion;
+    } catch (error) {
+      this.recordHistoryEvent("deepseek-error", { message: error instanceof Error ? error.message : String(error) }, this.historyFile);
+    } finally {
+      this.turnCompletion = null;
+      await this.historyFile.flush();
+      await this.onTurnComplete();
+    }
+  }
+};
+
+// src/managers/opencode-manager.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir13, readFile as readFile11 } from "fs/promises";
+import { delimiter, dirname as dirname7, join as join22 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Agent } from "undici";
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 
 // ../shared/src/credentials/opencode-go.ts
-import { z } from "zod";
+import { z as z3 } from "zod";
 var OPENCODE_GO_PROVIDER = "opencode-go";
 var DEFAULT_OPENCODE_GO_MODEL = "glm-5.2";
-var opencodeGoModelsDevSchema = z.object({
-  "opencode-go": z.object({
-    models: z.record(z.string(), z.object({
-      id: z.string().optional(),
-      name: z.string(),
-      description: z.string().optional(),
-      status: z.enum(["alpha", "beta", "deprecated"]).optional()
+var opencodeGoModelsDevSchema = z3.object({
+  "opencode-go": z3.object({
+    models: z3.record(z3.string(), z3.object({
+      id: z3.string().optional(),
+      name: z3.string(),
+      description: z3.string().optional(),
+      status: z3.enum(["alpha", "beta", "deprecated"]).optional()
     }))
   }).optional()
 });
@@ -8109,8 +8531,8 @@ async function getAllowedOpenRouterModels() {
 }
 
 // src/managers/opencode-manager.ts
-var OPENCODE_SHIM_DIR = dirname6(fileURLToPath(new URL("../../scripts/opencode", import.meta.url)));
-var OPENCODE_CONFIG_PATH = join21(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
+var OPENCODE_SHIM_DIR = dirname7(fileURLToPath2(new URL("../../scripts/opencode", import.meta.url)));
+var OPENCODE_CONFIG_PATH = join22(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
 var OPENCODE_FETCH_DISPATCHER = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
 var OPENCODE_SERVER_STARTUP_TIMEOUT_MS = 3e4;
 var OPENCODE_WORKSPACE_PERMISSION = {
@@ -8140,12 +8562,12 @@ var OPENCODE_VARIANT_CANDIDATES_BY_THINKING_LEVEL = {
   ultra: ["max", "xhigh", "high"],
   ultracode: ["max", "xhigh", "high"]
 };
-var opencodeAuthSchema = z2.record(z2.string(), z2.object({
-  type: z2.string().optional(),
-  key: z2.string().optional()
+var opencodeAuthSchema = z4.record(z4.string(), z4.object({
+  type: z4.string().optional(),
+  key: z4.string().optional()
 }));
 async function hasOpencodeCredentials(provider) {
-  if (!existsSync6(OPENCODE_AUTH_PATH)) return false;
+  if (!existsSync7(OPENCODE_AUTH_PATH)) return false;
   try {
     const auth = opencodeAuthSchema.safeParse(JSON.parse(await readFile11(OPENCODE_AUTH_PATH, "utf8")));
     return auth.success && auth.data[provider]?.type === "api" && Boolean(auth.data[provider]?.key);
@@ -8360,12 +8782,12 @@ var OpencodeManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.sessionId = options.initialSessionId;
-    this.historyFilePath = options.historyFilePath ?? join21(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
+    this.historyFilePath = options.historyFilePath ?? join22(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
-    await mkdir12(dirname6(this.historyFilePath), { recursive: true });
+    await mkdir13(dirname7(this.historyFilePath), { recursive: true });
   }
   getHistorySink() {
     return this.historyFile;
@@ -8869,8 +9291,8 @@ var OpencodeManager = class extends CodingAgentManager {
 };
 
 // src/managers/pi-manager.ts
-import { mkdir as mkdir13 } from "fs/promises";
-import { dirname as dirname7, join as join22 } from "path";
+import { mkdir as mkdir14 } from "fs/promises";
+import { dirname as dirname8, join as join23 } from "path";
 import {
   AuthStorage,
   createAgentSession,
@@ -8953,12 +9375,12 @@ var PiManager = class extends CodingAgentManager {
   providerApiKey = null;
   constructor(options) {
     super(options);
-    this.historyFilePath = options.historyFilePath ?? join22(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
+    this.historyFilePath = options.historyFilePath ?? join23(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
-    await mkdir13(dirname7(this.historyFilePath), { recursive: true });
+    await mkdir14(dirname8(this.historyFilePath), { recursive: true });
   }
   getHistorySink() {
     return this.historyFile;
@@ -9053,7 +9475,7 @@ var PiManager = class extends CodingAgentManager {
     const sessionManager = this.initialSessionId ? SessionManager.open(this.initialSessionId, PI_HISTORY_DIR, this.workingDirectory) : SessionManager.create(this.workingDirectory, PI_HISTORY_DIR);
     const resourceLoader = new DefaultResourceLoader({
       cwd: this.workingDirectory,
-      agentDir: join22(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
+      agentDir: join23(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
       extensionFactories: [registerCommandProtection(
         this.workingDirectory,
         this.historyFile,
@@ -9119,7 +9541,7 @@ var PiManager = class extends CodingAgentManager {
 
 // src/managers/relay-tools.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 
 // src/managers/relay-providers.ts
 function isRelaySubagentProviderAllowed(provider, allowedProviders) {
@@ -9128,19 +9550,18 @@ function isRelaySubagentProviderAllowed(provider, allowedProviders) {
 function getAvailableRelayProviders(availability) {
   const codexAvailable = availability.codexAvailable ?? false;
   const cursorAvailable = availability.cursorAvailable ?? false;
+  const deepseekAvailable = availability.deepseekAvailable ?? false;
   const opencodeAvailable = availability.opencodeAvailable ?? false;
   const piAvailable = availability.piAvailable ?? false;
   const providers = ["claude"];
   if (codexAvailable) providers.push("codex");
   if (cursorAvailable) providers.push("cursor");
+  if (deepseekAvailable) providers.push("deepseek");
   if (opencodeAvailable) providers.push("opencode");
   if (piAvailable) providers.push("pi");
   providers.push("relay");
   return providers;
 }
-function getAvailableCodeProviders(availability) {
-  return getAvailableRelayProviders(availability).filter((provider) => provider === "codex" || provider === "cursor" || provider === "opencode" || provider === "pi");
-}
 
 // src/managers/relay-tools.ts
 var POLL_INTERVAL_MS = 2e3;
@@ -9221,6 +9642,10 @@ function extractFinalResponse(history) {
       const text = extractTextBlocks(message?.content, "text", "");
       if (text) return text;
     }
+    if (event.type === "deepseek-session-event") {
+      const text = getDeepseekAssistantMessageText(payload.event, "text");
+      if (text) return text;
+    }
   }
   return null;
 }
@@ -9237,42 +9662,36 @@ async function getChatFinalResponse(chatId) {
   }
   return extractFinalResponse(history) ?? "[No response from subagent]";
 }
-function buildSpawnAgentTool(parentChatId, availability = {}, getAllowedProviders = () => monolithService.getRelaySubagentProviders()) {
-  const codexAvailable = availability.codexAvailable ?? false;
-  const cursorAvailable = availability.cursorAvailable ?? false;
-  const opencodeAvailable = availability.opencodeAvailable ?? false;
-  const availableProviders = getAvailableRelayProviders(availability);
-  const providerEnum = z3.enum(availableProviders);
-  const codeProviders = getAvailableCodeProviders(availability);
-  const providerDesc = codeProviders.length > 0 ? `Which agent to use. Prefer ${codeProviders.join(" or ")} for code writing, claude for exploration/analysis, relay for complex multi-step orchestration.` : "Which agent to use. Use claude for code writing, exploration, and analysis. Use relay for complex multi-step orchestration.";
-  const useCases = codeProviders.length > 0 ? `- Complex code writing tasks (use provider '${codeProviders.join("' or '")}' with a capable model)
-- Codebase exploration that would consume many tokens (use provider 'claude')` : `- Complex code writing tasks (use provider 'claude')
-- Codebase exploration that would consume many tokens (use provider 'claude')`;
+function buildSpawnAgentTool(parentChatId, availability = {}, getAllowedProviders = () => monolithService.getRelaySubagentProviders(), getProviderAvailability = () => availability) {
+  const providerEnum = z5.enum(VALID_RELAY_SUBAGENT_PROVIDERS);
   return tool(
     "spawn_agent",
     `Spawn a new subagent to perform a task. The subagent runs in its own chat with a fresh context window.
 
 Use this for:
-${useCases}
+- Complex code writing tasks (use a currently available code provider with a capable model)
+- Codebase exploration that would consume many tokens (use provider 'claude')
 - Browser testing, large test runs, or other token-heavy operations
 - Any task you want to delegate to preserve your own context
 
 The tool blocks until the subagent completes and returns its final response.
 You will also receive the chatId so you can send follow-up messages or clean up the chat.`,
     {
-      provider: providerEnum.describe(providerDesc),
-      prompt: z3.string().describe("The full prompt/instructions for the subagent. Be detailed - it has no context from your conversation."),
-      model: z3.string().optional().describe([
+      provider: providerEnum.describe("Which agent to use. Choose from the providers listed as currently available in Relay guidance. Prefer an available code provider for code writing, claude for exploration/analysis, and relay for complex multi-step orchestration."),
+      prompt: z5.string().describe("The full prompt/instructions for the subagent. Be detailed - it has no context from your conversation."),
+      model: z5.string().optional().describe([
         `Model override. Claude: ${AGENT_MODELS.claude.join(", ")} (opus is the default; sonnet is faster).`,
-        codexAvailable ? `Codex: ${AGENT_MODELS.codex.join(", ")}.` : null,
-        cursorAvailable ? `Cursor: ${AGENT_MODELS.cursor.join(", ")}.` : null,
-        opencodeAvailable ? `Opencode: ${AGENT_MODELS.opencode.join(", ")}.` : null
-      ].filter(Boolean).join(" ")),
-      thinking_level: z3.enum(VALID_THINKING_LEVELS).optional().describe(
-        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high, Codex = medium, Cursor = medium, Opencode = medium."
+        `Codex: ${AGENT_MODELS.codex.join(", ")}.`,
+        `Cursor: ${AGENT_MODELS.cursor.join(", ")}.`,
+        `DeepSeek Harness: ${AGENT_MODELS.deepseek.join(", ")}.`,
+        `Opencode: ${AGENT_MODELS.opencode.join(", ")}.`,
+        `Pi: ${AGENT_MODELS.pi.join(", ")}.`
+      ].join(" ")),
+      thinking_level: z5.enum(VALID_THINKING_LEVELS).optional().describe(
+        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high; Codex, Cursor, DeepSeek Harness, Opencode, and Pi = medium."
       ),
-      title: z3.string().optional().describe("Optional title for the subagent chat (for identification)."),
-      timeout_minutes: z3.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
+      title: z5.string().optional().describe("Optional title for the subagent chat (for identification)."),
+      timeout_minutes: z5.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
     },
     async (args) => {
       try {
@@ -9290,6 +9709,12 @@ You will also receive the chatId so you can send follow-up messages or clean up
             isError: true
           };
         }
+        if (!isRelaySubagentProviderAllowed(provider, getAvailableRelayProviders(getProviderAvailability()))) {
+          return {
+            content: [{ type: "text", text: `Relay cannot use ${provider} because its credentials are unavailable.` }],
+            isError: true
+          };
+        }
         const createBody = {
           provider,
           title: args.title || `Subagent (${provider})`
@@ -9347,13 +9772,13 @@ var messageAgentTool = tool(
 
 The tool blocks until the subagent completes and returns its response.`,
   {
-    chatId: z3.string().describe("The chat ID of the subagent (returned by spawn_agent)."),
-    message: z3.string().describe("The follow-up message to send."),
-    model: z3.string().optional().describe("Optional model override for this message."),
-    thinking_level: z3.enum(VALID_THINKING_LEVELS).optional().describe(
+    chatId: z5.string().describe("The chat ID of the subagent (returned by spawn_agent)."),
+    message: z5.string().describe("The follow-up message to send."),
+    model: z5.string().optional().describe("Optional model override for this message."),
+    thinking_level: z5.enum(VALID_THINKING_LEVELS).optional().describe(
       "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high, Codex = medium, Cursor = medium, Opencode = medium."
     ),
-    timeout_minutes: z3.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
+    timeout_minutes: z5.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
   },
   async (args) => {
     try {
@@ -9391,7 +9816,7 @@ var deleteAgentTool = tool(
   "delete_agent",
   `Delete a subagent chat to free resources. Use this after a subagent has completed its work and you no longer need to send it follow-up messages.`,
   {
-    chatId: z3.string().describe("The chat ID of the subagent to delete.")
+    chatId: z5.string().describe("The chat ID of the subagent to delete.")
   },
   async (args) => {
     try {
@@ -9409,11 +9834,11 @@ var deleteAgentTool = tool(
     }
   }
 );
-function createRelayMcpServer(parentChatId, availability = {}, getAllowedProviders) {
+function createRelayMcpServer(parentChatId, availability = {}, getAllowedProviders, getProviderAvailability) {
   return createSdkMcpServer({
     name: "relay-subagent-tools",
     version: "1.0.0",
-    tools: [buildSpawnAgentTool(parentChatId, availability, getAllowedProviders), messageAgentTool, deleteAgentTool]
+    tools: [buildSpawnAgentTool(parentChatId, availability, getAllowedProviders, getProviderAvailability), messageAgentTool, deleteAgentTool]
   });
 }
 
@@ -9515,12 +9940,13 @@ function getUsingToolsSection() {
   ];
   return [`# Using your tools`, ...prependBullets(items)].join("\n");
 }
-function getDelegationSection(codexAvailable, cursorAvailable, opencodeAvailable, piAvailable) {
-  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable, opencodeAvailable, piAvailable }).join(", ");
+function getDelegationSection(codexAvailable, cursorAvailable, deepseekAvailable, opencodeAvailable, piAvailable) {
+  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable, deepseekAvailable, opencodeAvailable, piAvailable }).join(", ");
   const spawnDesc = `Create a new subagent with a specific provider (${providerList}), send it a prompt, and wait for its response. Returns the chatId and the agent's final response. You can set a custom timeout via the timeout_minutes parameter (default: 10 minutes).`;
   const claudeModelList = AGENT_MODELS.claude.join(", ");
   const extraAgentLines = [
     codexAvailable ? `Use provider 'codex' for heavy code writing, implementation, and large refactors. Suggested models: ${AGENT_MODELS.codex.join(", ")} (${AGENT_MODELS.codex[0]} is the default).` : null,
+    deepseekAvailable ? `Use provider 'deepseek' for tasks that benefit from the DeepSeek Harness tool loop. Suggested models: ${AGENT_MODELS.deepseek.join(", ")}.` : null,
     opencodeAvailable ? `Use provider 'opencode' for cheaper routine implementation tasks through OpenRouter-backed open source models. Suggested models: ${AGENT_MODELS.opencode.join(", ")}.` : null,
     piAvailable ? `Use provider 'pi' for coding tasks through Pi's OpenRouter-backed coding agent. Suggested models: ${AGENT_MODELS.pi.join(", ")}.` : null,
     cursorAvailable ? `Use provider 'cursor' for fast iteration on code changes. Suggested models: ${AGENT_MODELS.cursor.join(", ")}.` : null
@@ -9645,14 +10071,14 @@ function getEnvironmentSection() {
   ].join("\n");
 }
 function buildRelaySystemPrompt(options) {
-  const { customInstructions, codexAvailable, cursorAvailable, opencodeAvailable, piAvailable } = options ?? {};
+  const { customInstructions, codexAvailable, cursorAvailable, deepseekAvailable, opencodeAvailable, piAvailable } = options ?? {};
   const sections = [
     getIntroSection(),
     getSystemSection(),
     getDoingTasksSection(),
     getActionsSection(),
     getUsingToolsSection(),
-    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false, opencodeAvailable ?? false, piAvailable ?? false),
+    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false, deepseekAvailable ?? false, opencodeAvailable ?? false, piAvailable ?? false),
     getToneAndStyleSection(),
     getOutputEfficiencySection(),
     getEnvironmentSection(),
@@ -9684,14 +10110,22 @@ var RelayManager = class {
   constructor(options) {
     const codexAvailable = options.codexAvailable ?? false;
     const cursorAvailable = options.cursorAvailable ?? false;
+    const deepseekAvailable = options.deepseekAvailable ?? false;
     const opencodeAvailable = options.opencodeAvailable ?? false;
     const piAvailable = options.piAvailable ?? false;
+    const availability = { codexAvailable, cursorAvailable, deepseekAvailable, opencodeAvailable, piAvailable };
+    const getProviderAvailability = options.getProviderAvailability ?? (() => availability);
     this.inner = new ClaudeManager({
       ...options,
-      systemPromptOverride: (customInstructions) => buildRelaySystemPrompt({ customInstructions, codexAvailable, cursorAvailable, opencodeAvailable, piAvailable }),
+      systemPromptOverride: (customInstructions) => buildRelaySystemPrompt({ customInstructions, ...getProviderAvailability() }),
       tools: RELAY_TOOLS,
       mcpServers: {
-        "relay-subagent-tools": createRelayMcpServer(options.chatId, { codexAvailable, cursorAvailable, opencodeAvailable, piAvailable })
+        "relay-subagent-tools": createRelayMcpServer(
+          options.chatId,
+          availability,
+          void 0,
+          getProviderAvailability
+        )
       },
       envOverrides: {
         CLAUDE_CODE_STREAM_CLOSE_TIMEOUT: "900000"
@@ -9743,17 +10177,17 @@ var RelayManager = class {
 // src/analytics/agent/activity/agent-chat-activity-tracker-service.ts
 import {
   appendFile as appendFile3,
-  mkdir as mkdir14,
+  mkdir as mkdir15,
   readFile as readFile12,
   readdir as readdir6,
   rename as rename2,
   unlink as unlink3
 } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/analytics/agent/activity/skill-mcp-call-extractor.ts
-var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "opencode", "pi", "custom", "dynamic"]);
+var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "deepseek", "opencode", "pi", "custom", "dynamic"]);
 function mcpNameFromToolCall(message) {
   const parsedName = parseMcpToolName(message.tool);
   if (parsedName) return parsedName.server;
@@ -9800,7 +10234,7 @@ var AgentChatActivityBuffer = class {
       options.storageName,
       ...options.legacyStorageNames ?? []
     ];
-    this.liveFile = join23(ENGINE_DIR2, `${options.storageName}.jsonl`);
+    this.liveFile = join24(ENGINE_DIR2, `${options.storageName}.jsonl`);
     this.segmentFilePatterns = this.storageNames.map(
       (storageName) => new RegExp(`^${storageName}\\.(\\d+)\\.jsonl$`)
     );
@@ -9817,7 +10251,7 @@ var AgentChatActivityBuffer = class {
     failed: 0
   });
   append(record) {
-    const pending = mkdir14(ENGINE_DIR2, { recursive: true }).then(
+    const pending = mkdir15(ENGINE_DIR2, { recursive: true }).then(
       () => appendFile3(this.liveFile, `${JSON.stringify(record)}
 `, "utf-8")
     ).catch((error) => {
@@ -9859,8 +10293,8 @@ var AgentChatActivityBuffer = class {
       await Promise.allSettled([...this.pendingAppends]);
     for (const storageName of this.storageNames) {
       await rename2(
-        join23(ENGINE_DIR2, `${storageName}.jsonl`),
-        join23(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
+        join24(ENGINE_DIR2, `${storageName}.jsonl`),
+        join24(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
       ).catch(() => {
       });
     }
@@ -9871,7 +10305,7 @@ var AgentChatActivityBuffer = class {
       if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry)))
         continue;
       try {
-        await this.uploadSegment(join23(ENGINE_DIR2, entry));
+        await this.uploadSegment(join24(ENGINE_DIR2, entry));
         flushed++;
       } catch (error) {
         failed++;
@@ -9903,7 +10337,7 @@ var AgentChatActivityBuffer = class {
       ) && entry.endsWith(UPLOADED_SUFFIX)
     ).sort();
     for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
-      await unlink3(join23(ENGINE_DIR2, entry)).catch(() => {
+      await unlink3(join24(ENGINE_DIR2, entry)).catch(() => {
       });
     }
     return { flushed, failed };
@@ -10136,17 +10570,17 @@ var keepAliveService = new KeepAliveService();
 // src/services/canvas-service.ts
 import { readdir as readdir7, readFile as readFile13, stat as stat3 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var GLOBAL_CANVAS_DIRECTORIES = [
-  join24(homedir14(), ".claude", "plans"),
-  join24(process.env.XDG_DATA_HOME ?? join24(homedir14(), ".local", "share"), "opencode", "plans"),
-  join24(homedir14(), ".replicas", "canvas")
+  join25(homedir14(), ".claude", "plans"),
+  join25(process.env.XDG_DATA_HOME ?? join25(homedir14(), ".local", "share"), "opencode", "plans"),
+  join25(homedir14(), ".replicas", "canvas")
 ];
 async function canvasDirectories() {
   const repositories = await gitService.listRepositories().catch(() => []);
   return [
     ...GLOBAL_CANVAS_DIRECTORIES,
-    ...repositories.map((repository) => join24(repository.path, ".opencode", "plans"))
+    ...repositories.map((repository) => join25(repository.path, ".opencode", "plans"))
   ];
 }
 var CanvasService = class {
@@ -10170,7 +10604,7 @@ var CanvasService = class {
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
           const filename = current.relativePath ? `${current.relativePath}/${entry.name}` : entry.name;
-          const filePath = join24(current.directory, entry.name);
+          const filePath = join25(current.directory, entry.name);
           if (entry.isDirectory()) {
             pending.push({ directory: filePath, relativePath: filename });
             continue;
@@ -10195,7 +10629,7 @@ var CanvasService = class {
     if (!safe) return null;
     const { kind, mimeType } = classifyCanvasFilename(safe);
     for (const directory of await this.directories()) {
-      const filePath = join24(directory, safe);
+      const filePath = join25(directory, safe);
       let sizeBytes = 0;
       let updatedAt = "";
       try {
@@ -10367,13 +10801,13 @@ async function reconcileCanvasItems(filenames) {
 import { createReadStream } from "fs";
 import { createHash as createHash2 } from "crypto";
 import { readdir as readdir8, readFile as readFile14, stat as stat4 } from "fs/promises";
-import { basename as basename2, join as join26 } from "path";
+import { basename as basename2, join as join27 } from "path";
 
 // src/services/chat/chat-senders.ts
-import { join as join25 } from "path";
-var CHAT_SENDERS_DIR = join25(ENGINE_DIR2, "chat-senders");
+import { join as join26 } from "path";
+var CHAT_SENDERS_DIR = join26(ENGINE_DIR2, "chat-senders");
 function chatMessageSendersFilePath(chatId) {
-  return join25(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+  return join26(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
 }
 function parseChatMessageSendersJsonl(content) {
   return content.split("\n").flatMap((line) => {
@@ -10389,9 +10823,9 @@ function parseChatMessageSendersJsonl(content) {
 
 // src/services/upload-chat-transcripts.ts
 var HISTORY_DIRS = [
-  join26(ENGINE_DIR2, "claude-histories"),
-  join26(ENGINE_DIR2, "relay-histories"),
-  join26(ENGINE_DIR2, "codex-histories")
+  join27(ENGINE_DIR2, "claude-histories"),
+  join27(ENGINE_DIR2, "relay-histories"),
+  join27(ENGINE_DIR2, "codex-histories")
 ];
 async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), capture) {
   let flushed = 0;
@@ -10409,7 +10843,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
       if (!entry.endsWith(".jsonl")) continue;
       const chatId = basename2(entry, ".jsonl");
       tasks.push(
-        uploadChatTranscript(chatId, join26(dir, entry), chatsById.get(chatId), capture).then((artifact) => {
+        uploadChatTranscript(chatId, join27(dir, entry), chatsById.get(chatId), capture).then((artifact) => {
           flushed++;
           if (artifact && capture) revisions.push(artifact);
         }).catch((err) => {
@@ -10511,7 +10945,7 @@ async function flushRepoState() {
 // src/services/upload-engine-logs.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { readdir as readdir9, stat as stat5 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var MAX_ENGINE_LOG_FLUSH_SESSIONS = 10;
 var MAX_ENGINE_LOG_FLUSH_BYTES = 5 * 1024 * 1024;
 var ENGINE_LOG_FLUSH_TIMEOUT_MS = 2e4;
@@ -10540,7 +10974,7 @@ async function flushAllEngineLogs() {
   const candidates = (await Promise.all(filenames.slice(0, MAX_ENGINE_LOG_FLUSH_SESSIONS).map(async (filename) => {
     try {
       const sessionId = filename.slice(0, -".log".length);
-      const filePath = join27(LOG_DIR, filename);
+      const filePath = join28(LOG_DIR, filename);
       const fileStat = await runBeforeDeadline(() => stat5(filePath), deadline);
       if (!fileStat.isFile()) {
         skipped++;
@@ -10636,16 +11070,19 @@ async function uploadEngineLog(input, timeoutMs) {
 }
 
 // src/services/chat/chat-service.ts
-var CODEX_AUTH_PATH2 = join28(homedir15(), ".codex", "auth.json");
+var CODEX_AUTH_PATH2 = join29(homedir15(), ".codex", "auth.json");
 var CHATS_BACKUP_FILE = `${CHATS_FILE}.bak`;
 function isCodexAvailable() {
-  return existsSync7(CODEX_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENAI_API_KEY);
+  return existsSync8(CODEX_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENAI_API_KEY);
 }
 function isOpencodeAvailable() {
-  return existsSync7(OPENCODE_AUTH_PATH);
+  return existsSync8(OPENCODE_AUTH_PATH);
+}
+function isDeepseekAvailable() {
+  return Boolean(getDeepseekApiKey());
 }
 function isPiAvailable() {
-  return existsSync7(PI_AUTH_PATH);
+  return existsSync8(PI_AUTH_PATH);
 }
 function isCursorAvailable() {
   return Boolean(ENGINE_ENV.CURSOR_API_KEY);
@@ -10763,13 +11200,13 @@ var ChatService = class {
   persistInFlight = false;
   persistQueued = false;
   async initialize() {
-    await mkdir15(ENGINE_DIR2, { recursive: true });
-    await mkdir15(CLAUDE_HISTORY_DIR, { recursive: true });
-    await mkdir15(RELAY_HISTORY_DIR, { recursive: true });
-    await mkdir15(CODEX_HISTORY_DIR, { recursive: true });
-    await mkdir15(CURSOR_HISTORY_DIR, { recursive: true });
-    await mkdir15(OPENCODE_HISTORY_DIR, { recursive: true });
-    await mkdir15(CHAT_SENDERS_DIR, { recursive: true });
+    await mkdir16(ENGINE_DIR2, { recursive: true });
+    await mkdir16(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir16(RELAY_HISTORY_DIR, { recursive: true });
+    await mkdir16(CODEX_HISTORY_DIR, { recursive: true });
+    await mkdir16(CURSOR_HISTORY_DIR, { recursive: true });
+    await mkdir16(OPENCODE_HISTORY_DIR, { recursive: true });
+    await mkdir16(CHAT_SENDERS_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -11155,7 +11592,7 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    await rm2(join28(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
+    await rm2(join29(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`), { force: true });
     await rm2(chatMessageSendersFilePath(persisted.id), { force: true });
   }
   async getChatHistory(chatId, page = {}) {
@@ -11260,7 +11697,7 @@ var ChatService = class {
     if (persisted.provider === "claude") {
       provider = new ClaudeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -11268,24 +11705,39 @@ var ChatService = class {
         onProcessingChanged
       });
     } else if (persisted.provider === "relay") {
+      const getProviderAvailability = () => ({
+        codexAvailable: isCodexAvailable(),
+        opencodeAvailable: isOpencodeAvailable(),
+        piAvailable: isPiAvailable(),
+        cursorAvailable: isCursorAvailable(),
+        deepseekAvailable: isDeepseekAvailable()
+      });
       provider = new RelayManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
         onEvent: onProviderEvent,
         onProcessingChanged,
         chatId: persisted.id,
-        codexAvailable: isCodexAvailable(),
-        opencodeAvailable: isOpencodeAvailable(),
-        piAvailable: isPiAvailable(),
-        cursorAvailable: isCursorAvailable()
+        ...getProviderAvailability(),
+        getProviderAvailability
       });
     } else if (persisted.provider === "cursor") {
       provider = new CursorManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
+        initialSessionId: persisted.providerSessionId,
+        onSaveSessionId: saveSession,
+        onTurnComplete: onProviderTurnComplete,
+        onEvent: onProviderEvent,
+        onProcessingChanged
+      });
+    } else if (persisted.provider === "deepseek") {
+      provider = new DeepseekManager({
+        workingDirectory: this.workingDirectory,
+        historyFilePath: join29(DEEPSEEK_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -11295,7 +11747,7 @@ var ChatService = class {
     } else if (persisted.provider === "opencode") {
       provider = new OpencodeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(OPENCODE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(OPENCODE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -11305,7 +11757,7 @@ var ChatService = class {
     } else if (persisted.provider === "pi") {
       provider = new PiManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(PI_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(PI_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -11315,7 +11767,7 @@ var ChatService = class {
     } else {
       provider = new CodexAspManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join28(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -11480,7 +11932,7 @@ var ChatService = class {
     });
     uploadChatTranscript(
       chatId,
-      join28(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
+      join29(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
       this.toSummary(chat)
     ).catch((err) => {
       console.error("[ChatService] Failed to upload chat transcript:", { chatId, err });
@@ -11618,7 +12070,7 @@ var ChatService = class {
 // src/services/repo-file-service.ts
 import { execFile } from "child_process";
 import { readFile as readFile16, realpath, stat as stat6 } from "fs/promises";
-import { join as join29, resolve as resolve2, extname as extname2 } from "path";
+import { join as join30, resolve as resolve2, extname as extname2 } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -11770,7 +12222,7 @@ var RepoFileService = class {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo) return null;
     try {
-      const fullPath = await realpath(resolve2(join29(repo.path, filePath)));
+      const fullPath = await realpath(resolve2(join30(repo.path, filePath)));
       const repoRoot = await realpath(repo.path);
       const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
       if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
@@ -11903,22 +12355,22 @@ var RepoFileService = class {
 
 // src/v1-routes.ts
 import { Hono } from "hono";
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 import { readdir as readdir11, stat as stat7, readFile as readFile19 } from "fs/promises";
-import { join as join32, resolve as resolve3 } from "path";
+import { join as join33, resolve as resolve3 } from "path";
 
 // src/services/warm-hooks-service.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { readFile as readFile18 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import { join as join31 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join32 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir16, readFile as readFile17, writeFile as writeFile6, readdir as readdir10, appendFile as appendFile5, unlink as unlink4 } from "fs/promises";
+import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile6, readdir as readdir10, appendFile as appendFile5, unlink as unlink4 } from "fs/promises";
 import { homedir as homedir16 } from "os";
-import { join as join30 } from "path";
-var LOGS_DIR2 = join30(homedir16(), ".replicas", "warm-hook-logs");
-var CURRENT_RUN_LOG = join30(LOGS_DIR2, "current-run.log");
+import { join as join31 } from "path";
+var LOGS_DIR2 = join31(homedir16(), ".replicas", "warm-hook-logs");
+var CURRENT_RUN_LOG = join31(LOGS_DIR2, "current-run.log");
 var GLOBAL_FILENAME = "global.json";
 function withPreview2(stored) {
   const preview = buildHookOutputPreview(stored.output);
@@ -11926,7 +12378,7 @@ function withPreview2(stored) {
 }
 var WarmHookLogsService = class {
   async ensureDir() {
-    await mkdir16(LOGS_DIR2, { recursive: true });
+    await mkdir17(LOGS_DIR2, { recursive: true });
   }
   async saveGlobalHookLog(entry) {
     await this.ensureDir();
@@ -11935,7 +12387,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile6(join30(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join31(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -11945,7 +12397,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile6(join30(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join31(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -11955,7 +12407,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile6(join30(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile6(join31(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -11974,7 +12426,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile17(join30(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile17(join31(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -12012,7 +12464,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile17(join30(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile17(join31(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -12031,8 +12483,8 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join31(repoPath, filename);
-    if (!existsSync8(configPath)) {
+    const configPath = join32(repoPath, filename);
+    if (!existsSync9(configPath)) {
       continue;
     }
     try {
@@ -12083,7 +12535,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve5) => {
-    const proc = spawn3("bash", ["-lc", params.content], {
+    const proc = spawn4("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -12293,8 +12745,8 @@ ${combinedScript}` : combinedScript;
 
 // src/services/terminal-service.ts
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync9 } from "fs";
-import { spawn as spawn4 } from "node-pty";
+import { existsSync as existsSync10 } from "fs";
+import { spawn as spawn5 } from "node-pty";
 var MAX_REPLAY_CHARS = 1024 * 1024;
 var MAX_TERMINAL_SESSIONS = 8;
 var MAX_PENDING_INPUT = 64;
@@ -12312,8 +12764,8 @@ var TerminalService = class {
       });
     }
     const id = randomUUID7();
-    const shell = process.env.SHELL && existsSync9(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
-    const pty = spawn4(shell, ["-l"], {
+    const shell = process.env.SHELL && existsSync10(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
+    const pty = spawn5(shell, ["-l"], {
       name: "xterm-256color",
       cols,
       rows,
@@ -12411,75 +12863,75 @@ var TerminalService = class {
 var terminalService = new TerminalService();
 
 // src/v1-routes.ts
-var imageMediaTypeSchema = z4.enum(IMAGE_MEDIA_TYPES);
-var createPreviewSchema = z4.object({
-  port: z4.number().int().min(1).max(65535),
-  publicUrl: z4.string().min(1)
+var imageMediaTypeSchema = z6.enum(IMAGE_MEDIA_TYPES);
+var createPreviewSchema = z6.object({
+  port: z6.number().int().min(1).max(65535),
+  publicUrl: z6.string().min(1)
 });
-var terminalSizeSchema = z4.object({
-  cols: z4.number().int().min(2).max(500),
-  rows: z4.number().int().min(1).max(200)
+var terminalSizeSchema = z6.object({
+  cols: z6.number().int().min(2).max(500),
+  rows: z6.number().int().min(1).max(200)
 });
-var writeTerminalSessionSchema = z4.object({
-  data: z4.string().max(64 * 1024),
-  generation: z4.number().int().nonnegative(),
-  sequence: z4.number().int().nonnegative()
+var writeTerminalSessionSchema = z6.object({
+  data: z6.string().max(64 * 1024),
+  generation: z6.number().int().nonnegative(),
+  sequence: z6.number().int().nonnegative()
 });
-var mergePullRequestSchema = z4.object({
-  prUrl: z4.string().url()
+var mergePullRequestSchema = z6.object({
+  prUrl: z6.string().url()
 });
-var sendMessageSchema = z4.object({
-  messageId: z4.string().min(1).optional(),
-  submittedAt: z4.string().datetime().optional(),
-  message: z4.string().min(1),
-  model: z4.string().optional(),
-  customInstructions: z4.string().optional(),
-  planMode: z4.boolean().optional(),
-  images: z4.array(z4.object({
-    type: z4.literal("image"),
-    source: z4.union([
-      z4.object({
-        type: z4.literal("base64"),
+var sendMessageSchema = z6.object({
+  messageId: z6.string().min(1).optional(),
+  submittedAt: z6.string().datetime().optional(),
+  message: z6.string().min(1),
+  model: z6.string().optional(),
+  customInstructions: z6.string().optional(),
+  planMode: z6.boolean().optional(),
+  images: z6.array(z6.object({
+    type: z6.literal("image"),
+    source: z6.union([
+      z6.object({
+        type: z6.literal("base64"),
         media_type: imageMediaTypeSchema,
-        data: z4.string().min(1)
+        data: z6.string().min(1)
       }),
-      z4.object({
-        type: z4.literal("url"),
-        url: z4.string().url()
+      z6.object({
+        type: z6.literal("url"),
+        url: z6.string().url()
       })
     ])
   })).optional(),
-  thinkingLevel: z4.enum(VALID_THINKING_LEVELS).optional(),
-  goalMode: z4.boolean().optional(),
-  fastMode: z4.boolean().optional(),
-  enableInteractiveTools: z4.boolean().optional(),
-  type: z4.string().min(1).optional(),
-  merge: z4.boolean().optional(),
-  idempotencyKey: z4.string().min(1).max(128).optional(),
-  senderUserId: z4.string().optional(),
-  senderEmail: z4.string().optional(),
-  senderDisplayName: z4.string().optional(),
-  senderAvatarUrl: z4.string().optional(),
-  errorNotificationTarget: z4.discriminatedUnion("type", [
-    z4.object({ type: z4.literal("slack") }),
-    z4.object({ type: z4.literal("linear"), sessionId: z4.string().min(1) }),
-    z4.object({
-      type: z4.literal("code_host"),
-      provider: z4.enum(["github", "gitlab"]),
-      resource: z4.enum(["issue", "pull_request"]),
-      repositoryId: z4.string().min(1),
-      resourceNumber: z4.number().int().positive()
+  thinkingLevel: z6.enum(VALID_THINKING_LEVELS).optional(),
+  goalMode: z6.boolean().optional(),
+  fastMode: z6.boolean().optional(),
+  enableInteractiveTools: z6.boolean().optional(),
+  type: z6.string().min(1).optional(),
+  merge: z6.boolean().optional(),
+  idempotencyKey: z6.string().min(1).max(128).optional(),
+  senderUserId: z6.string().optional(),
+  senderEmail: z6.string().optional(),
+  senderDisplayName: z6.string().optional(),
+  senderAvatarUrl: z6.string().optional(),
+  errorNotificationTarget: z6.discriminatedUnion("type", [
+    z6.object({ type: z6.literal("slack") }),
+    z6.object({ type: z6.literal("linear"), sessionId: z6.string().min(1) }),
+    z6.object({
+      type: z6.literal("code_host"),
+      provider: z6.enum(["github", "gitlab"]),
+      resource: z6.enum(["issue", "pull_request"]),
+      repositoryId: z6.string().min(1),
+      resourceNumber: z6.number().int().positive()
     }),
-    z4.object({ type: z4.literal("automation"), executionId: z4.string().min(1) })
+    z6.object({ type: z6.literal("automation"), executionId: z6.string().min(1) })
   ]).optional()
 });
-var respondToolInputSchema = z4.object({
-  requestId: z4.string().min(1),
-  selectionId: z4.string().min(1)
+var respondToolInputSchema = z6.object({
+  requestId: z6.string().min(1),
+  selectionId: z6.string().min(1)
 });
-var updateGoalSchema = z4.object({
-  objective: z4.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
-  status: z4.enum(["active", "paused"]).optional()
+var updateGoalSchema = z6.object({
+  objective: z6.string().trim().min(1).max(MAX_CODEX_GOAL_OBJECTIVE_CHARS).optional(),
+  status: z6.enum(["active", "paused"]).optional()
 }).refine((body) => body.objective !== void 0 || body.status !== void 0, {
   message: "Goal objective or status required"
 });
@@ -12670,7 +13122,7 @@ function createV1Routes(deps) {
       const result = await deps.chatService.updateGoal(c.req.param("chatId"), body);
       return c.json(result);
     } catch (error) {
-      if (error instanceof z4.ZodError) {
+      if (error instanceof z6.ZodError) {
         return c.json(jsonError(error.issues[0]?.message || "Invalid goal update"), 400);
       }
       if (error instanceof ChatNotFoundError) {
@@ -13295,7 +13747,7 @@ data: ${JSON.stringify("Terminal session not found")}
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join32(LOG_DIR, filename);
+          const filePath = join33(LOG_DIR, filename);
           const fileStat = await stat7(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {
@@ -13401,17 +13853,17 @@ var HeartbeatService = class _HeartbeatService {
 var heartbeatService = new HeartbeatService();
 
 // src/services/workspace-sdk-service.ts
-import { cp, mkdir as mkdir17 } from "fs/promises";
-import { dirname as dirname8, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { cp, mkdir as mkdir18 } from "fs/promises";
+import { dirname as dirname9, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 async function installWorkspaceSdk() {
-  const source = resolve4(dirname8(fileURLToPath2(import.meta.url)), "../../workspace-sdk");
+  const source = resolve4(dirname9(fileURLToPath3(import.meta.url)), "../../workspace-sdk");
   const targets = [
     resolve4(ENGINE_ENV.HOME_DIR, "node_modules/@replicas/sdk"),
     "/tmp/node_modules/@replicas/sdk"
   ];
   await Promise.all(targets.map(async (target) => {
-    await mkdir17(target, { recursive: true });
+    await mkdir18(target, { recursive: true });
     await cp(source, target, { recursive: true, force: true });
   }));
 }
@@ -13439,7 +13891,7 @@ async function timeStartupStep(name, fn) {
 async function waitForInitializationGate() {
   if (!ENGINE_ENV.REPLICAS_ENGINE_DEFER_INITIALIZATION) return;
   const deadline = Date.now() + ENGINE_INIT_GATE_TIMEOUT_MS;
-  while (!existsSync10(SANDBOX_PATHS.ENGINE_INIT_GATE)) {
+  while (!existsSync11(SANDBOX_PATHS.ENGINE_INIT_GATE)) {
     if (Date.now() >= deadline) {
       throw new Error("Timed out waiting for deferred engine initialization gate");
     }