chainlesschain 0.162.175 → 0.162.176

package/src/lib/hook-manager.js

@@ -4,7 +4,6 @@
  */
 
 import crypto from "crypto";
-import { execSync } from "child_process";
 import broker from "./process-execution-broker/index.js";
 
 /**
@@ -275,8 +274,8 @@ export async function executeHook(hook, context = {}) {
     const type = hook.type || HookType.SYNC;
 
     if (type === HookType.COMMAND || type === HookType.SCRIPT) {
-      // Command/script hooks execute a shell command (execSync hoisted to a
-      // top-level import — this runs per hook on the tool-use hot path).
+      // Command/script hooks execute a shell command through the shared
+      // process broker on the tool-use hot path.
       const cmd = hook.handler || "";
       if (!cmd) {
         return {
@@ -291,18 +290,10 @@ export async function executeHook(hook, context = {}) {
         HOOK_EVENT: hook.event,
         HOOK_CONTEXT: JSON.stringify(context),
       };
-      // M1: Record hook command execution in broker audit log
-      const auditEntry = {
-        pid: process.pid,
-        origin: "hook",
-        command: cmd,
-        args: [],
-        startedAt: Date.now(),
-        sessionId: context?.sessionId,
-      };
-      if (typeof broker._recordAudit === "function")
-        broker._recordAudit(auditEntry);
-      const output = execSync(cmd, {
+      const output = broker.execSync(cmd, {
+        origin: "hook-manager:command",
+        scope: "hook",
+        policy: "allow",
         encoding: "utf-8",
         timeout: hook.timeout || 20000,
         // execSync defaults maxBuffer to 1 MB; a hook that prints more (a

package/src/lib/hook-runner.cjs

@@ -232,7 +232,21 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
         CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
       },
     };
-    if (usePowershell) {
+    const brokerOptions = {
+      ...common,
+      origin: opts.origin || "hook",
+      policy: opts.origin === "plugin:hook" ? "allow" : undefined,
+      pluginId: opts.pluginId || null,
+      pluginVersion: opts.pluginVersion || null,
+      pluginSource: opts.pluginSource || null,
+    };
+    if (opts.broker && opts.origin === "plugin:hook") {
+      res = opts.broker.spawnSync(
+        usePowershell ? buildPowershellArgv(command, shellKind, { executionPolicy: loadShellConfig({ cwd: common.cwd }).executionPolicy }).file : command,
+        usePowershell ? buildPowershellArgv(command, shellKind, { executionPolicy: loadShellConfig({ cwd: common.cwd }).executionPolicy }).argv : [],
+        brokerOptions,
+      );
+    } else if (usePowershell) {
       // Per-hook `shell: powershell|pwsh` (settings hook entry): explicit argv
       // instead of the default shell; the enterprise ExecutionPolicy override
       // (settings shell.powershell.executionPolicy) applies here too.
@@ -352,9 +366,30 @@ async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
     if (usePowershell) {
       const { executionPolicy } = loadShellConfig({ cwd: wd });
       const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
-      child = _deps.spawn(inv.file, inv.argv, { cwd: wd, env: spawnEnv });
+      child = opts.broker && opts.origin === "plugin:hook"
+        ? opts.broker.spawn(inv.file, inv.argv, {
+            cwd: wd,
+            env: spawnEnv,
+            origin: opts.origin,
+            policy: "allow",
+            pluginId: opts.pluginId || null,
+            pluginVersion: opts.pluginVersion || null,
+            pluginSource: opts.pluginSource || null,
+          })
+        : _deps.spawn(inv.file, inv.argv, { cwd: wd, env: spawnEnv });
     } else {
-      child = _deps.spawn(command, { cwd: wd, env: spawnEnv, shell: true });
+      child = opts.broker && opts.origin === "plugin:hook"
+        ? opts.broker.spawn(command, [], {
+            cwd: wd,
+            env: spawnEnv,
+            shell: true,
+            origin: opts.origin,
+            policy: "allow",
+            pluginId: opts.pluginId || null,
+            pluginVersion: opts.pluginVersion || null,
+            pluginSource: opts.pluginSource || null,
+          })
+        : _deps.spawn(command, { cwd: wd, env: spawnEnv, shell: true });
     }
   } catch (err) {
     return {
@@ -444,6 +479,11 @@ function runHooks(commandHooks, input = {}, opts = {}) {
   const runOne = (h) =>
     runCommandHook(h.command, input, {
       ...opts,
+      broker: opts.broker,
+      origin: h.origin,
+      pluginId: h.pluginId,
+      pluginVersion: h.pluginVersion,
+      pluginSource: h.pluginSource,
       timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
       // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
       // "shell":"powershell" }` in the settings hook entry
@@ -504,6 +544,11 @@ async function runHooksParallel(commandHooks, input = {}, opts = {}) {
     hooks.map((h) =>
       runCommandHookAsync(h.command, input, {
         ...opts,
+        broker: opts.broker,
+        origin: h.origin,
+        pluginId: h.pluginId,
+        pluginVersion: h.pluginVersion,
+        pluginSource: h.pluginSource,
         timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
         shell: h.shell != null ? h.shell : opts.shell,
       }).then((r) => ({ h, r })),

package/src/lib/hooks-v2-producers.js

@@ -0,0 +1,15 @@
+/**
+ * Best-effort bridge from real runtime producers to Hooks v2.
+ * Hook failures never change the surrounding agent or interaction result.
+ */
+export function emitHooksV2Event(eventName, context = {}, options = {}) {
+  void import("./hooks-v2-runtime.js")
+    .then(({ default: runtime }) => {
+      if (!runtime || typeof runtime.executeHooks !== "function") return;
+      return runtime.executeHooks(eventName, context, options);
+    })
+    .catch(() => {
+      // Hooks are an optional extension; producer delivery is best-effort.
+    });
+}
+

package/src/lib/hooks-v2-runtime.js

@@ -24,10 +24,12 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import broker from "./process-execution-broker/index.js";
+import { EventRuntimeStore } from "./event-runtime-store.js";
 
 const VALID_HOOK_EVENTS = new Set([
   // Session
-  "PreToolUse", "PostToolUse", "Notification", "Stop", "SubagentStop",
+  "PreToolUse", "PostToolUse", "Notification", "Stop", "SubagentStart", "SubagentStop",
+  "SessionResume", "SessionPause", "PostCompact",
   // Auth
   "PreCommit", "PostCommit",
   // Skill
@@ -35,24 +37,33 @@ const VALID_HOOK_EVENTS = new Set([
   // Model
   "PreCompact", "ModelSelection",
   // Config
-  "ConfigChange", "PermissionAllow", "PermissionDeny",
+  "ConfigChange", "PermissionAllow", "PermissionDeny", "PermissionRequest", "PermissionDenied",
   // Timeline
   "TimelineEntry",
   // MCP
-  "McpRequest", "McpResponse",
+  "McpRequest", "McpResponse", "MCPElicitation",
+  // Task / workspace lifecycle
+  "TaskCreated", "TaskCompleted", "InstructionsLoaded", "CwdChanged",
+  "WorktreeCreate", "WorktreeRemove",
 ]);
 
 const VALID_EXECUTOR_TYPES = new Set(["command", "http", "prompt", "agent", "js"]);
 
 class HooksV2Runtime extends EventEmitter {
-  constructor(configDir) {
+  constructor(configDir, options = {}) {
     super();
     this.configDir = configDir;
+    this.durableStore = options.durableStore || null;
     this.hooks = new Map(); // eventName -> HookDefinition[]
     this.executionLog = [];
     this._loaded = false;
   }
 
+  setDurableStore(store) {
+    this.durableStore = store || null;
+    return this.durableStore;
+  }
+
   /**
    * @typedef {Object} HookDefinition
    * @property {string} id
@@ -132,17 +143,29 @@ class HooksV2Runtime extends EventEmitter {
    * @param {Object} context - event context (tool_name, tool_input, session_id, etc.)
    * @returns {Promise<{results: Array, blocked: boolean, blockingResult?: any}>}
    */
-  async emitEvent(eventName, context = {}) {
+  async emitEvent(eventName, context = {}, options = {}) {
     if (!VALID_HOOK_EVENTS.has(eventName)) {
       throw new Error(`Invalid hook event: ${eventName}`);
     }
 
     const hooks = this.hooks.get(eventName) || [];
-    const results = [];
-    let blocked = false;
-    let blockingResult = null;
-
+    const durableRecord = this.durableStore
+      ? this.durableStore.enqueueInbox(
+          { event: eventName, context },
+          { id: context.event_id || context.eventId || null },
+        )
+      : null;
+    // Hooks are parallel by default. De-duplicate by id so a reload or layered
+    // config cannot execute the same handler twice. `parallel:false` remains a
+    // deterministic compatibility mode for callers that require ordering.
+    const uniqueHooks = [];
+    const seen = new Set();
     for (const hook of hooks) {
+      if (seen.has(hook.id)) continue;
+      seen.add(hook.id);
+      uniqueHooks.push(hook);
+    }
+    const runOne = async (hook) => {
       const execId = crypto.randomUUID();
       const start = Date.now();
       const record = { execId, hookId: hook.id, event: eventName, type: hook.type, startedAt: new Date() };
@@ -170,28 +193,47 @@ class HooksV2Runtime extends EventEmitter {
         record.durationMs = Date.now() - start;
         record.status = "success";
         record.result = result;
-        results.push(record);
-
-        // Check for blocking decision
-        if (hook.blocking && result && result.decision === "block") {
-          blocked = true;
-          blockingResult = result;
-          record.blocked = true;
-        }
+        if (hook.blocking && result && result.decision === "block") record.blocked = true;
 
         this.emit("hook:success", record);
       } catch (err) {
         record.durationMs = Date.now() - start;
         record.status = "error";
         record.error = err.message;
-        results.push(record);
         this.emit("hook:error", record);
       }
 
       this.executionLog.push(record);
+      return record;
+    };
+    const results = options.parallel === false
+      ? []
+      : await Promise.all(uniqueHooks.map(runOne));
+    if (options.parallel === false) {
+      for (const hook of uniqueHooks) results.push(await runOne(hook));
     }
+    const blocking = results.filter((r) => r.blocked === true);
+    const blocked = blocking.length > 0;
+    const blockingResult = blocking[0]?.result || null;
+
+    const outcome = { success: !blocked, results, blocked, blockingResult };
+    if (durableRecord && !durableRecord.duplicate) {
+      this.durableStore.acknowledgeInbox(durableRecord.id, {
+        event: eventName,
+        blocked,
+        resultCount: results.length,
+      });
+      this.durableStore.enqueueOutbox(
+        { event: eventName, outcome },
+        { id: `${durableRecord.id}:result` },
+      );
+    }
+    return outcome;
+  }
 
-    return { results, blocked, blockingResult };
+  /** Compatibility/public name used by runtime parity and SDK callers. */
+  async executeHooks(eventName, context = {}, options = {}) {
+    return this.emitEvent(eventName, context, options);
   }
 
   async _execCommand(hook, context) {
@@ -253,7 +295,9 @@ class HooksV2Runtime extends EventEmitter {
   }
 
   async _execJs(hook, context) {
-    // In-process JS execution via vm (sandboxed) - stub for full vm2/isolated-vm integration
+    if (typeof hook.handler === "function") return hook.handler(context);
+    // In-process JS execution via vm (sandboxed) - config-loaded code remains
+    // disabled until the dedicated VM executor is enabled.
     return { decision: "noop", note: "JS executor stub - context received", contextKeys: Object.keys(context) };
   }
 
@@ -273,6 +317,11 @@ class HooksV2Runtime extends EventEmitter {
 }
 
 // Singleton instance
-const hooksRuntime = new HooksV2Runtime();
+const hooksRuntime = new HooksV2Runtime(undefined, {
+  durableStore:
+    process.env.CC_EVENT_RUNTIME_DURABLE === "1"
+      ? new EventRuntimeStore()
+      : null,
+});
 export default hooksRuntime;
 export { HooksV2Runtime, VALID_HOOK_EVENTS, VALID_EXECUTOR_TYPES };

package/src/lib/host-adb-bridge.js

@@ -17,8 +17,8 @@
  * still used for the V5/V6 IPC code path (separate hub singleton).
  *
  * Methods implemented (only what system-data-android consumes):
- *   - `contacts.query({since?})` →
- *       [{ lookupKey, displayName }, ...]
+ *   - `contacts.query({since?})` → contacts with phones, emails,
+ *       organization, job title, starred state, and photo URI
  *   - `app.list({includeSystem?})` →
  *       [{ packageName }, ...]
  *
@@ -120,27 +120,116 @@ function parseContentQueryRows(stdout) {
   return rows;
 }
 
-async function queryContacts(_params, opts) {
+function mergeContactRows(contactRows, phoneRows, emailRows, organizationRows) {
+  const byId = new Map();
+  for (const row of contactRows) {
+    const contactId = row._id == null ? null : String(row._id);
+    const displayName = row.display_name || null;
+    if (!contactId || !displayName) continue;
+    byId.set(contactId, {
+      lookupKey: row.lookup || null,
+      displayName,
+      phones: [],
+      emails: [],
+      starred: row.starred === "1",
+      organization: null,
+      jobTitle: null,
+      photoUri: row.photo_uri || null,
+    });
+  }
+
+  const appendUnique = (rows, field, valueOf) => {
+    for (const row of rows) {
+      const contact = byId.get(String(row.contact_id));
+      const value = valueOf(row);
+      if (!contact || typeof value !== "string" || !value.trim()) continue;
+      const normalized = value.trim();
+      if (!contact[field].includes(normalized)) contact[field].push(normalized);
+    }
+  };
+  appendUnique(phoneRows, "phones", (row) => row.data1 || row.number);
+  appendUnique(emailRows, "emails", (row) => row.data1 || row.address);
+  for (const row of organizationRows) {
+    const contact = byId.get(String(row.contact_id));
+    if (!contact) continue;
+    const organization = row.data1 || row.company;
+    const jobTitle = row.data4 || row.title;
+    if (!contact.organization && organization && organization.trim()) {
+      contact.organization = organization.trim();
+    }
+    if (!contact.jobTitle && jobTitle && jobTitle.trim()) {
+      contact.jobTitle = jobTitle.trim();
+    }
+  }
+  return [...byId.values()];
+}
+
+async function queryContacts(params, opts) {
   const serial = await pickDevice(opts);
-  const stdout = await adb(
-    [
-      "shell",
-      "content",
-      "query",
-      "--uri",
-      "content://com.android.contacts/contacts",
-      "--projection",
-      "lookup:display_name",
-    ],
-    { ...opts, serial },
+  const contactArgs = [
+    "shell",
+    "content",
+    "query",
+    "--uri",
+    "content://com.android.contacts/contacts",
+    "--projection",
+    "_id:lookup:display_name:starred:photo_uri",
+  ];
+  if (Number.isInteger(params?.since) && params.since > 0) {
+    contactArgs.push(
+      "--where",
+      `contact_last_updated_timestamp >= ${params.since}`,
+    );
+  }
+  const commandOpts = { ...opts, serial, timeoutMs: opts.timeoutMs || 120_000 };
+  const [contactsOut, phonesOut, emailsOut, organizationsOut] =
+    await Promise.all([
+      adb(contactArgs, commandOpts),
+      adb(
+        [
+          "shell",
+          "content",
+          "query",
+          "--uri",
+          "content://com.android.contacts/data/phones",
+          "--projection",
+          "contact_id:data1",
+        ],
+        commandOpts,
+      ),
+      adb(
+        [
+          "shell",
+          "content",
+          "query",
+          "--uri",
+          "content://com.android.contacts/data/emails",
+          "--projection",
+          "contact_id:data1",
+        ],
+        commandOpts,
+      ),
+      adb(
+        [
+          "shell",
+          "content",
+          "query",
+          "--uri",
+          "content://com.android.contacts/data",
+          "--projection",
+          "contact_id:data1:data4",
+          "--where",
+          "mimetype='vnd.android.cursor.item/organization'",
+        ],
+        commandOpts,
+      ),
+    ]);
+  return mergeContactRows(
+    parseContentQueryRows(contactsOut),
+    parseContentQueryRows(phonesOut),
+    parseContentQueryRows(emailsOut),
+    parseContentQueryRows(organizationsOut),
   );
-  const rows = parseContentQueryRows(stdout);
-  return rows
-    .map((r) => ({
-      lookupKey: r.lookup || null,
-      displayName: r.display_name || null,
-    }))
-    .filter((c) => c.displayName);
 }
 
 async function listApps(params, opts) {
@@ -497,6 +586,7 @@ export function createHostAdbBridge(opts = {}) {
 // Exposed for unit testing without spawning real adb.
 export const _internals = {
   parseContentQueryRows,
+  mergeContactRows,
   listDevices,
   pickDevice,
   queryContacts,

package/src/lib/ide-context.js

@@ -438,6 +438,109 @@ export function hasIdeOpenDiff(mcp) {
   );
 }
 
+const DIFF_REVIEW_AUDIT_SCHEMA = "cc-diff-review/v1";
+const DIFF_REVIEW_OPERATIONS = new Set([
+  "modify",
+  "create",
+  "delete",
+  "rename",
+]);
+
+function auditString(value, max) {
+  if (value == null) return null;
+  const text = String(value).slice(0, max);
+  return text || null;
+}
+
+function auditIndex(value) {
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
+
+function auditFingerprint(value) {
+  if (!value || typeof value !== "object") return null;
+  const sha256 = auditString(value.sha256, 64);
+  if (!/^[a-f0-9]{64}$/i.test(sha256 || "")) return null;
+  return {
+    sha256: sha256.toLowerCase(),
+    chars: auditIndex(value.chars),
+    lines: auditIndex(value.lines),
+  };
+}
+
+/**
+ * Reduce a host-provided Diff Review audit to the bounded v1 wire contract.
+ * Correlation ids and path are overwritten from the CLI request so a malformed
+ * or stale local bridge cannot spoof which session/tool the decision belongs to.
+ */
+export function normalizeDiffReviewAudit(value, binding = {}) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    value.schema !== DIFF_REVIEW_AUDIT_SCHEMA
+  ) {
+    return null;
+  }
+  const requestedOutcome = auditString(binding.outcome ?? value.outcome, 64);
+  const outcome = ["accepted", "rejected", "changes-requested"].includes(
+    requestedOutcome,
+  )
+    ? requestedOutcome
+    : "rejected";
+  const requestedOperation = binding.operation ?? value.operation;
+  const operation = DIFF_REVIEW_OPERATIONS.has(requestedOperation)
+    ? requestedOperation
+    : "modify";
+  const comments = (Array.isArray(value.comments) ? value.comments : [])
+    .filter((comment) => comment && typeof comment === "object")
+    .map((comment) => ({
+      line: auditIndex(comment.line),
+      endLine: auditIndex(comment.endLine),
+      lineFingerprint: auditFingerprint(comment.lineFingerprint),
+      note: auditString(comment.note, 1000),
+    }))
+    .filter((comment) => comment.note)
+    .slice(0, 32);
+  const selectedHunks = [
+    ...new Set(
+      (Array.isArray(value.selectedHunks) ? value.selectedHunks : []).filter(
+        (index) => Number.isInteger(index) && index >= 0,
+      ),
+    ),
+  ]
+    .sort((a, b) => a - b)
+    .slice(0, 128);
+  return {
+    schema: DIFF_REVIEW_AUDIT_SCHEMA,
+    reviewId: auditString(value.reviewId, 64),
+    createdAt: auditString(value.createdAt, 64),
+    actor: auditString(value.actor, 128) || "local-user",
+    host: auditString(value.host, 64) || "ide",
+    path: auditString(binding.path ?? value.path, 2048),
+    operation,
+    targetPath:
+      operation === "rename"
+        ? auditString(binding.targetPath ?? value.targetPath, 2048)
+        : null,
+    sessionId: auditString(binding.sessionId, 256),
+    turnId: auditString(binding.turnId, 256),
+    toolUseId: auditString(binding.toolUseId, 256),
+    outcome,
+    source: auditString(value.source, 64) || "agent-proposed",
+    written: value.written === true,
+    followUpRequested:
+      value.followUpRequested === true || outcome === "changes-requested",
+    baseline: auditFingerprint(value.baseline),
+    proposed: auditFingerprint(value.proposed),
+    reviewed: auditFingerprint(value.reviewed),
+    final: auditFingerprint(value.final),
+    selectedHunks,
+    appliedHunks: auditIndex(value.appliedHunks),
+    totalHunks: auditIndex(value.totalHunks),
+    comments,
+    reason: auditString(value.reason, 512),
+  };
+}
+
 /**
  * Run one blocking openDiff review in the connected IDE. Returns
  *   { outcome:"accepted", finalText|null }  — the IDE wrote the file itself
@@ -459,7 +562,17 @@ export function hasIdeOpenDiff(mcp) {
 export async function requestIdeDiffApproval(mcp, req = {}) {
   if (!hasIdeOpenDiff(mcp)) return null;
   if (!req.path || typeof req.modifiedText !== "string") return null;
+  const operation = req.operation || "modify";
+  if (!DIFF_REVIEW_OPERATIONS.has(operation)) return null;
+  if (operation === "rename" && !req.targetPath) return null;
   const exec = mcp.externalToolExecutors.mcp__ide__openDiff;
+  const reviewContext = Object.fromEntries(
+    Object.entries({
+      sessionId: auditString(req.sessionId, 256),
+      turnId: auditString(req.turnId, 256),
+      toolUseId: auditString(req.toolUseId, 256),
+    }).filter(([, value]) => value),
+  );
   let result;
   try {
     result = await mcp.mcpClient.callTool(exec.serverName, exec.toolName, {
@@ -469,15 +582,26 @@ export async function requestIdeDiffApproval(mcp, req = {}) {
         ? { originalText: req.originalText }
         : {}),
       ...(req.title ? { title: req.title } : {}),
+      ...(req.operation ? { operation } : {}),
+      ...(operation === "rename" ? { targetPath: req.targetPath } : {}),
+      ...(Object.values(reviewContext).some(Boolean) ? { reviewContext } : {}),
     });
   } catch {
     return null;
   }
   const data = parseToolResultJson(result);
+  const audit = normalizeDiffReviewAudit(data?.audit, {
+    ...reviewContext,
+    path: req.path,
+    operation,
+    targetPath: operation === "rename" ? req.targetPath : null,
+    outcome: data?.outcome,
+  });
   if (data?.outcome === "accepted") {
     return {
       outcome: "accepted",
       finalText: typeof data.finalText === "string" ? data.finalText : null,
+      ...(audit ? { audit } : {}),
     };
   }
   if (data?.outcome === "changes-requested") {
@@ -486,9 +610,12 @@ export async function requestIdeDiffApproval(mcp, req = {}) {
       comments: Array.isArray(data.comments) ? data.comments : [],
       reviewedText:
         typeof data.reviewedText === "string" ? data.reviewedText : null,
+      ...(audit ? { audit } : {}),
     };
   }
-  if (data?.outcome === "rejected") return { outcome: "rejected" };
+  if (data?.outcome === "rejected") {
+    return { outcome: "rejected", ...(audit ? { audit } : {}) };
+  }
   return null; // anything else is not a verdict — fail safe to fallback
 }
 

package/src/lib/interaction-adapter.js

@@ -14,6 +14,7 @@ import {
   LEGACY_TO_UNIFIED_TYPE,
 } from "../runtime/runtime-events.js";
 import { createAbortError } from "./abort-utils.js";
+import { emitHooksV2Event } from "./hooks-v2-producers.js";
 import { verifyApprovalBinding } from "./agent-authority.js";
 import { createEnvelope } from "@chainlesschain/session-core";
 
@@ -245,6 +246,44 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     this._resolvePending(requestId, answer, "question", binding);
   }
 
+  /**
+   * Ask an MCP server elicitation over the same question/answer channel.
+   * The schema is carried as metadata so capable IDE clients can render a
+   * native form; older clients still receive a bounded, ordinary question.
+   */
+  async askElicitation({
+    server,
+    requestId: mcpRequestId,
+    message = "MCP server requests input",
+    requestedSchema = null,
+    timeoutMs,
+  } = {}) {
+    emitHooksV2Event("MCPElicitation", {
+      server: server || null,
+      request_id: mcpRequestId ?? null,
+      message: String(message),
+      requested_schema: requestedSchema || null,
+    });
+    return this._request(
+      {
+        type: "question",
+        questionType: "elicitation",
+        question: String(message),
+        ...(requestedSchema ? { requestedSchema } : {}),
+        metadata: {
+          kind: "mcp_elicitation",
+          server: server || null,
+          requestId: mcpRequestId ?? null,
+          requestedSchema: requestedSchema || null,
+        },
+      },
+      {
+        kind: "question",
+        ...(Number(timeoutMs) > 0 ? { timeoutMs: Number(timeoutMs) } : {}),
+      },
+    );
+  }
+
   async requestHostTool(toolName, args = {}, extra = {}) {
     return this._request(
       {