lody 0.102.0 → 0.104.0

package/dist/deepseek-acp.js

@@ -1,38 +1,82 @@
+import { R as RequestError, j as DEEPSEEK_HARNESS_BASE_URL_ENV, l as DEEPSEEK_HARNESS_API_KEY_ENV, n as ndJsonStream, o as AgentSideConnection, a as DEEPSEEK_HARNESS_AGENT_PRESETS, p as ACP_EXTENSION_DSH_VERSION, P as PROTOCOL_VERSION, q as DEEPSEEK_HARNESS_DEFAULT_MODEL, r as DEEPSEEK_HARNESS_PROVIDER } from "./chunks/acp-C0LiROfB.js";
 import { resolve, isAbsolute } from "node:path";
-import { o as object, s as string, b as boolean, c as array, l as literal, u as unknown, n as number, a as _enum, r as record } from "./chunks/schemas-WuyisFi9.js";
+import { o as object$1, s as string, c as boolean, b as array, l as literal, u as unknown, n as number, a as _enum, r as record } from "./chunks/schemas-D_XLKCXC.js";
 import { S as SessionUsageAccumulator, L as LODY_EXTENSION_METHODS, e as supportsLodySubagentEvents, d as LODY_SUBAGENT_EVENT_METHOD } from "./chunks/subagent-events-BJ9JwZva.js";
 import { randomUUID, createHash } from "node:crypto";
 import { Readable, Writable } from "node:stream";
-import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, l as DEEPSEEK_HARNESS_API_KEY_ENV, n as ndJsonStream, o as AgentSideConnection, a as DEEPSEEK_HARNESS_AGENT_PRESETS, R as RequestError, p as ACP_EXTENSION_DSH_VERSION, P as PROTOCOL_VERSION, q as DEEPSEEK_HARNESS_DEFAULT_MODEL, r as DEEPSEEK_HARNESS_PROVIDER } from "./chunks/acp-Bsd2Lmd6.js";
 import { c as createPlanModeConfigOption, L as LODY_PLAN_MODE_CONFIG_ID } from "./chunks/plan-mode-D0D5cnMs.js";
 import { L as LodySubagentEmitter } from "./chunks/subagent-emitter-BsTuVPDw.js";
 import "node:url";
-const blockSchema = object({ type: string() }).passthrough();
-const resultSchema = object({
+function nativeTurnId(turn) {
+  return `dsh-turn:${turn}`;
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function forkTarget(meta2) {
+  const lody = object(object(meta2)?.lody);
+  if (!lody || !Object.hasOwn(lody, "forkAtTurn"))
+    return void 0;
+  const target = object(lody.forkAtTurn);
+  if (!target || target.version !== 1 || target.turnId !== void 0 && (typeof target.turnId !== "string" || !/^dsh-turn:(0|[1-9]\d*)$/.test(target.turnId) || !Number.isSafeInteger(Number(target.turnId.slice("dsh-turn:".length)))))
+    throw RequestError.invalidParams(void 0, "invalid _meta.lody.forkAtTurn");
+  return target?.turnId;
+}
+function forkSnapshot(source, target) {
+  const events = source.events;
+  const end = target === void 0 ? events.length - 1 : events.findIndex((event) => event.type === "turn/end" && typeof event.data.turn === "number" && nativeTurnId(event.data.turn) === target);
+  if (target !== void 0 && end === -1)
+    throw RequestError.invalidParams(void 0, "fork turn is unknown or has not ended");
+  const prefix = events.slice(0, end + 1);
+  const lastTurn = [...prefix].reverse().find((event) => event.type === "turn/start" || event.type === "turn/end");
+  if (lastTurn?.type === "turn/start")
+    throw RequestError.invalidParams(void 0, "cannot fork an unfinished turn; select an earlier completed turn");
+  let agentPreset = source.header.agentPreset;
+  let selection;
+  for (const [index, event] of prefix.entries()) {
+    if (event.seq !== index)
+      throw RequestError.invalidParams(void 0, "source session has a non-contiguous log");
+    if (event.type === "agent-preset/selected" && typeof event.data.agentPreset === "string")
+      agentPreset = event.data.agentPreset;
+    if (event.type === "request/header") {
+      const config = object(object(event.data.header)?.config);
+      if (!config || typeof config.provider !== "string" || typeof config.model !== "string")
+        throw RequestError.invalidParams(void 0, "source request header has no model route");
+      selection = {
+        provider: config.provider,
+        model: config.model,
+        ...typeof config.reasoningEffort === "string" ? { reasoningEffort: config.reasoningEffort } : {}
+      };
+    }
+  }
+  return { sourceId: source.header.id, seed: structuredClone(prefix), agentPreset, selection };
+}
+const blockSchema = object$1({ type: string() }).passthrough();
+const resultSchema = object$1({
   type: literal("tool-result"),
   toolCallId: string().min(1),
   content: array(blockSchema),
   isError: boolean().optional()
 });
-const callSchema = object({
+const callSchema = object$1({
   callId: string().min(1),
   name: string().min(1),
   arguments: string()
 });
-const ptcSchema = object({
+const ptcSchema = object$1({
   subCallId: string().min(1),
   name: string().min(1),
   arguments: unknown(),
   parentCallId: string(),
   rootCallId: string()
 });
-const locationSchema = object({ path: string(), line: number().int().positive().optional() });
-const viewSchema = object({
+const locationSchema = object$1({ path: string(), line: number().int().positive().optional() });
+const viewSchema = object$1({
   card: _enum(["generic", "terminal", "diff", "read", "search", "web"]),
   title: string().optional(),
   kind: _enum(["read", "edit", "delete", "move", "search", "execute", "fetch", "other"]).optional(),
   locations: array(locationSchema).optional(),
-  diffs: array(object({ path: string(), oldText: string().nullable(), newText: string() })).optional(),
+  diffs: array(object$1({ path: string(), oldText: string().nullable(), newText: string() })).optional(),
   output: string().optional(),
   content: array(blockSchema).optional()
 }).passthrough();
@@ -163,8 +207,8 @@ class ToolCallBridge {
       }
       await this.start(call.callId, call.name, args);
     } else if (type === "tool/result") {
-      const event = object({
-        message: object({ content: array(resultSchema) }),
+      const event = object$1({
+        message: object$1({ content: array(resultSchema) }),
         meta: unknown().optional()
       }).passthrough().parse(data);
       for (const block of event.message.content) {
@@ -174,7 +218,7 @@ class ToolCallBridge {
       const call = ptcSchema.parse(data);
       await this.start(call.subCallId, call.name, call.arguments);
       if (type === "tool/ptc-dispatch") {
-        const result = object({ content: array(blockSchema), isError: boolean() }).passthrough().parse(data);
+        const result = object$1({ content: array(blockSchema), isError: boolean() }).passthrough().parse(data);
         await this.finish(call.subCallId, result, result);
       }
     } else if (type === "turn/end") {
@@ -234,17 +278,17 @@ class HarnessUsageTracker {
     return this.accumulator.update(sessionId, String(seq), { [this.route.model]: usage });
   }
 }
-const questionSchema = object({
+const questionSchema = object$1({
   id: string().refine((value) => value.trim().length > 0),
   question: string().min(1),
   header: string().optional(),
   detail: string().optional(),
-  options: array(object({
+  options: array(object$1({
     label: string().min(1),
     description: string().optional()
   })).optional(),
   multiSelect: boolean().optional(),
-  intent: object({ kind: literal("plan-review"), approve: string() }).optional()
+  intent: object$1({ kind: literal("plan-review"), approve: string() }).optional()
 });
 function failure(code, message) {
   return Object.assign(new Error(message), { name: "UserQuestionError", code });
@@ -364,7 +408,7 @@ class UserQuestionBridge {
       throw failure("ASK_ABORTED", "The user cancelled the question");
     if (response.action === "decline")
       throw failure("ASK_DECLINED", "The user declined the question");
-    const accepted = object({
+    const accepted = object$1({
       action: literal("accept"),
       content: record(string(), unknown())
     }).safeParse(response);
@@ -409,11 +453,13 @@ const inject = [
   "llm",
   "permissionPresets",
   "sessionPersistence",
+  "sessions",
   "sessionQuery",
   "sessionTitle",
   "userQuestions"
 ];
 const LODY_CAPABILITIES = {
+  forkAtTurn: { version: 1 },
   subagentEvents: { version: 1 },
   sessionTitle: { version: 1 },
   compaction: { version: 1 },
@@ -432,6 +478,7 @@ const MODEL_DISCOVERY_TIMEOUT_MS = 15e3;
 const MODEL_DISCOVERY_MAX_BYTES = 1024 * 1024;
 const MODEL_DISCOVERY_MAX_MODELS = 1e3;
 const MODEL_ID_MAX_LENGTH = 512;
+const ACP_MODEL_ID_PREFIX = "dsh-route:";
 const INVALID_MCP_SERVER_NAME_CHARS = /[^A-Za-z0-9_-]/gu;
 const IMAGE_MEDIA_TYPES = [
   "image/png",
@@ -470,33 +517,60 @@ function resolveAdapterConfig(config) {
     ...config?.stream ? { stream: config.stream } : {}
   };
 }
-async function loadHarnessModels(llm, provider, configuredModel, endpoint) {
-  const listed = endpoint ? (await discoverDeepSeekModelIds(endpoint.baseUrl, endpoint.apiKey)).map((id) => ({
-    provider,
-    id
-  })) : await llm.listModels(provider);
-  const modelIds = [];
-  const ids = /* @__PURE__ */ new Set();
-  for (const model of listed) {
-    if (model.provider !== provider || !model.id.trim())
-      continue;
-    if (ids.has(model.id)) {
-      throw new Error(`acp-extension-dsh: duplicate model ${JSON.stringify(model.id)} for provider ${JSON.stringify(provider)}`);
+async function loadHarnessModels(llm, defaultProvider, configuredModel, endpoint) {
+  const providers = llm.listProviders?.() ?? [{ id: defaultProvider, name: defaultProvider }];
+  if (!providers.some(({ id }) => id === defaultProvider)) {
+    throw new Error(`configured provider ${JSON.stringify(defaultProvider)} is unavailable`);
+  }
+  const identities = [];
+  for (const { id: provider } of providers) {
+    const listed = endpoint && provider === defaultProvider ? (await discoverDeepSeekModelIds(endpoint.baseUrl, endpoint.apiKey)).map((id) => ({
+      provider,
+      id
+    })) : await llm.listModels(provider);
+    const ids = /* @__PURE__ */ new Set();
+    for (const model of listed) {
+      if (model.provider !== provider || !model.id.trim())
+        continue;
+      if (ids.has(model.id)) {
+        throw new Error(`acp-extension-dsh: duplicate model ${JSON.stringify(model.id)} for provider ${JSON.stringify(provider)}`);
+      }
+      ids.add(model.id);
+      identities.push({ provider, model: model.id });
+    }
+    if (endpoint && provider === defaultProvider && ids.size === 0) {
+      throw new Error("the endpoint returned no usable models");
+    }
+    if (provider === defaultProvider && !endpoint && !ids.has(configuredModel)) {
+      identities.unshift({ provider, model: configuredModel });
     }
-    ids.add(model.id);
-    modelIds.push(model.id);
   }
-  if (endpoint && modelIds.length === 0) {
+  const initialSelection = endpoint ? identities.find(({ provider }) => provider === defaultProvider) : { provider: defaultProvider, model: configuredModel };
+  if (!initialSelection)
     throw new Error("the endpoint returned no usable models");
-  }
-  if (!endpoint && !ids.has(configuredModel))
-    modelIds.unshift(configuredModel);
-  const initialModel = endpoint ? modelIds[0] : configuredModel;
   return {
-    models: await Promise.all(modelIds.map((modelId) => resolveHarnessModel(llm, provider, modelId))),
-    initialModel
+    models: await Promise.all(identities.map(({ provider, model }) => resolveHarnessModel(llm, provider, model))),
+    initialSelection
   };
 }
+function encodeAcpModelId(provider, model) {
+  return `${ACP_MODEL_ID_PREFIX}${Buffer.from(JSON.stringify([provider, model])).toString("base64url")}`;
+}
+function decodeAcpModelId(value, legacyProvider) {
+  if (!value.startsWith(ACP_MODEL_ID_PREFIX))
+    return { provider: legacyProvider, model: value };
+  try {
+    const decoded = JSON.parse(Buffer.from(value.slice(ACP_MODEL_ID_PREFIX.length), "base64url").toString("utf8"));
+    if (Array.isArray(decoded) && decoded.length === 2 && decoded.every((part) => typeof part === "string" && part.trim())) {
+      return { provider: decoded[0], model: decoded[1] };
+    }
+  } catch {
+  }
+  throw invalidParams("model route id is invalid");
+}
+function selectedModel(record2) {
+  return record2.models.find((candidate) => candidate.provider === record2.selection.current.provider && candidate.id === record2.selection.current.model);
+}
 function modelDiscoveryUrl(baseUrl) {
   const url = new URL(baseUrl);
   url.pathname = `${url.pathname.replace(/\/+$/u, "")}/models`;
@@ -727,13 +801,13 @@ function configOptions(record2) {
     {
       id: MODEL_CONFIG_ID,
       name: "Model",
-      description: "DeepSeek model used for the session",
+      description: "Provider route and model used for the session",
       category: "model",
       type: "select",
-      currentValue: record2.selection.current.model,
+      currentValue: encodeAcpModelId(record2.selection.current.provider, record2.selection.current.model),
       options: record2.models.map((model2) => ({
-        value: model2.id,
-        name: model2.name,
+        value: encodeAcpModelId(model2.provider, model2.id),
+        name: `${model2.name} (${model2.provider})`,
         description: model2.description ?? null
       }))
     }
@@ -743,7 +817,7 @@ function configOptions(record2) {
     const state = plan.get(record2.agent);
     options.push(createPlanModeConfigOption(state.pending ?? state.active));
   }
-  const model = record2.models.find((candidate) => candidate.id === record2.selection.current.model);
+  const model = selectedModel(record2);
   if (model?.reasoning && record2.selection.current.reasoningEffort) {
     options.push({
       id: REASONING_EFFORT_CONFIG_ID,
@@ -763,16 +837,16 @@ function configOptions(record2) {
 }
 function legacyModels(record2) {
   return {
-    currentModelId: record2.selection.current.model,
+    currentModelId: encodeAcpModelId(record2.selection.current.provider, record2.selection.current.model),
     availableModels: record2.models.flatMap((model) => [
       {
-        modelId: model.id,
-        name: model.name,
+        modelId: encodeAcpModelId(model.provider, model.id),
+        name: `${model.name} (${model.provider})`,
         description: model.description ?? null
       },
       ...model.reasoning?.efforts.map((effort) => ({
-        modelId: `${model.id}[${effort.id}]`,
-        name: `${model.name} (${effort.name})`,
+        modelId: `${encodeAcpModelId(model.provider, model.id)}[${effort.id}]`,
+        name: `${model.name} (${model.provider}, ${effort.name})`,
         description: model.description ?? null
       })) ?? []
     ])
@@ -1112,6 +1186,11 @@ function apply(ctx, rawConfig) {
       });
     });
   });
+  const flushSession = async (session) => {
+    const store = ctx.get("sessions");
+    if (!store || !await store.flush(session))
+      throw new Error("no session durability listener is available");
+  };
   const settleAfterQuiescence = (record2, inflight) => {
     if (inflight.settlementStarted)
       return;
@@ -1122,6 +1201,7 @@ function apply(ctx, rawConfig) {
         await record2.agent.whenIdle();
         await record2.outputTail;
         await record2.tools.interrupt();
+        await flushSession(record2.agent.session);
       }
       if (record2.inflight !== inflight)
         return;
@@ -1300,7 +1380,11 @@ function apply(ctx, rawConfig) {
               continue;
             await notify({
               sessionId: record2.agent.session.id,
-              update: { sessionUpdate: "agent_message_chunk", content }
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content,
+                ...typeof event.data.turn === "number" ? { _meta: { lody: { turnId: nativeTurnId(event.data.turn) } } } : {}
+              }
             });
           }
         }, inflight);
@@ -1347,9 +1431,19 @@ function apply(ctx, rawConfig) {
     }
   });
   ctx.on("agent/inbox/claimed", ({ agent, message, turn }) => {
-    const inflight = ownedRecord(agent)?.inflight;
-    if (inflight && inflight.messageId === message.id)
+    const record2 = ownedRecord(agent);
+    const inflight = record2?.inflight;
+    if (record2 && inflight && inflight.messageId === message.id) {
       inflight.turn = turn;
+      enqueueNotification(record2, {
+        sessionId: agent.session.id,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "" },
+          _meta: { lody: { turnId: nativeTurnId(turn) } }
+        }
+      }, inflight);
+    }
   });
   ctx.on("agent/error", ({ agent, turn, error }) => {
     const record2 = ownedRecord(agent);
@@ -1440,26 +1534,27 @@ function apply(ctx, rawConfig) {
         throw invalidParams(`failed to select agent preset ${JSON.stringify(value)}: ${errorChain(error)}`);
       });
     } else if (params.configId === MODEL_CONFIG_ID) {
-      return resolveHarnessModel(llm, record2.selection.current.provider, value).then((model) => {
-        const index = record2.models.findIndex((candidate) => candidate.id === value);
+      const selected = decodeAcpModelId(value, record2.selection.current.provider);
+      return resolveHarnessModel(llm, selected.provider, selected.model).then((model) => {
+        const index = record2.models.findIndex((candidate) => candidate.provider === selected.provider && candidate.id === selected.model);
         if (index === -1)
           record2.models.push(model);
         else
           record2.models[index] = model;
         const reasoningEffort = resolveReasoningEffort(model, record2.selection.current.reasoningEffort && model.reasoning?.efforts.some((effort) => effort.id === record2.selection.current.reasoningEffort) ? record2.selection.current.reasoningEffort : void 0);
         record2.selection.current = {
-          provider: record2.selection.current.provider,
-          model: value,
+          provider: selected.provider,
+          model: selected.model,
           ...reasoningEffort ? { reasoningEffort } : {}
         };
         return { configOptions: configOptions(record2) };
       }).catch((error) => {
         if (error instanceof RequestError)
           throw error;
-        throw invalidParams(`failed to resolve model ${JSON.stringify(value)}: ${errorChain(error)}`);
+        throw invalidParams(`failed to resolve model route ${JSON.stringify(selected.provider)} / ${JSON.stringify(selected.model)}: ${errorChain(error)}`);
       });
     } else if (params.configId === REASONING_EFFORT_CONFIG_ID) {
-      const model = record2.models.find((candidate) => candidate.id === record2.selection.current.model);
+      const model = selectedModel(record2);
       if (!model)
         throw internalError("selected model metadata is unavailable");
       const reasoningEffort = resolveReasoningEffort(model, value);
@@ -1475,6 +1570,150 @@ function apply(ctx, rawConfig) {
     }
     return { configOptions: configOptions(record2) };
   };
+  const createSession = async (params, fork) => {
+    assertOpen();
+    validateSessionParams(params);
+    let catalog;
+    try {
+      catalog = await loadModelCatalog();
+    } catch (error) {
+      throw internalError(`failed to discover models: ${errorChain(error)}`);
+    }
+    const models = [...catalog.models];
+    const initialSelection = fork?.selection ?? catalog.initialSelection;
+    if (fork?.selection) {
+      const model = await resolveHarnessModel(llm, initialSelection.provider, initialSelection.model);
+      const index = models.findIndex((candidate) => candidate.provider === model.provider && candidate.id === model.id);
+      if (index < 0)
+        models.push(model);
+      else
+        models[index] = model;
+    }
+    const sessionId = randomUUID();
+    const questions = new UserQuestionBridge(sessionId, (request) => conn.unstable_createElicitation(request), () => questionCapabilities);
+    const initialModel = models.find((model) => model.provider === initialSelection.provider && model.id === initialSelection.model);
+    if (!initialModel)
+      throw internalError("initial model metadata is unavailable");
+    const reasoningEffort = resolveReasoningEffort(initialModel, fork?.selection ? fork.selection.reasoningEffort : config.reasoningEffort);
+    const selection = {
+      current: {
+        provider: initialSelection.provider,
+        model: initialSelection.model,
+        ...reasoningEffort ? { reasoningEffort } : {}
+      }
+    };
+    const agentPresetOptions = (await ctx.agentPresets.list()).filter((preset) => preset.broken === void 0);
+    const requestedPreset = fork?.agentPreset ?? ctx.agentPresets.defaultId;
+    if (!agentPresetOptions.some((preset) => preset.id === requestedPreset)) {
+      throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} is unavailable`);
+    }
+    const mcpServerNames = reserveMcpServerNames(params.mcpServers, sessionId, activeMcpServerNames);
+    let mountedPreset = requestedPreset;
+    let handle;
+    try {
+      handle = await ctx.agents.create({
+        sessionId,
+        meta: {
+          cwd: params.cwd,
+          agentPreset: requestedPreset,
+          ...fork ? { parentSession: fork.sourceId, isSeeded: true } : {}
+        },
+        ...fork ? { seed: fork.seed, inheritedEventCount: fork.seed.length } : {},
+        agentOptions: {
+          provider: initialSelection.provider,
+          model: initialSelection.model
+        },
+        setup: async (agentContext) => {
+          if (subagentEvents && !carrierKeyOf) {
+            const scope = await agentContext.loader.import("@deepseek-ai/dsh-scope");
+            if (typeof scope.carrierKeyOf !== "function")
+              throw new Error("Harness scope identity API is unavailable");
+            carrierKeyOf = scope.carrierKeyOf;
+          }
+          installModelSelection(agentContext, selection);
+          agentContext.on("user-questions/request", (request, next) => {
+            if (!request.agent || ownedRecord(request.agent)?.questions !== questions)
+              return next();
+            return questions.ask(request);
+          });
+          mountedPreset = (await ctx.agentPresets.mount(agentContext, requestedPreset)).id;
+          await mountMcpServers(agentContext, params.mcpServers, mcpServerNames.names, params.cwd);
+        }
+      });
+    } catch (error) {
+      mcpServerNames.release();
+      if (error instanceof RequestError)
+        throw error;
+      throw internalError(`failed to create session: ${errorChain(error)}`);
+    }
+    const dispose = async () => {
+      questions.cancel();
+      try {
+        await handle.dispose();
+      } finally {
+        mcpServerNames.release();
+      }
+    };
+    if (closed) {
+      await dispose();
+      throw internalError("connection closed during session/new");
+    }
+    let permissionMode;
+    let permissionOptions;
+    try {
+      permissionMode = ctx.permissionPresets.current(handle.agent.session);
+      permissionOptions = permissionState(ctx, permissionMode);
+    } catch (error) {
+      await dispose();
+      throw error;
+    }
+    const record2 = {
+      cwd: params.cwd,
+      tools: new ToolCallBridge({
+        cwd: params.cwd,
+        lookup: (name2) => {
+          const tools = handle.agent.ctx.get("tools");
+          return tools?.get(name2, handle.agent);
+        },
+        content: (block) => assistantBlockToAcp(block, attachments),
+        emit: (update) => notify({ sessionId, update }),
+        warn: (message) => ctx.logger.warn(`acp-extension-dsh: ${message}`)
+      }),
+      questions,
+      usage: new HarnessUsageTracker(!baseUrl || /^https:\/\/api\.deepseek\.com(?:\/v1)?\/?$/.test(baseUrl)),
+      agent: handle.agent,
+      dispose,
+      selection,
+      permissionMode,
+      permissionOptions,
+      agentPreset: mountedPreset,
+      agentPresetOptions,
+      models,
+      started: fork?.seed.some((event) => event.type === "turn/start") ?? false,
+      outputTail: Promise.resolve()
+    };
+    if (fork) {
+      try {
+        await flushSession(handle.agent.session);
+        assertOpen();
+      } catch (error) {
+        let cleanupError;
+        try {
+          await dispose();
+        } catch (failure2) {
+          cleanupError = failure2;
+        }
+        throw internalError(`fork child ${sessionId} could not be committed: ${errorChain(error)}${cleanupError ? `; cleanup: ${errorChain(cleanupError)}` : ""}`);
+      }
+    }
+    sessions.set(sessionId, record2);
+    return {
+      sessionId,
+      modes: modeState(record2),
+      configOptions: configOptions(record2),
+      models: legacyModels(record2)
+    };
+  };
   const makeAgent = (connection) => {
     conn = connection;
     return {
@@ -1501,7 +1740,7 @@ function apply(ctx, rawConfig) {
               embeddedContext: false
             },
             mcpCapabilities: { http: true },
-            sessionCapabilities: { close: {} },
+            sessionCapabilities: { close: {}, fork: {} },
             _meta: { lody: LODY_CAPABILITIES }
           },
           authMethods: []
@@ -1510,118 +1749,36 @@ function apply(ctx, rawConfig) {
       authenticate(_params) {
         return Promise.resolve();
       },
-      async newSession(params) {
+      newSession(params) {
+        return createSession(params);
+      },
+      async unstable_forkSession(params) {
         assertOpen();
-        validateSessionParams(params);
-        let catalog;
-        try {
-          catalog = await loadModelCatalog();
-        } catch (error) {
-          throw internalError(`failed to discover models: ${errorChain(error)}`);
-        }
-        const { models, initialModel: initialModelId } = catalog;
-        const sessionId = randomUUID();
-        const questions = new UserQuestionBridge(sessionId, (request) => conn.unstable_createElicitation(request), () => questionCapabilities);
-        const initialModel = models.find((model) => model.id === initialModelId);
-        if (!initialModel)
-          throw internalError("initial model metadata is unavailable");
-        const reasoningEffort = resolveReasoningEffort(initialModel, config.reasoningEffort);
-        const selection = {
-          current: {
-            provider: config.provider,
-            model: initialModelId,
-            ...reasoningEffort ? { reasoningEffort } : {}
-          }
+        const target = forkTarget(params._meta);
+        const creation = {
+          cwd: params.cwd,
+          mcpServers: params.mcpServers ?? [],
+          additionalDirectories: params.additionalDirectories
         };
-        const agentPresetOptions = (await ctx.agentPresets.list()).filter((preset) => preset.broken === void 0);
-        const requestedPreset = ctx.agentPresets.defaultId;
-        if (!agentPresetOptions.some((preset) => preset.id === requestedPreset)) {
-          throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} is unavailable`);
-        }
-        const mcpServerNames = reserveMcpServerNames(params.mcpServers, sessionId, activeMcpServerNames);
-        let mountedPreset = requestedPreset;
-        let handle;
+        validateSessionParams(creation);
+        const query = ctx.get("sessionQuery");
+        if (!query)
+          throw internalError("Harness session query is unavailable");
+        let source;
         try {
-          handle = await ctx.agents.create({
-            sessionId,
-            meta: { cwd: params.cwd, agentPreset: requestedPreset },
-            agentOptions: { provider: config.provider, model: initialModelId },
-            setup: async (agentContext) => {
-              if (subagentEvents && !carrierKeyOf) {
-                const scope = await agentContext.loader.import("@deepseek-ai/dsh-scope");
-                if (typeof scope.carrierKeyOf !== "function")
-                  throw new Error("Harness scope identity API is unavailable");
-                carrierKeyOf = scope.carrierKeyOf;
-              }
-              installModelSelection(agentContext, selection);
-              agentContext.on("user-questions/request", (request, next) => {
-                if (!request.agent || ownedRecord(request.agent)?.questions !== questions)
-                  return next();
-                return questions.ask(request);
-              });
-              mountedPreset = (await ctx.agentPresets.mount(agentContext, requestedPreset)).id;
-              await mountMcpServers(agentContext, params.mcpServers, mcpServerNames.names, params.cwd);
-            }
-          });
+          source = await query.observeSession(params.sessionId);
         } catch (error) {
-          mcpServerNames.release();
-          if (error instanceof RequestError)
-            throw error;
-          throw internalError(`failed to create session: ${errorChain(error)}`);
+          throw invalidParams(`fork source unavailable: ${errorChain(error)}`);
         }
-        const dispose = async () => {
-          questions.cancel();
-          try {
-            await handle.dispose();
-          } finally {
-            mcpServerNames.release();
-          }
-        };
-        if (closed) {
-          await dispose();
-          throw internalError("connection closed during session/new");
-        }
-        let permissionMode;
-        let permissionOptions;
+        let snapshot;
         try {
-          permissionMode = ctx.permissionPresets.current(handle.agent.session);
-          permissionOptions = permissionState(ctx, permissionMode);
-        } catch (error) {
-          await dispose();
-          throw error;
+          if (source.header.id !== params.sessionId)
+            throw invalidParams("fork source identity mismatch");
+          snapshot = forkSnapshot(source, target);
+        } finally {
+          source[Symbol.dispose]();
         }
-        const record2 = {
-          cwd: params.cwd,
-          tools: new ToolCallBridge({
-            cwd: params.cwd,
-            lookup: (name2) => {
-              const tools = handle.agent.ctx.get("tools");
-              return tools?.get(name2, handle.agent);
-            },
-            content: (block) => assistantBlockToAcp(block, attachments),
-            emit: (update) => notify({ sessionId, update }),
-            warn: (message) => ctx.logger.warn(`acp-extension-dsh: ${message}`)
-          }),
-          questions,
-          usage: new HarnessUsageTracker(!baseUrl || /^https:\/\/api\.deepseek\.com(?:\/v1)?\/?$/.test(baseUrl)),
-          agent: handle.agent,
-          dispose,
-          selection,
-          permissionMode,
-          permissionOptions,
-          agentPreset: mountedPreset,
-          agentPresetOptions,
-          models,
-          started: false,
-          outputTail: Promise.resolve()
-        };
-        sessions.set(sessionId, record2);
-        return {
-          sessionId,
-          modes: modeState(record2),
-          configOptions: configOptions(record2),
-          models: legacyModels(record2)
-        };
+        return createSession(creation, snapshot);
       },
       setSessionMode(params) {
         const record2 = requireSession(params.sessionId);