lody 0.97.2 → 0.98.0

package/dist/deepseek-acp.js

@@ -1,13 +1,12 @@
 import { S as SessionUsageAccumulator } from "./chunks/usage-DY4Eg1Mf.js";
+import { o as object, s as string, l as literal, b as boolean, c as array, r as record, u as unknown } from "./chunks/schemas-C-NzK2uQ.js";
 import { randomUUID, createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { Readable, Writable } from "node:stream";
-import { n as ndJsonStream, A as AgentSideConnection, R as RequestError, P as PROTOCOL_VERSION } from "./chunks/acp-DCoAUZc7.js";
-import { j as DEEPSEEK_HARNESS_BASE_URL_ENV, k as DEEPSEEK_HARNESS_API_KEY_ENV, a as DEEPSEEK_HARNESS_AGENT_PRESETS, l as ACP_EXTENSION_DSH_VERSION, m as DEEPSEEK_HARNESS_DEFAULT_MODEL, n as DEEPSEEK_HARNESS_PROVIDER } from "./chunks/profile-DQaC7SJZ.js";
+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/profile-BmD8b-zH.js";
 import { L as LODY_EXTENSION_METHODS } from "./chunks/methods-CvEDMahD.js";
 import { c as createPlanModeConfigOption, L as LODY_PLAN_MODE_CONFIG_ID } from "./chunks/plan-mode-BLOER-fv.js";
 import "node:url";
-import "./chunks/schemas-C-NzK2uQ.js";
 const prices = {
   "deepseek-flash": [0.15, 3e-3, 0.6],
   // Official aliases now served and billed as DeepSeek-V4.1-Flash.
@@ -60,6 +59,172 @@ class HarnessUsageTracker {
     return this.accumulator.update(sessionId, String(seq), { [this.route.model]: usage });
   }
 }
+const questionSchema = object({
+  id: string().refine((value) => value.trim().length > 0),
+  question: string().min(1),
+  header: string().optional(),
+  detail: string().optional(),
+  options: array(object({
+    label: string().min(1),
+    description: string().optional()
+  })).optional(),
+  multiSelect: boolean().optional(),
+  intent: object({ kind: literal("plan-review"), approve: string() }).optional()
+});
+function failure(code, message) {
+  return Object.assign(new Error(message), { name: "UserQuestionError", code });
+}
+const meta = (fields = {}) => ({
+  lody: { elicitation: { version: 1, ...fields } }
+});
+class UserQuestionBridge {
+  sessionId;
+  send;
+  capabilities;
+  tail = Promise.resolve();
+  pending = /* @__PURE__ */ new Set();
+  constructor(sessionId, send, capabilities) {
+    this.sessionId = sessionId;
+    this.send = send;
+    this.capabilities = capabilities;
+  }
+  cancel() {
+    for (const controller of this.pending)
+      controller.abort();
+  }
+  ask(request) {
+    const controller = new AbortController();
+    this.pending.add(controller);
+    const signal = request.signal ? AbortSignal.any([request.signal, controller.signal]) : controller.signal;
+    const aborted = () => failure("ASK_ABORTED", "ask_user_question was cancelled before the user answered");
+    let removeListener = () => {
+    };
+    const cancellation = new Promise((_, reject) => {
+      const abort = () => reject(aborted());
+      if (signal.aborted)
+        abort();
+      else {
+        signal.addEventListener("abort", abort, { once: true });
+        removeListener = () => signal.removeEventListener("abort", abort);
+      }
+    });
+    const previous = this.tail;
+    const work = previous.then(async () => {
+      if (signal.aborted)
+        throw aborted();
+      return this.elicit(request);
+    });
+    const result = Promise.race([work, cancellation]).finally(() => {
+      removeListener();
+      this.pending.delete(controller);
+    });
+    this.tail = Promise.all([previous, result.catch(() => {
+    })]).then(() => {
+    });
+    return result;
+  }
+  async elicit(request) {
+    const capabilities = this.capabilities();
+    if (!capabilities.form)
+      throw failure("NO_PROVIDER", "ACP client does not support form elicitation");
+    const parsed = array(questionSchema).min(1).safeParse(request.questions);
+    if (!parsed.success)
+      throw failure("BAD_QUESTIONS", "Invalid user question request");
+    const questions = parsed.data;
+    if (new Set(questions.map((q) => q.id)).size !== questions.length)
+      throw failure("BAD_QUESTIONS", "Question ids must be unique");
+    const properties = /* @__PURE__ */ Object.create(null);
+    const fields = questions.map((question, index) => {
+      const key = `question_${index}`;
+      const customKey = `custom_${index}`;
+      const options = question.options ?? [];
+      if (new Set(options.map((o) => o.label)).size !== options.length)
+        throw failure("BAD_QUESTIONS", "Option labels must be unique");
+      if (question.intent && (question.detail === void 0 || !options.some((o) => o.label === question.intent?.approve)))
+        throw failure("BAD_INTENT", "Plan review requires detail and an existing approval option");
+      const description = [question.question, question.detail].filter(Boolean).join("\n\n");
+      const additive = options.length > 0 && question.multiSelect === true && capabilities.answerNotes;
+      let other = "Other";
+      while (options.some((o) => o.label === other))
+        other += " (custom)";
+      const choices = options.map((o) => ({
+        const: o.label,
+        title: o.label,
+        ...o.description ? { description: o.description } : {}
+      }));
+      if (additive)
+        choices.push({ const: other, title: other });
+      const base = { title: question.header || question.id, description };
+      properties[key] = options.length === 0 ? { ...base, type: "string" } : question.multiSelect ? { ...base, type: "array", items: { anyOf: choices } } : { ...base, type: "string", oneOf: choices };
+      if (options.length > 0)
+        properties[customKey] = {
+          type: "string",
+          title: "Other",
+          description: additive ? "Add a custom answer alongside your selections, or select Other and enter it here." : "Type your own answer instead of selecting an option.",
+          _meta: meta(additive ? { noteFor: key } : { customAnswerFor: key })
+        };
+      return {
+        question,
+        key,
+        customKey,
+        options,
+        additive,
+        other,
+        description
+      };
+    });
+    let response;
+    try {
+      response = await this.send({
+        sessionId: this.sessionId,
+        mode: "form",
+        message: fields.length === 1 ? fields[0]?.description ?? "Input requested" : "Input requested",
+        requestedSchema: { type: "object", properties },
+        _meta: meta({ autoResolveAfterSeconds: null })
+      });
+    } catch (cause) {
+      throw failure("ANSWER_FAILED", `ACP user question request failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+    if (response.action === "cancel")
+      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({
+      action: literal("accept"),
+      content: record(string(), unknown())
+    }).safeParse(response);
+    if (!accepted.success)
+      throw failure("INVALID_ANSWER", "ACP client returned an invalid question response");
+    const content = accepted.data.content;
+    return {
+      answers: fields.map(({ question, key, customKey, options, additive, other }) => {
+        const raw = content[key];
+        const custom = content[customKey];
+        const invalid = () => failure("INVALID_ANSWER", `Invalid answer for question ${question.id}`);
+        if (custom !== void 0 && typeof custom !== "string")
+          throw invalid();
+        if (options.length === 0) {
+          if (typeof raw !== "string" || !raw.trim())
+            throw invalid();
+          return { id: question.id, selected: [], custom: raw };
+        }
+        const selected = raw === void 0 ? [] : question.multiSelect ? raw : [raw];
+        if (!Array.isArray(selected) || selected.some((v) => typeof v !== "string") || new Set(selected).size !== selected.length)
+          throw invalid();
+        if (selected.some((v) => !options.some((o) => o.label === v) && !(additive && v === other)))
+          throw invalid();
+        const hasCustom = typeof custom === "string" && custom.trim().length > 0;
+        if (!selected.length && !hasCustom || additive && selected.includes(other) && !hasCustom || !question.multiSelect && selected.length > 0 && hasCustom)
+          throw invalid();
+        return {
+          id: question.id,
+          selected: selected.filter((v) => !(additive && v === other)),
+          ...hasCustom ? { custom } : {}
+        };
+      })
+    };
+  }
+}
 const name = "acp-extension-dsh";
 const inject = [
   "agents",
@@ -69,7 +234,8 @@ const inject = [
   "llm",
   "permissionPresets",
   "sessionPersistence",
-  "sessionQuery"
+  "sessionQuery",
+  "userQuestions"
 ];
 const LODY_CAPABILITIES = {
   compaction: { version: 1 },
@@ -346,10 +512,10 @@ function installModelSelection(agentContext, selection) {
     };
   });
 }
-function planModeService(record) {
-  return record.agent.ctx.get("planMode");
+function planModeService(record2) {
+  return record2.agent.ctx.get("planMode");
 }
-function configOptions(record) {
+function configOptions(record2) {
   const options = [
     {
       id: MODE_CONFIG_ID,
@@ -357,8 +523,8 @@ function configOptions(record) {
       description: "Sandbox and approval policy for the session",
       category: "mode",
       type: "select",
-      currentValue: record.permissionMode,
-      options: record.permissionOptions.map((mode) => ({
+      currentValue: record2.permissionMode,
+      options: record2.permissionOptions.map((mode) => ({
         value: mode.value,
         name: mode.name,
         description: mode.description ?? null
@@ -370,8 +536,8 @@ function configOptions(record) {
       description: "Tools, prompt, and capabilities composed for the session",
       category: "agent_preset",
       type: "select",
-      currentValue: record.agentPreset,
-      options: record.agentPresetOptions.map((preset) => {
+      currentValue: record2.agentPreset,
+      options: record2.agentPresetOptions.map((preset) => {
         const builtIn = DEEPSEEK_HARNESS_AGENT_PRESETS.find((candidate) => candidate.value === preset.id);
         return {
           value: preset.id,
@@ -386,28 +552,28 @@ function configOptions(record) {
       description: "DeepSeek model used for the session",
       category: "model",
       type: "select",
-      currentValue: record.selection.current.model,
-      options: record.models.map((model2) => ({
+      currentValue: record2.selection.current.model,
+      options: record2.models.map((model2) => ({
         value: model2.id,
         name: model2.name,
         description: model2.description ?? null
       }))
     }
   ];
-  const plan = planModeService(record);
+  const plan = planModeService(record2);
   if (plan) {
-    const state = plan.get(record.agent);
+    const state = plan.get(record2.agent);
     options.push(createPlanModeConfigOption(state.pending ?? state.active));
   }
-  const model = record.models.find((candidate) => candidate.id === record.selection.current.model);
-  if (model?.reasoning && record.selection.current.reasoningEffort) {
+  const model = record2.models.find((candidate) => candidate.id === record2.selection.current.model);
+  if (model?.reasoning && record2.selection.current.reasoningEffort) {
     options.push({
       id: REASONING_EFFORT_CONFIG_ID,
       name: "Reasoning effort",
       description: "How much reasoning effort the model should use",
       category: "thought_level",
       type: "select",
-      currentValue: record.selection.current.reasoningEffort,
+      currentValue: record2.selection.current.reasoningEffort,
       options: model.reasoning.efforts.map((effort) => ({
         value: effort.id,
         name: effort.name,
@@ -417,10 +583,10 @@ function configOptions(record) {
   }
   return options;
 }
-function legacyModels(record) {
+function legacyModels(record2) {
   return {
-    currentModelId: record.selection.current.model,
-    availableModels: record.models.flatMap((model) => [
+    currentModelId: record2.selection.current.model,
+    availableModels: record2.models.flatMap((model) => [
       {
         modelId: model.id,
         name: model.name,
@@ -434,10 +600,10 @@ function legacyModels(record) {
     ])
   };
 }
-function modeState(record) {
+function modeState(record2) {
   return {
-    currentModeId: record.permissionMode,
-    availableModes: record.permissionOptions.map((mode) => ({
+    currentModeId: record2.permissionMode,
+    availableModes: record2.permissionOptions.map((mode) => ({
       id: mode.value,
       name: mode.name,
       description: mode.description ?? null
@@ -642,6 +808,7 @@ function apply(ctx, rawConfig) {
   let closed = false;
   let conn;
   let imagePromptEnabled = false;
+  let questionCapabilities = { form: false, answerNotes: false };
   if (ctx.permissionPresets.names.length === 0) {
     throw new Error("acp-extension-dsh: no permission presets are composed");
   }
@@ -658,42 +825,42 @@ function apply(ctx, rawConfig) {
       throw internalError("the ACP bridge has been disposed");
   };
   const requireSession = (sessionId) => {
-    const record = sessions.get(sessionId);
-    if (!record)
+    const record2 = sessions.get(sessionId);
+    if (!record2)
       throw invalidParams(`unknown session: ${sessionId}`);
-    return record;
+    return record2;
   };
   const ownedRecord = (agent) => {
-    const record = sessions.get(agent.session.id);
-    return record?.agent === agent ? record : void 0;
+    const record2 = sessions.get(agent.session.id);
+    return record2?.agent === agent ? record2 : void 0;
   };
   const notify = async (notification) => {
     await conn.sessionUpdate(notification).catch((error) => {
       ctx.logger.warn(`acp-extension-dsh: session/update failed: ${String(error)}`);
     });
   };
-  const enqueueOutput = (record, work, inflight) => {
-    record.outputTail = record.outputTail.then(work).catch((error) => {
-      const failure = error instanceof Error ? error : new Error(String(error));
+  const enqueueOutput = (record2, work, inflight) => {
+    record2.outputTail = record2.outputTail.then(work).catch((error) => {
+      const failure2 = error instanceof Error ? error : new Error(String(error));
       if (inflight)
-        inflight.outputError ??= failure;
+        inflight.outputError ??= failure2;
       ctx.logger.warn(`acp-extension-dsh: assistant output failed: ${errorChain(error)}`);
     });
   };
-  const enqueueNotification = (record, notification, inflight) => enqueueOutput(record, () => notify(notification), inflight);
-  const settleAfterQuiescence = (record, inflight) => {
+  const enqueueNotification = (record2, notification, inflight) => enqueueOutput(record2, () => notify(notification), inflight);
+  const settleAfterQuiescence = (record2, inflight) => {
     if (inflight.settlementStarted)
       return;
     inflight.settlementStarted = true;
     void (async () => {
       await inflight.admissionDone;
       if (inflight.messageQueued) {
-        await record.agent.whenIdle();
-        await record.outputTail;
+        await record2.agent.whenIdle();
+        await record2.outputTail;
       }
-      if (record.inflight !== inflight)
+      if (record2.inflight !== inflight)
         return;
-      record.inflight = void 0;
+      record2.inflight = void 0;
       if (inflight.cancelRequested) {
         inflight.resolve("cancelled");
       } else if (inflight.outputError) {
@@ -707,43 +874,43 @@ function apply(ctx, rawConfig) {
         inflight.resolve(end ? end.kind === "interrupted" ? "cancelled" : "end_turn" : "cancelled");
       }
     })().catch((error) => {
-      if (record.inflight !== inflight)
+      if (record2.inflight !== inflight)
         return;
-      record.inflight = void 0;
+      record2.inflight = void 0;
       inflight.reject(internalError(`prompt settlement failed: ${errorChain(error)}`));
     });
   };
-  const refreshPermissionState = (record) => {
-    const permissionMode = ctx.permissionPresets.current(record.agent.session);
-    if (permissionMode === record.permissionMode)
+  const refreshPermissionState = (record2) => {
+    const permissionMode = ctx.permissionPresets.current(record2.agent.session);
+    if (permissionMode === record2.permissionMode)
       return false;
-    record.permissionMode = permissionMode;
-    record.permissionOptions = permissionState(ctx, permissionMode);
+    record2.permissionMode = permissionMode;
+    record2.permissionOptions = permissionState(ctx, permissionMode);
     return true;
   };
-  const schedulePermissionSync = (record) => {
-    if (record.permissionSyncQueued)
+  const schedulePermissionSync = (record2) => {
+    if (record2.permissionSyncQueued)
       return;
-    record.permissionSyncQueued = true;
+    record2.permissionSyncQueued = true;
     queueMicrotask(() => {
-      record.permissionSyncQueued = false;
-      if (sessions.get(record.agent.session.id) !== record)
+      record2.permissionSyncQueued = false;
+      if (sessions.get(record2.agent.session.id) !== record2)
         return;
       try {
-        if (!refreshPermissionState(record))
+        if (!refreshPermissionState(record2))
           return;
-        enqueueNotification(record, {
-          sessionId: record.agent.session.id,
+        enqueueNotification(record2, {
+          sessionId: record2.agent.session.id,
           update: {
             sessionUpdate: "current_mode_update",
-            currentModeId: record.permissionMode
+            currentModeId: record2.permissionMode
           }
         });
-        enqueueNotification(record, {
-          sessionId: record.agent.session.id,
+        enqueueNotification(record2, {
+          sessionId: record2.agent.session.id,
           update: {
             sessionUpdate: "config_option_update",
-            configOptions: configOptions(record)
+            configOptions: configOptions(record2)
           }
         });
       } catch (error) {
@@ -752,43 +919,43 @@ function apply(ctx, rawConfig) {
     });
   };
   const disposeRecords = async (records) => {
-    await Promise.all(records.map(async (record) => {
-      await record.inflight?.admissionDone;
-      await record.agent.whenIdle();
-      await record.outputTail;
+    await Promise.all(records.map(async (record2) => {
+      await record2.inflight?.admissionDone;
+      await record2.agent.whenIdle();
+      await record2.outputTail;
     }));
     const subagents = ctx.get("subagents");
     if (subagents) {
       try {
-        await subagents.drainContinuableDescendants(records.map((record) => record.agent));
+        await subagents.drainContinuableDescendants(records.map((record2) => record2.agent));
       } catch (error) {
         ctx.logger.warn(`acp-extension-dsh: continuable subagent teardown failed: ${String(error)}`);
       }
     }
-    const results = await Promise.allSettled(records.map((record) => record.dispose()));
+    const results = await Promise.allSettled(records.map((record2) => record2.dispose()));
     const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
     if (failures.length > 0) {
       throw new AggregateError(failures, `DeepSeek ACP teardown failed for ${failures.length} session(s): ${failures.map(errorChain).join("; ")}`);
     }
   };
   ctx.on("agent/assistant-stream", ({ agent, frame }) => {
-    const record = ownedRecord(agent);
-    if (!record || frame.type !== "chunk")
+    const record2 = ownedRecord(agent);
+    if (!record2 || frame.type !== "chunk")
       return;
     const chunk = frame.chunk;
     if (!chunk)
       return;
     if (chunk.type === "reasoning-delta" && typeof chunk.text === "string" && chunk.text.length > 0) {
-      enqueueNotification(record, {
-        sessionId: record.agent.session.id,
+      enqueueNotification(record2, {
+        sessionId: record2.agent.session.id,
         update: {
           sessionUpdate: "agent_thought_chunk",
           content: { type: "text", text: chunk.text }
         }
       });
     } else if (chunk.type === "block-end" && chunk.block?.type === "reasoning") {
-      enqueueNotification(record, {
-        sessionId: record.agent.session.id,
+      enqueueNotification(record2, {
+        sessionId: record2.agent.session.id,
         update: {
           sessionUpdate: "agent_thought_chunk",
           content: { type: "text", text: "\n\n" }
@@ -797,35 +964,38 @@ function apply(ctx, rawConfig) {
     }
   });
   ctx.on("session/event", (session, event) => {
-    const record = sessions.get(session.header.id);
-    if (!record || record.agent.session !== session)
+    const record2 = sessions.get(session.header.id);
+    if (!record2 || record2.agent.session !== session)
       return;
     if (event.type === "plan/mode") {
-      enqueueNotification(record, {
-        sessionId: record.agent.session.id,
-        update: { sessionUpdate: "config_option_update", configOptions: configOptions(record) }
+      enqueueNotification(record2, {
+        sessionId: record2.agent.session.id,
+        update: {
+          sessionUpdate: "config_option_update",
+          configOptions: configOptions(record2)
+        }
       });
     }
     if (PERMISSION_EVENT_TYPES.has(event.type))
-      schedulePermissionSync(record);
+      schedulePermissionSync(record2);
     try {
       if (event.type === "request/context" && event.data.provider && event.data.model) {
-        record.usage.setRoute(event.data.provider, event.data.model);
+        record2.usage.setRoute(event.data.provider, event.data.model);
       }
       if (event.type === "assistant/message" && event.data.usage && event.seq !== void 0) {
-        const update = record.usage.record(session.id, event.seq, event.time ?? NaN, event.data.usage);
+        const update = record2.usage.record(session.id, event.seq, event.time ?? NaN, event.data.usage);
         if (update)
-          enqueueOutput(record, () => conn.extNotification(LODY_EXTENSION_METHODS.sessionUsageUpdate, update), record.inflight);
+          enqueueOutput(record2, () => conn.extNotification(LODY_EXTENSION_METHODS.sessionUsageUpdate, update), record2.inflight);
       }
       if (event.type === "assistant/message") {
-        const inflight = record.inflight?.turn === event.data.turn ? record.inflight : void 0;
-        enqueueOutput(record, async () => {
+        const inflight = record2.inflight?.turn === event.data.turn ? record2.inflight : void 0;
+        enqueueOutput(record2, async () => {
           for (const block of event.data.message?.content ?? []) {
             const content = await assistantBlockToAcp(block, attachments);
             if (!content)
               continue;
             await notify({
-              sessionId: record.agent.session.id,
+              sessionId: record2.agent.session.id,
               update: { sessionUpdate: "agent_message_chunk", content }
             });
           }
@@ -836,8 +1006,8 @@ function apply(ctx, rawConfig) {
           kind: "context_compaction",
           automatic: event.data.turn !== null
         };
-        enqueueNotification(record, {
-          sessionId: record.agent.session.id,
+        enqueueNotification(record2, {
+          sessionId: record2.agent.session.id,
           update: {
             sessionUpdate: "tool_call",
             toolCallId: `context-compaction:${event.data.compactionId}`,
@@ -854,8 +1024,8 @@ function apply(ctx, rawConfig) {
           automatic: event.data.turn !== null,
           ...event.data.error ? { failureReason: event.data.error } : {}
         };
-        enqueueNotification(record, {
-          sessionId: record.agent.session.id,
+        enqueueNotification(record2, {
+          sessionId: record2.agent.session.id,
           update: {
             sessionUpdate: "tool_call_update",
             toolCallId: `context-compaction:${event.data.compactionId}`,
@@ -866,7 +1036,7 @@ function apply(ctx, rawConfig) {
         });
       }
     } finally {
-      const inflight = record.inflight;
+      const inflight = record2.inflight;
       if (inflight && event.type === "turn/end" && inflight.turn === event.data.turn && event.data.reason) {
         inflight.endReason = event.data.reason;
       }
@@ -878,19 +1048,19 @@ function apply(ctx, rawConfig) {
       inflight.turn = turn;
   });
   ctx.on("agent/error", ({ agent, turn, error }) => {
-    const record = ownedRecord(agent);
-    const inflight = record?.inflight;
-    if (!record || !inflight || !inflight.messageQueued || inflight.turn !== turn)
+    const record2 = ownedRecord(agent);
+    const inflight = record2?.inflight;
+    if (!record2 || !inflight || !inflight.messageQueued || inflight.turn !== turn)
       return;
     inflight.agentError = new Error(errorChain(error));
-    settleAfterQuiescence(record, inflight);
+    settleAfterQuiescence(record2, inflight);
   });
   ctx.on("approval/request", (request, next) => {
-    const record = ownedRecord(request.agent);
-    if (!record || !request.callId)
+    const record2 = ownedRecord(request.agent);
+    if (!record2 || !request.callId)
       return next();
     return conn.requestPermission({
-      sessionId: record.agent.session.id,
+      sessionId: record2.agent.session.id,
       toolCall: { toolCallId: request.callId },
       options: [
         { optionId: "allow-once", name: "Allow once", kind: "allow_once" },
@@ -902,91 +1072,100 @@ function apply(ctx, rawConfig) {
       return outcome.optionId === "allow-once" ? "allowed-once" : "rejected";
     });
   });
-  const setPermissionMode = (record, modeId) => {
-    if (modeId === record.permissionMode)
+  const setPermissionMode = (record2, modeId) => {
+    if (modeId === record2.permissionMode)
       return;
     assertAllowed(modeId, new Set(ctx.permissionPresets.names), "permission mode");
-    ctx.permissionPresets.set(record.agent.session, modeId);
-    const permissionMode = ctx.permissionPresets.current(record.agent.session);
+    ctx.permissionPresets.set(record2.agent.session, modeId);
+    const permissionMode = ctx.permissionPresets.current(record2.agent.session);
     if (permissionMode !== modeId) {
       throw internalError(`permission preset ${JSON.stringify(modeId)} did not become the effective mode`);
     }
-    record.permissionMode = permissionMode;
-    record.permissionOptions = permissionState(ctx, permissionMode);
+    record2.permissionMode = permissionMode;
+    record2.permissionOptions = permissionState(ctx, permissionMode);
   };
-  const setConfigOption = (record, params) => {
+  const setConfigOption = (record2, params) => {
     if (params.configId === LODY_PLAN_MODE_CONFIG_ID) {
-      const plan = planModeService(record);
+      const plan = planModeService(record2);
       if (!plan || typeof params.value !== "boolean") {
         throw invalidParams("Plan mode requires a supported Agent preset and a boolean value");
       }
-      plan.set(record.agent, params.value);
-      return { configOptions: configOptions(record) };
+      plan.set(record2.agent, params.value);
+      return { configOptions: configOptions(record2) };
     }
     const value = requireSelectValue(params);
     if (params.configId === MODE_CONFIG_ID) {
-      setPermissionMode(record, value);
+      setPermissionMode(record2, value);
     } else if (params.configId === AGENT_PRESET_CONFIG_ID) {
-      const available = new Set(record.agentPresetOptions.map((preset) => preset.id));
+      const available = new Set(record2.agentPresetOptions.map((preset) => preset.id));
       assertAllowed(value, available, "agent preset");
-      if (value === record.agentPreset)
-        return { configOptions: configOptions(record) };
-      if (record.started) {
+      if (value === record2.agentPreset)
+        return { configOptions: configOptions(record2) };
+      if (record2.started) {
         throw invalidParams("agent preset is fixed after the session has started");
       }
-      return ctx.agentPresets.select(record.agent, value).then((selectedPreset) => {
-        record.agentPreset = selectedPreset;
-        return { configOptions: configOptions(record) };
+      return ctx.agentPresets.select(record2.agent, value).then((selectedPreset) => {
+        record2.agentPreset = selectedPreset;
+        return { configOptions: configOptions(record2) };
       }).catch((error) => {
         if (error instanceof RequestError)
           throw error;
         throw invalidParams(`failed to select agent preset ${JSON.stringify(value)}: ${errorChain(error)}`);
       });
     } else if (params.configId === MODEL_CONFIG_ID) {
-      return resolveHarnessModel(llm, record.selection.current.provider, value).then((model) => {
-        const index = record.models.findIndex((candidate) => candidate.id === value);
+      return resolveHarnessModel(llm, record2.selection.current.provider, value).then((model) => {
+        const index = record2.models.findIndex((candidate) => candidate.id === value);
         if (index === -1)
-          record.models.push(model);
+          record2.models.push(model);
         else
-          record.models[index] = model;
-        const reasoningEffort = resolveReasoningEffort(model, record.selection.current.reasoningEffort && model.reasoning?.efforts.some((effort) => effort.id === record.selection.current.reasoningEffort) ? record.selection.current.reasoningEffort : void 0);
-        record.selection.current = {
-          provider: record.selection.current.provider,
+          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,
           ...reasoningEffort ? { reasoningEffort } : {}
         };
-        return { configOptions: configOptions(record) };
+        return { configOptions: configOptions(record2) };
       }).catch((error) => {
         if (error instanceof RequestError)
           throw error;
         throw invalidParams(`failed to resolve model ${JSON.stringify(value)}: ${errorChain(error)}`);
       });
     } else if (params.configId === REASONING_EFFORT_CONFIG_ID) {
-      const model = record.models.find((candidate) => candidate.id === record.selection.current.model);
+      const model = record2.models.find((candidate) => candidate.id === record2.selection.current.model);
       if (!model)
         throw internalError("selected model metadata is unavailable");
       const reasoningEffort = resolveReasoningEffort(model, value);
       if (!reasoningEffort) {
         throw invalidParams(`model ${JSON.stringify(model.id)} has no reasoning selector`);
       }
-      record.selection.current = {
-        ...record.selection.current,
+      record2.selection.current = {
+        ...record2.selection.current,
         reasoningEffort
       };
     } else {
       throw invalidParams(`unknown config option: ${params.configId}`);
     }
-    return { configOptions: configOptions(record) };
+    return { configOptions: configOptions(record2) };
   };
   const makeAgent = (connection) => {
     conn = connection;
     return {
       async initialize(_params) {
+        const elicitation = _params.clientCapabilities?._meta?.lody;
+        const notes = elicitation && typeof elicitation === "object" && !Array.isArray(elicitation) && "elicitation" in elicitation ? elicitation.elicitation : void 0;
+        questionCapabilities = {
+          form: _params.clientCapabilities?.elicitation?.form != null,
+          answerNotes: !!notes && typeof notes === "object" && !Array.isArray(notes) && "version" in notes && notes.version === 1 && "answerNotes" in notes && notes.answerNotes === true
+        };
         const { models } = await loadModelCatalog();
         imagePromptEnabled = supportsAcpImagePrompts(attachments, models);
         return {
           protocolVersion: PROTOCOL_VERSION,
-          agentInfo: { name: "acp-extension-dsh", version: ACP_EXTENSION_DSH_VERSION },
+          agentInfo: {
+            name: "acp-extension-dsh",
+            version: ACP_EXTENSION_DSH_VERSION
+          },
           agentCapabilities: {
             promptCapabilities: {
               image: imagePromptEnabled,
@@ -1014,6 +1193,7 @@ function apply(ctx, rawConfig) {
         }
         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");
@@ -1026,13 +1206,9 @@ function apply(ctx, rawConfig) {
           }
         };
         const agentPresetOptions = (await ctx.agentPresets.list()).filter((preset) => preset.broken === void 0);
-        let requestedPreset = ctx.agentPresets.defaultId;
+        const requestedPreset = ctx.agentPresets.defaultId;
         if (!agentPresetOptions.some((preset) => preset.id === requestedPreset)) {
-          if (!agentPresetOptions.some((preset) => preset.id === "standard")) {
-            throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} and recovery preset "standard" are unavailable; restore the bundled standard preset or choose an available agent-presets.default in $DSH_HOME/settings.yaml`);
-          }
-          ctx.logger.warn(`acp-extension-dsh: default agent preset ${JSON.stringify(requestedPreset)} is unavailable; using "standard" for this session without changing settings`);
-          requestedPreset = "standard";
+          throw internalError(`default agent preset ${JSON.stringify(requestedPreset)} is unavailable`);
         }
         const mcpServerNames = reserveMcpServerNames(params.mcpServers, sessionId, activeMcpServerNames);
         let mountedPreset = requestedPreset;
@@ -1044,6 +1220,11 @@ function apply(ctx, rawConfig) {
             agentOptions: { provider: config.provider, model: initialModelId },
             setup: async (agentContext) => {
               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);
             }
@@ -1055,6 +1236,7 @@ function apply(ctx, rawConfig) {
           throw internalError(`failed to create session: ${errorChain(error)}`);
         }
         const dispose = async () => {
+          questions.cancel();
           try {
             await handle.dispose();
           } finally {
@@ -1074,7 +1256,8 @@ function apply(ctx, rawConfig) {
           await dispose();
           throw error;
         }
-        const record = {
+        const record2 = {
+          questions,
           usage: new HarnessUsageTracker(!baseUrl || /^https:\/\/api\.deepseek\.com(?:\/v1)?\/?$/.test(baseUrl)),
           agent: handle.agent,
           dispose,
@@ -1087,27 +1270,27 @@ function apply(ctx, rawConfig) {
           started: false,
           outputTail: Promise.resolve()
         };
-        sessions.set(sessionId, record);
+        sessions.set(sessionId, record2);
         return {
           sessionId,
-          modes: modeState(record),
-          configOptions: configOptions(record),
-          models: legacyModels(record)
+          modes: modeState(record2),
+          configOptions: configOptions(record2),
+          models: legacyModels(record2)
         };
       },
       setSessionMode(params) {
-        const record = requireSession(params.sessionId);
-        setPermissionMode(record, params.modeId);
+        const record2 = requireSession(params.sessionId);
+        setPermissionMode(record2, params.modeId);
       },
       setSessionConfigOption(params) {
         return setConfigOption(requireSession(params.sessionId), params);
       },
       async prompt(params) {
         assertOpen();
-        const record = requireSession(params.sessionId);
-        if (record.inflight)
+        const record2 = requireSession(params.sessionId);
+        if (record2.inflight)
           throw invalidParams("a prompt is already in flight for this session");
-        if (ctx.agents.get(record.agent.id) !== record.agent) {
+        if (ctx.agents.get(record2.agent.id) !== record2.agent) {
           throw internalError("prompt was not queued: the agent was disposed outside the bridge");
         }
         const messageId = randomUUID();
@@ -1131,24 +1314,24 @@ function apply(ctx, rawConfig) {
           cancelRequested: false,
           settlementStarted: false
         };
-        record.inflight = inflight;
+        record2.inflight = inflight;
         let admissionError;
         try {
-          const content = await admitAcpPrompt(params.prompt, llm, record.selection.current, attachments, imagePromptEnabled, admissionController.signal);
+          const content = await admitAcpPrompt(params.prompt, llm, record2.selection.current, attachments, imagePromptEnabled, admissionController.signal);
           if (!inflight.cancelRequested) {
-            if (ctx.agents.get(record.agent.id) !== record.agent) {
+            if (ctx.agents.get(record2.agent.id) !== record2.agent) {
               throw internalError("prompt was not queued: the agent was disposed outside the bridge");
             }
             const message = createUserMessage(messageId, content);
             inflight.messageId = messageId;
             inflight.messageQueued = true;
-            const wasStarted = record.started;
+            const wasStarted = record2.started;
             try {
-              record.agent.followup(message);
-              record.started = true;
+              record2.agent.followup(message);
+              record2.started = true;
             } catch (error) {
               inflight.messageQueued = false;
-              record.started = wasStarted;
+              record2.started = wasStarted;
               throw new Error(`prompt was not queued: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
             }
           }
@@ -1158,45 +1341,47 @@ function apply(ctx, rawConfig) {
           finishAdmission();
         }
         if (inflight.cancelRequested) {
-          settleAfterQuiescence(record, inflight);
+          settleAfterQuiescence(record2, inflight);
           return { stopReason: await completion };
         }
         if (admissionError) {
-          if (record.inflight === inflight)
-            record.inflight = void 0;
+          if (record2.inflight === inflight)
+            record2.inflight = void 0;
           if (admissionError instanceof RequestError)
             throw admissionError;
           throw internalError(errorChain(admissionError));
         }
-        settleAfterQuiescence(record, inflight);
+        settleAfterQuiescence(record2, inflight);
         return { stopReason: await completion };
       },
       cancel(params) {
-        const record = sessions.get(params.sessionId);
-        if (!record)
+        const record2 = sessions.get(params.sessionId);
+        if (!record2)
           return Promise.resolve();
-        const inflight = record.inflight;
+        record2.questions.cancel();
+        const inflight = record2.inflight;
         if (inflight) {
           inflight.cancelRequested = true;
           inflight.admissionController.abort(new Error("ACP prompt cancelled"));
-          settleAfterQuiescence(record, inflight);
+          settleAfterQuiescence(record2, inflight);
         }
         if (!inflight || inflight.messageQueued)
-          record.agent.cancel({ kind: "user" });
+          record2.agent.cancel({ kind: "user" });
         return Promise.resolve();
       },
       async closeSession(params) {
-        const record = requireSession(params.sessionId);
+        const record2 = requireSession(params.sessionId);
+        record2.questions.cancel();
         sessions.delete(params.sessionId);
-        const inflight = record.inflight;
+        const inflight = record2.inflight;
         if (inflight) {
           inflight.cancelRequested = true;
           inflight.admissionController.abort(new Error("ACP session closed"));
-          settleAfterQuiescence(record, inflight);
+          settleAfterQuiescence(record2, inflight);
         }
         if (!inflight || inflight.messageQueued)
-          record.agent.cancel({ kind: "user" });
-        await disposeRecords([record]);
+          record2.agent.cancel({ kind: "user" });
+        await disposeRecords([record2]);
       }
     };
   };
@@ -1209,15 +1394,16 @@ function apply(ctx, rawConfig) {
     closed = true;
     const records = [...sessions.values()];
     sessions.clear();
-    for (const record of records) {
-      const inflight = record.inflight;
+    for (const record2 of records) {
+      record2.questions.cancel();
+      const inflight = record2.inflight;
       if (inflight) {
         inflight.cancelRequested = true;
         inflight.admissionController.abort(new Error("ACP bridge disposed"));
-        settleAfterQuiescence(record, inflight);
+        settleAfterQuiescence(record2, inflight);
       }
       if (!inflight || inflight.messageQueued)
-        record.agent.cancel({ kind: "user" });
+        record2.agent.cancel({ kind: "user" });
     }
     quiescing = (async () => {
       await disposeRecords(records);