dsh-dispatch 0.1.0 → 0.3.0

package/dist/index.js

@@ -262,7 +262,7 @@ function installCommands(hub, deps) {
     handler: () => ({ kind: "success", text: statusText(hub, deps) })
   }), "dsh-dispatch: /dispatch-status");
 }
-function pairingResult(hub, prefix = "") {
+function pairingResult(hub, prefix2 = "") {
   if (hub.config.relay === "") {
     return {
       kind: "error",
@@ -272,7 +272,7 @@ function pairingResult(hub, prefix = "") {
   const code = hub.pairing.pairingCode(hub.config.relay, hub.config.machineName);
   return {
     kind: "success",
-    text: `${prefix}\u914D\u5BF9\u7801\uFF08${hub.config.machineName}\uFF09\uFF1A
+    text: `${prefix2}\u914D\u5BF9\u7801\uFF08${hub.config.machineName}\uFF09\uFF1A
 ${code}
 
 \u6216\u5728\u624B\u673A\u4E0A\u6253\u5F00\uFF1A
@@ -289,7 +289,9 @@ function statusText(hub, deps) {
     `\u623F\u95F4:       ${status.room.slice(0, 8)}\u2026`,
     `\u5DF2\u914D\u5BF9:     ${hub.pairing.everPaired ? "yes" : "no"}${status.phoneOnline ? "\uFF08\u624B\u673A\u5728\u7EBF\uFF09" : "\uFF08\u624B\u673A\u79BB\u7EBF\uFF09"}`,
     `\u5F85\u6279\u5BA1\u6279:   ${String(deps.approvals.openCount())}`,
+    `\u5F85\u7B54\u63D0\u95EE:   ${String(deps.questions.openCount())}`,
     `\u6D3E\u53D1\u4F1A\u8BDD:   ${String(deps.dispatch.dispatchedCount())}`,
+    `full-access \u6D3E\u53D1: ${hub.config.allowFullAccessDispatch ? "\u5DF2\u5F00\u542F \u26A0\uFE0F" : "\u5DF2\u7981\u7528"}`,
     `\u89E3\u5BC6\u5931\u8D25:   ${String(status.decryptFailures)}${status.decryptFailures > 0 ? " \u2014 \u5BC6\u94A5\u4E0D\u5339\u914D\uFF0C\u8BF7\u91CD\u65B0\u914D\u5BF9" : ""}`,
     `allowedRoots: ${hub.config.allowedRoots.length === 0 ? "(\u7A7A \u2014 \u8FDC\u7A0B\u6D3E\u4EFB\u52A1\u5DF2\u7981\u7528)" : hub.config.allowedRoots.join(", ")}`
   ].join("\n");
@@ -411,7 +413,8 @@ async function prepareWorkspace(options) {
   if (!await isGitRepo(options.cwd)) {
     return {
       cwd: options.cwd,
-      note: `\u5DF2\u964D\u7EA7\uFF1A${options.cwd} \u4E0D\u662F git \u4ED3\u5E93\uFF0C\u4EFB\u52A1\u76F4\u63A5\u5728\u8BE5\u76EE\u5F55\u8FD0\u884C\uFF08\u672A\u521B\u5EFA worktree\uFF09`
+      note: `\u5DF2\u964D\u7EA7\uFF1A${options.cwd} \u4E0D\u662F git \u4ED3\u5E93\uFF0C\u4EFB\u52A1\u76F4\u63A5\u5728\u8BE5\u76EE\u5F55\u8FD0\u884C\uFF08\u672A\u521B\u5EFA worktree\uFF09`,
+      noteReason: { code: "not-a-git-repo", params: { cwd: options.cwd } }
     };
   }
   const root = join2(options.dataDir, "worktrees");
@@ -454,8 +457,23 @@ function stderrOf(error) {
 
 // src/dispatch.ts
 var SEEN_LIMIT = 256;
-var DISPATCH_DISABLED = "dispatch \u672A\u542F\u7528\uFF1A\u8BF7\u5728\u63D2\u4EF6\u914D\u7F6E\u4E2D\u8BBE\u7F6E allowedRoots";
-var NO_REMOTE_FOLLOWUP = "\u8BE5\u4F1A\u8BDD\u4E0D\u652F\u6301\u8FDC\u7A0B\u8FFD\u52A0";
+function complain(text, code, params) {
+  return { text, reason: params === void 0 ? { code } : { code, params } };
+}
+var DISPATCH_DISABLED = complain(
+  "dispatch \u672A\u542F\u7528\uFF1A\u8BF7\u5728\u63D2\u4EF6\u914D\u7F6E\u4E2D\u8BBE\u7F6E allowedRoots",
+  "dispatch-disabled"
+);
+var NO_REMOTE_FOLLOWUP = complain("\u8BE5\u4F1A\u8BDD\u4E0D\u652F\u6301\u8FDC\u7A0B\u8FFD\u52A0", "no-remote-followup");
+var FULL_ACCESS_DISABLED = complain(
+  "full-access \u6D3E\u53D1\u672A\u542F\u7528\uFF1A\u8BF7\u5728\u63D2\u4EF6\u914D\u7F6E\u4E2D\u5F00\u542F allowFullAccessDispatch",
+  "full-access-disabled"
+);
+var FULL_ACCESS_UNAVAILABLE = complain(
+  "full-access \u4E0D\u53EF\u7528\uFF1A\u672C\u673A dsh \u672A\u7EC4\u5408 permission-presets \u63D2\u4EF6",
+  "full-access-unavailable"
+);
+var FULL_ACCESS_PRESET = "danger-full-access";
 function installDispatch(hub) {
   const state = {
     handles: /* @__PURE__ */ new Map(),
@@ -480,6 +498,11 @@ function installDispatch(hub) {
   };
 }
 async function handleRequest(hub, state, message) {
+  const rejected = validate(hub, message);
+  if (rejected !== void 0) {
+    hub.relay.send(failure(message.requestId, rejected));
+    return;
+  }
   const replay = state.seen.get(message.requestId);
   if (replay !== void 0) {
     if (replay !== null) hub.relay.send(replay);
@@ -497,10 +520,9 @@ async function handleRequest(hub, state, message) {
 }
 async function startSession(hub, state, message) {
   const prompt = message.prompt;
-  const oversized = overLimit("prompt", prompt);
-  if (oversized !== void 0) return failure(message.requestId, oversized);
   const target = resolveCwd(hub, message.cwd);
   if (typeof target !== "string") return failure(message.requestId, target.error);
+  const full = message.access === "full";
   try {
     const workspace = await prepareWorkspace({
       cwd: target,
@@ -509,28 +531,48 @@ async function startSession(hub, state, message) {
     });
     state.loaderReady ??= Promise.resolve(hub.ctx.get("loader")?.await()).then(() => void 0);
     await state.loaderReady;
-    const handle = await createSession(hub.ctx, workspace.cwd, prompt);
-    state.handles.set(handle.agent.id, handle);
-    hub.sessions.markDispatched(handle.agent.id, prompt);
-    const result = ok(message.requestId, handle.agent.id);
-    return workspace.note === void 0 ? result : { ...result, note: workspace.note };
+    const created = await createSession(hub.ctx, workspace.cwd, prompt, full);
+    state.handles.set(created.handle.agent.id, created.handle);
+    hub.sessions.markDispatched(created.handle.agent.id, prompt, full ? "full" : "standard");
+    if (created.fullAccessError !== void 0) {
+      hub.report(`dispatch ${message.requestId}`, `\u5B8C\u5168\u8BBF\u95EE\u6743\u9650\u672A\u80FD\u5E94\u7528\uFF1A${created.fullAccessError}`);
+    }
+    const result = ok(message.requestId, created.handle.agent.id);
+    const advisory = created.fullAccessError === void 0 ? workspace.note === void 0 ? void 0 : { text: workspace.note, reason: workspace.noteReason ?? { code: "not-a-git-repo" } } : complain(
+      `\u5B8C\u5168\u8BBF\u95EE\u6743\u9650\u672A\u80FD\u5E94\u7528\uFF0C\u5DF2\u5728\u6807\u51C6\u6743\u9650\u4E0B\u8FD0\u884C\uFF1A${created.fullAccessError}`,
+      "full-access-not-applied",
+      { detail: created.fullAccessError }
+    );
+    return advisory === void 0 ? result : { ...result, note: advisory.text, reason: advisory.reason };
   } catch (error) {
     const detail = error instanceof WorktreeError ? error.message : String(error);
     hub.log.error("dispatch %s failed: %s", message.requestId, detail);
-    return failure(message.requestId, detail);
+    return failure(message.requestId, complain(
+      detail,
+      error instanceof WorktreeError ? "worktree-failed" : "dispatch-failed",
+      { detail }
+    ));
   }
 }
 async function handleFollowup(hub, state, message) {
-  const oversized = overLimit("\u6D88\u606F", message.text);
+  const oversized = overLimit("message", message.text);
   if (oversized !== void 0) {
-    hub.report(`session.message ${message.sessionId}`, oversized);
+    hub.report(
+      `session.message ${message.sessionId}`,
+      oversized.text,
+      { sessionId: message.sessionId, reason: oversized.reason }
+    );
     return;
   }
   if (state.seen.get(message.requestId) !== void 0) return;
   state.seen.set(message.requestId, null);
   const agent = state.handles.get(message.sessionId)?.agent ?? hub.sessions.agentOf(message.sessionId);
   if (agent === void 0) {
-    hub.report(`session.message ${message.sessionId}`, NO_REMOTE_FOLLOWUP);
+    hub.report(
+      `session.message ${message.sessionId}`,
+      NO_REMOTE_FOLLOWUP.text,
+      { sessionId: message.sessionId, reason: NO_REMOTE_FOLLOWUP.reason }
+    );
     return;
   }
   agent.followup(createUserMessage({
@@ -539,13 +581,22 @@ async function handleFollowup(hub, state, message) {
   }));
 }
 function overLimit(field, text) {
+  const label = field === "prompt" ? "\u63D0\u793A\u8BCD" : "\u6D88\u606F";
   const tail = "\u8BF7\u5728\u624B\u673A\u7AEF\u7F29\u77ED\u540E\u91CD\u53D1\u3002";
   if (text.length > MAX_PROMPT_CHARS) {
-    return `${field} \u8D85\u957F\uFF1A${String(text.length)} \u5B57\u7B26\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_CHARS)} \u5B57\u7B26\u3002${tail}`;
+    return complain(
+      `${label} \u8D85\u957F\uFF1A${String(text.length)} \u5B57\u7B26\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_CHARS)} \u5B57\u7B26\u3002${tail}`,
+      `${field}-too-long-chars`,
+      { actual: text.length, limit: MAX_PROMPT_CHARS }
+    );
   }
   const bytes = utf8Length(text);
   if (bytes > MAX_PROMPT_BYTES) {
-    return `${field} \u8D85\u957F\uFF1A${String(bytes)} \u5B57\u8282\uFF08UTF-8\uFF09\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_BYTES)} \u5B57\u8282\u3002${tail}`;
+    return complain(
+      `${label} \u8D85\u957F\uFF1A${String(bytes)} \u5B57\u8282\uFF08UTF-8\uFF09\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_BYTES)} \u5B57\u8282\u3002${tail}`,
+      `${field}-too-long-bytes`,
+      { actual: bytes, limit: MAX_PROMPT_BYTES }
+    );
   }
   return void 0;
 }
@@ -570,7 +621,22 @@ async function composeAgent(ctx, selection) {
     }
   };
 }
-async function createSession(ctx, cwd, prompt) {
+function validate(hub, message) {
+  const oversized = overLimit("prompt", message.prompt);
+  if (oversized !== void 0) return oversized;
+  if (message.access !== void 0 && message.access !== "standard" && message.access !== "full") {
+    return complain(
+      `access \u53D6\u503C\u65E0\u6548\uFF1A${String(message.access)}`,
+      "bad-access-value",
+      { value: String(message.access) }
+    );
+  }
+  if (message.access !== "full") return void 0;
+  if (!hub.config.allowFullAccessDispatch) return FULL_ACCESS_DISABLED;
+  if (hub.ctx.get("permissionPresets") === void 0) return FULL_ACCESS_UNAVAILABLE;
+  return void 0;
+}
+async function createSession(ctx, cwd, prompt, fullAccess) {
   const selection = ctx.get("agentDefaultModel")?.currentSelection();
   const composition = await composeAgent(ctx, selection);
   const handle = await ctx.agents.create({
@@ -582,30 +648,54 @@ async function createSession(ctx, cwd, prompt) {
     setup: composition.setup
   });
   await handle.agent.whenIdle();
+  const fullAccessError = fullAccess ? applyFullAccess(ctx, handle) : void 0;
   handle.agent.followup(createUserMessage({
     content: [{ type: "text", text: prompt }],
     source: { kind: "user" }
   }));
-  return handle;
+  return fullAccessError === void 0 ? { handle } : { handle, fullAccessError };
+}
+function applyFullAccess(ctx, handle) {
+  try {
+    const presets = ctx.get("permissionPresets");
+    if (presets === void 0) return "permission-presets \u63D2\u4EF6\u672A\u7EC4\u5408";
+    presets.set(handle.agent.session, FULL_ACCESS_PRESET);
+    return void 0;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function resolvedRoots(hub) {
+  return hub.config.allowedRoots.map((root) => resolve2(expandHome(root)));
 }
 function resolveCwd(hub, requested) {
-  const roots = hub.config.allowedRoots.map((root) => resolve2(expandHome(root)));
+  const roots = resolvedRoots(hub);
   if (roots.length === 0) return { error: DISPATCH_DISABLED };
   const first = roots[0];
   if (requested === void 0) return first === void 0 ? { error: DISPATCH_DISABLED } : first;
   const target = resolve2(isAbsolute(requested) ? requested : expandHome(requested));
   const inside = roots.some((root) => target === root || target.startsWith(root + sep));
-  return inside ? target : { error: `cwd \u4E0D\u5728\u5141\u8BB8\u76EE\u5F55\u5185\uFF1A${target}` };
+  return inside ? target : { error: complain(`cwd \u4E0D\u5728\u5141\u8BB8\u76EE\u5F55\u5185\uFF1A${target}`, "cwd-not-allowed", { cwd: target }) };
 }
 async function reportTurnFinal(hub, sessionId) {
   const snapshot = await hub.ctx.sessionQuery.readSurface(SessionId(sessionId));
   const ok2 = !hub.sessions.hasError(sessionId);
+  const text = lastAssistantText(snapshot.events);
+  const placeholder = text === void 0 ? complain("\uFF08\u672C\u8F6E\u6CA1\u6709\u4EA7\u751F\u52A9\u624B\u6587\u672C\uFF09", "no-assistant-text") : void 0;
   const summary = clampBytes(
-    truncate(lastAssistantText(snapshot.events), MAX_SUMMARY_CHARS),
+    truncate(text ?? placeholder.text, MAX_SUMMARY_CHARS),
     MAX_FIELD_BYTES
   );
   hub.relay.send(
-    { v: 1, ts: Date.now(), type: "turn.final", sessionId, ok: ok2, summary },
+    {
+      v: 1,
+      ts: Date.now(),
+      type: "turn.final",
+      sessionId,
+      ok: ok2,
+      summary,
+      ...placeholder === void 0 ? {} : { reason: placeholder.reason }
+    },
     {
       v: 1,
       ts: Date.now(),
@@ -623,13 +713,21 @@ function lastAssistantText(events) {
     const text = event.data.message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
     if (text !== "") return text;
   }
-  return "\uFF08\u672C\u8F6E\u6CA1\u6709\u4EA7\u751F\u52A9\u624B\u6587\u672C\uFF09";
+  return void 0;
 }
 function ok(requestId, sessionId) {
   return { v: 1, ts: Date.now(), type: "dispatch.result", requestId, ok: true, sessionId };
 }
-function failure(requestId, error) {
-  return { v: 1, ts: Date.now(), type: "dispatch.result", requestId, ok: false, error };
+function failure(requestId, complaint) {
+  return {
+    v: 1,
+    ts: Date.now(),
+    type: "dispatch.result",
+    requestId,
+    ok: false,
+    error: complaint.text,
+    reason: complaint.reason
+  };
 }
 var ResultCache = class {
   #entries = /* @__PURE__ */ new Map();
@@ -650,14 +748,16 @@ var ResultCache = class {
 // src/hub.ts
 var ERROR_CHARS = 1e3;
 function createHub(parts) {
-  const report = (context, message) => {
+  const report = (context, message, about = {}) => {
     parts.log.error("%s: %s", context, message);
     parts.relay.send({
       v: 1,
       ts: Date.now(),
       type: "error",
       message: truncate(message, ERROR_CHARS),
-      context
+      context,
+      ...about.sessionId === void 0 ? {} : { sessionId: about.sessionId },
+      ...about.reason === void 0 ? {} : { reason: about.reason }
     });
   };
   return {
@@ -669,6 +769,195 @@ function createHub(parts) {
   };
 }
 
+// src/questions.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var ASK_USER_QUESTION = "ask_user_question";
+var PROMPT_CHARS = 2e3;
+var PROMPT_BYTES = 4e3;
+var LABEL_CHARS = 300;
+var LABEL_BYTES = 600;
+var REMINDER_MS2 = 5 * 6e4;
+var MAX_REMINDERS2 = 6;
+function installQuestions(hub) {
+  const pending = /* @__PURE__ */ new Map();
+  hub.ctx.on("tools/execute", (exec, next) => {
+    if (exec.name !== ASK_USER_QUESTION || exec.agent === void 0) return next();
+    if (!hub.pairing.everPaired || !hub.relay.connected) return next();
+    if (exec.signal.aborted) return next();
+    return forward2(hub, pending, exec, next);
+  });
+  return {
+    respond(message) {
+      const entry = pending.get(message.questionId);
+      if (entry === void 0) {
+        hub.relay.send(closedMsg2(message.questionId, "expired"));
+        return;
+      }
+      const value = toAnswerValue(entry, message.answers);
+      if (typeof value === "string") {
+        hub.report(`question ${entry.questionId}`, value);
+        return;
+      }
+      entry.settle(successResult(value), "phone");
+    },
+    resendPending() {
+      for (const entry of pending.values()) hub.relay.send(entry.frame, entry.push);
+    },
+    openCount: () => pending.size
+  };
+}
+function forward2(hub, pending, exec, next) {
+  const normalized = normalize(exec.arguments);
+  if (normalized === null) {
+    hub.report("question", "ask_user_question \u53C2\u6570\u65E0\u6CD5\u89E3\u6790\uFF0C\u5DF2\u4EA4\u56DE\u672C\u673A\u5904\u7406");
+    return next();
+  }
+  const questionId = randomUUID3();
+  const sessionId = exec.agent?.id ?? "";
+  const frame = {
+    v: 1,
+    ts: Date.now(),
+    type: "question.request",
+    questionId,
+    sessionId,
+    items: normalized.items,
+    createdAt: Date.now()
+  };
+  const push = {
+    v: 1,
+    ts: Date.now(),
+    type: "push",
+    kind: "question",
+    sessionId,
+    title: normalized.items[0]?.prompt.slice(0, 120) ?? "\u9700\u8981\u4F60\u56DE\u7B54\u4E00\u4E2A\u95EE\u9898"
+  };
+  if (!hub.relay.send(frame, push)) {
+    hub.report("question", "\u63D0\u95EE\u672A\u80FD\u63A8\u9001\u5230\u624B\u673A\uFF08relay \u672A\u8FDE\u63A5\u6216\u5185\u5BB9\u8FC7\u5927\uFF09\uFF0C\u5DF2\u4EA4\u56DE\u672C\u673A\u5904\u7406");
+    return next();
+  }
+  const forwarded = { questionId, sessionId, frame, push, labels: normalized.labels };
+  return race2(hub, pending, forwarded, exec, next);
+}
+function race2(hub, pending, forwarded, exec, next) {
+  const { questionId } = forwarded;
+  return new Promise((resolve3) => {
+    let settled = false;
+    let localFailure;
+    const settle = (result, resolution) => {
+      if (settled) return;
+      settled = true;
+      const entry2 = pending.get(questionId);
+      if (entry2?.timer !== void 0) clearTimeout(entry2.timer);
+      pending.delete(questionId);
+      exec.signal.removeEventListener("abort", onAbort);
+      hub.relay.send(closedMsg2(questionId, resolution));
+      resolve3(result);
+    };
+    function onAbort() {
+      settle(localFailure ?? abortedResult(), "cancelled");
+    }
+    exec.signal.addEventListener("abort", onAbort, { once: true });
+    const entry = { ...forwarded, settle, reminders: 0, timer: void 0 };
+    pending.set(questionId, entry);
+    armReminder2(hub, entry);
+    void next().then((result) => {
+      if (!result.isError) settle(result, "local");
+      else localFailure = result;
+    }, (error) => {
+      hub.fail(`question ${questionId}: local provider failed`, error);
+    });
+  });
+}
+function armReminder2(hub, entry) {
+  entry.timer = setTimeout(() => {
+    entry.timer = void 0;
+    entry.reminders += 1;
+    hub.relay.send(entry.frame, entry.push);
+    if (entry.reminders >= MAX_REMINDERS2) {
+      hub.log.warn(
+        "question %s still unanswered after %d reminders; it stays open (never auto-answered)",
+        entry.questionId,
+        entry.reminders
+      );
+      return;
+    }
+    armReminder2(hub, entry);
+  }, REMINDER_MS2);
+  entry.timer.unref?.();
+}
+function normalize(args) {
+  const questions = args?.questions;
+  if (!Array.isArray(questions) || questions.length === 0) return null;
+  const items = [];
+  const labels = /* @__PURE__ */ new Map();
+  for (const raw of questions) {
+    if (typeof raw?.id !== "string" || typeof raw.question !== "string") return null;
+    const options = [];
+    const byId = /* @__PURE__ */ new Map();
+    (raw.options ?? []).forEach((option, index) => {
+      if (typeof option?.label !== "string") return;
+      const id = `o${String(index)}`;
+      byId.set(id, option.label);
+      options.push({ id, label: clamp(decorate(option.label, option.description), LABEL_CHARS, LABEL_BYTES) });
+    });
+    labels.set(raw.id, byId);
+    items.push({
+      id: raw.id,
+      prompt: clamp(prefix(raw.header, raw.question), PROMPT_CHARS, PROMPT_BYTES),
+      options,
+      multiSelect: raw.multi_select === true,
+      // The tool's output schema always permits `custom`, so free text is
+      // always a valid answer — and the only answer when there are no options.
+      allowFreeText: true
+    });
+  }
+  return items.length === 0 ? null : { items, labels };
+}
+var decorate = (label, description) => description === void 0 || description === "" ? label : `${label} \u2014 ${description}`;
+var prefix = (header, question) => header === void 0 || header === "" ? question : `${header}
+
+${question}`;
+var clamp = (text, chars, bytes) => clampBytes(truncate(text, chars), bytes);
+function toAnswerValue(entry, answers) {
+  if (!Array.isArray(answers)) return "\u56DE\u7B54\u683C\u5F0F\u65E0\u6548\uFF1Aanswers \u4E0D\u662F\u6570\u7EC4";
+  const seen = /* @__PURE__ */ new Set();
+  const projected = [];
+  for (const answer of answers) {
+    const options = entry.labels.get(answer.itemId);
+    if (options === void 0) return `\u56DE\u7B54\u5F15\u7528\u4E86\u672A\u77E5\u7684\u95EE\u9898 id\uFF1A${String(answer.itemId)}`;
+    if (seen.has(answer.itemId)) return `\u95EE\u9898 ${answer.itemId} \u88AB\u56DE\u7B54\u4E86\u591A\u6B21`;
+    seen.add(answer.itemId);
+    const selected = [];
+    for (const optionId of answer.optionIds ?? []) {
+      const label = options.get(optionId);
+      if (label === void 0) return `\u95EE\u9898 ${answer.itemId} \u7684\u9009\u9879 id \u672A\u77E5\uFF1A${String(optionId)}`;
+      selected.push(label);
+    }
+    const item = entry.frame.items.find((candidate) => candidate.id === answer.itemId);
+    if (item !== void 0 && !item.multiSelect && selected.length > 1) {
+      return `\u95EE\u9898 ${answer.itemId} \u662F\u5355\u9009\uFF0C\u5374\u6536\u5230 ${String(selected.length)} \u4E2A\u9009\u9879`;
+    }
+    const custom = answer.freeText;
+    if (selected.length === 0 && (custom === void 0 || custom === "")) {
+      return `\u95EE\u9898 ${answer.itemId} \u65E2\u6CA1\u6709\u9009\u9879\u4E5F\u6CA1\u6709\u6587\u5B57\u56DE\u7B54`;
+    }
+    projected.push({ id: answer.itemId, selected, ...custom === void 0 || custom === "" ? {} : { custom } });
+  }
+  const missing = entry.frame.items.filter((item) => !seen.has(item.id)).map((item) => item.id);
+  if (missing.length > 0) return `\u8FD8\u6709\u95EE\u9898\u672A\u56DE\u7B54\uFF1A${missing.join(", ")}`;
+  return { answers: projected };
+}
+function successResult(value) {
+  return { isError: false, value, content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function abortedResult() {
+  const message = "ask_user_question was cancelled before the user answered";
+  return { isError: true, error: { message }, content: [{ type: "text", text: `Error: ${message}` }] };
+}
+function closedMsg2(questionId, resolution) {
+  return { v: 1, ts: Date.now(), type: "question.closed", questionId, resolution };
+}
+
 // src/relay-client.ts
 var BACKOFF_BASE_MS = 500;
 var BACKOFF_MAX_MS = 3e4;
@@ -818,7 +1107,12 @@ var RelayClient = class {
   #onPresence(frame) {
     const { role, online } = frame;
     if (role !== "phone" || typeof online !== "boolean") return;
-    this.#setPhoneOnline(online);
+    if (online) {
+      this.#phoneOnline = true;
+      this.#options.onPhonePresence(true);
+      return;
+    }
+    this.#setPhoneOnline(false);
   }
   #setPhoneOnline(online) {
     if (this.#phoneOnline === online) return;
@@ -904,6 +1198,7 @@ var RelayClient = class {
 var INBOUND_FIELDS = {
   "sessions.get": [],
   "approval.respond": ["requestId", "approvalId", "decision"],
+  "question.respond": ["requestId", "questionId"],
   "dispatch.request": ["requestId", "prompt"],
   "session.message": ["requestId", "sessionId", "text"]
 };
@@ -921,18 +1216,33 @@ function parseInbound(value) {
     return null;
   }
   if (type === "dispatch.request" && typeof record["worktree"] !== "boolean") return null;
+  if (type === "question.respond" && !isAnswerList(record["answers"])) return null;
   return record;
 }
+function isAnswerList(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  return value.every((entry) => {
+    const answer = entry;
+    if (typeof answer?.itemId !== "string") return false;
+    if (!Array.isArray(answer.optionIds)) return false;
+    if (!answer.optionIds.every((id) => typeof id === "string")) return false;
+    return answer.freeText === void 0 || typeof answer.freeText === "string";
+  });
+}
 
 // src/sessions.ts
 import { SessionId as SessionId2 } from "@deepseek-ai/dsh-session";
 var TITLE_CHARS2 = 80;
+var ACTIVITY_CHARS = 40;
+var ACTIVITY_MIN_GAP_MS = 800;
 var SessionTracker = class {
   #ctx;
   #relay;
   #log;
   #tracked = /* @__PURE__ */ new Map();
   #published = /* @__PURE__ */ new Map();
+  #activityAt = /* @__PURE__ */ new Map();
+  #activityTimers = /* @__PURE__ */ new Map();
   constructor(ctx, relay, log) {
     this.#ctx = ctx;
     this.#relay = relay;
@@ -962,21 +1272,37 @@ var SessionTracker = class {
       });
     });
     this.#ctx.on("agent/turn-stopping", ({ agent }) => {
+      this.#update(agent.id, (entry) => {
+        entry.activity = void 0;
+        entry.activityCallId = void 0;
+      });
       void this.#refreshTitle(agent);
     });
     this.#ctx.on("agent/disposed", ({ agent }) => {
       this.#update(agent.id, (entry) => {
         entry.base = "done";
+        entry.activity = void 0;
       });
       this.#tracked.delete(agent.id);
       this.#published.delete(agent.id);
+      this.#clearActivityTimer(agent.id);
+    });
+    this.#ctx.on("session/event", (session, event) => {
+      if (event.type === "tool/call") {
+        this.#setActivity(session.id, truncate(event.data.name, ACTIVITY_CHARS), event.data.callId);
+        return;
+      }
+      if (event.type === "tool/result") {
+        this.#clearActivity(session.id, event.data.message.content[0].toolCallId);
+      }
     });
   }
   /** Mark a session as started by us, with the dispatch prompt as its title. */
-  markDispatched(sessionId, prompt) {
+  markDispatched(sessionId, prompt, access = "standard") {
     this.#update(sessionId, (entry) => {
       entry.dispatched = true;
       entry.title = truncate(prompt.trim().split("\n", 1)[0] ?? "", TITLE_CHARS2);
+      if (access === "full") entry.access = "full";
     });
   }
   isDispatched(sessionId) {
@@ -999,6 +1325,10 @@ var SessionTracker = class {
   agentOf(sessionId) {
     return this.#ctx.agents.get(SessionId2(sessionId));
   }
+  /** Whether a follow-up would land: exactly the check `session.message` makes. */
+  #isLive(sessionId) {
+    return this.agentOf(sessionId) !== void 0;
+  }
   /** An approval for this session is now waiting on a human. */
   approvalOpened(sessionId) {
     this.#update(sessionId, (entry) => {
@@ -1018,7 +1348,7 @@ var SessionTracker = class {
       if (!record.live) continue;
       const id = record.header.id;
       const known = this.#tracked.get(id) ?? this.#adopt(this.#ctx.agents.get(id));
-      wire.push(known === void 0 ? this.#fallbackWire(id, record.header.cwd ?? "", record.header.createdAt) : toWire(known));
+      wire.push(known === void 0 ? this.#fallbackWire(id, record.header.cwd ?? "", record.header.createdAt) : toWire(known, this.#isLive(id)));
     }
     return wire;
   }
@@ -1029,7 +1359,10 @@ var SessionTracker = class {
       cwd,
       state: "idle",
       lastActivity: createdAt,
-      dispatched: false
+      dispatched: false,
+      access: "standard",
+      // listSessions() already filtered to live records.
+      live: true
     };
   }
   #adopt(agent) {
@@ -1044,11 +1377,52 @@ var SessionTracker = class {
       openApprovals: 0,
       lastActivity: Date.now(),
       dispatched: false,
-      finalized: false
+      access: "standard",
+      finalized: false,
+      activity: void 0,
+      activityCallId: void 0
     };
     this.#tracked.set(agent.id, entry);
     return entry;
   }
+  #setActivity(sessionId, name2, callId) {
+    const entry = this.#tracked.get(sessionId);
+    if (entry === void 0 || entry.activity === name2) return;
+    entry.activity = name2;
+    entry.activityCallId = callId;
+    this.#publishActivity(sessionId);
+  }
+  /** Only the call that set the activity may clear it (tools can overlap). */
+  #clearActivity(sessionId, callId) {
+    const entry = this.#tracked.get(sessionId);
+    if (entry === void 0 || entry.activityCallId !== callId) return;
+    entry.activity = void 0;
+    entry.activityCallId = void 0;
+    this.#publishActivity(sessionId);
+  }
+  /** Trailing-edge coalescing, so a tool-heavy turn cannot flood the phone. */
+  #publishActivity(sessionId) {
+    const elapsed = Date.now() - (this.#activityAt.get(sessionId) ?? 0);
+    if (elapsed >= ACTIVITY_MIN_GAP_MS) {
+      this.#activityAt.set(sessionId, Date.now());
+      this.#publish(sessionId);
+      return;
+    }
+    if (this.#activityTimers.has(sessionId)) return;
+    const timer = setTimeout(() => {
+      this.#activityTimers.delete(sessionId);
+      this.#activityAt.set(sessionId, Date.now());
+      this.#publish(sessionId);
+    }, ACTIVITY_MIN_GAP_MS - elapsed);
+    timer.unref?.();
+    this.#activityTimers.set(sessionId, timer);
+  }
+  #clearActivityTimer(sessionId) {
+    const timer = this.#activityTimers.get(sessionId);
+    if (timer !== void 0) clearTimeout(timer);
+    this.#activityTimers.delete(sessionId);
+    this.#activityAt.delete(sessionId);
+  }
   #update(sessionId, mutate) {
     const entry = this.#tracked.get(sessionId) ?? this.#adopt(this.#ctx.agents.get(SessionId2(sessionId)));
     if (entry === void 0) return;
@@ -1060,8 +1434,8 @@ var SessionTracker = class {
   #publish(sessionId) {
     const entry = this.#tracked.get(sessionId);
     if (entry === void 0) return;
-    const session = toWire(entry);
-    const fingerprint = `${session.state}|${session.title}|${session.cwd}|${String(session.dispatched)}`;
+    const session = toWire(entry, this.#isLive(sessionId));
+    const fingerprint = `${session.state}|${session.title}|${session.cwd}|${String(session.dispatched)}|${String(session.access)}|${String(session.live)}|${session.activity ?? ""}`;
     if (this.#published.get(sessionId) === fingerprint) return;
     this.#published.set(sessionId, fingerprint);
     this.#relay.send({ v: 1, ts: Date.now(), type: "session.update", session });
@@ -1080,14 +1454,17 @@ var SessionTracker = class {
     }
   }
 };
-function toWire(entry) {
+function toWire(entry, live) {
   return {
     sessionId: entry.sessionId,
     title: entry.title,
     cwd: entry.cwd,
     state: stateOf(entry),
     lastActivity: entry.lastActivity,
-    dispatched: entry.dispatched
+    dispatched: entry.dispatched,
+    access: entry.access,
+    live,
+    ...entry.activity === void 0 ? {} : { activity: entry.activity }
   };
 }
 function stateOf(entry) {
@@ -1104,7 +1481,7 @@ function firstPrompt(agent) {
 }
 
 // src/version.ts
-var PLUGIN_VERSION = "0.1.0";
+var PLUGIN_VERSION = "0.3.0";
 
 // src/config.ts
 import { hostname } from "os";
@@ -1113,6 +1490,7 @@ var Config = z.object({
   relay: z.string().required(),
   machineName: z.string().default(hostname()),
   allowedRoots: z.array(z.string()).default([]),
+  allowFullAccessDispatch: z.boolean().default(false),
   dataDir: z.string().default("~/.dsh-dispatch"),
   pwaUrl: z.string().default("http://localhost:5173")
 });
@@ -1150,17 +1528,20 @@ function apply(ctx, config) {
   const sessions = new SessionTracker(ctx, relay, log);
   const hub = createHub({ ctx, config, log, relay, sessions, pairing });
   const approvals = installApprovals(hub);
+  const questions = installQuestions(hub);
   const dispatch = installDispatch(hub);
+  const routers = { approvals, questions, dispatch };
   deferred.message = (message) => {
-    route(hub, approvals, dispatch, message);
+    route(hub, routers, message);
   };
   deferred.hello = () => {
     publishStatus(hub);
     approvals.resendPending();
+    questions.resendPending();
     void publishSnapshot(hub);
   };
   sessions.install();
-  installCommands(hub, { approvals, dispatch });
+  installCommands(hub, routers);
   startRelay(hub);
 }
 function startRelay(hub) {
@@ -1191,7 +1572,8 @@ function startRelay(hub) {
     };
   }, "dsh-dispatch: status heartbeat");
 }
-function route(hub, approvals, dispatch, message) {
+function route(hub, routers, message) {
+  const { approvals, questions, dispatch } = routers;
   switch (message.type) {
     case "sessions.get":
       void publishSnapshot(hub);
@@ -1199,6 +1581,9 @@ function route(hub, approvals, dispatch, message) {
     case "approval.respond":
       approvals.respond(message);
       return;
+    case "question.respond":
+      questions.respond(message);
+      return;
     case "dispatch.request":
       void dispatch.request(message).catch((error) => {
         hub.fail(`dispatch.request ${message.requestId}`, error);
@@ -1216,7 +1601,12 @@ function publishStatus(hub) {
     ts: Date.now(),
     type: "machine.status",
     machine: hub.config.machineName,
-    pluginVersion: PLUGIN_VERSION
+    pluginVersion: PLUGIN_VERSION,
+    capabilities: {
+      fullAccessDispatch: hub.config.allowFullAccessDispatch,
+      questionForwarding: true
+    },
+    allowedRoots: resolvedRoots(hub)
   });
 }
 async function publishSnapshot(hub) {