@codexhost/cli-win32-arm64 0.13.3 → 0.15.0

package/app/plugins/grok/plugin.mjs

@@ -393,10 +393,13 @@ function usageSessionTitle(value) {
     return void 0;
   if (normalized.length <= MAX_SESSION_TITLE_LENGTH)
     return normalized;
-  const characters = [...normalized];
-  if (characters.length <= MAX_SESSION_TITLE_LENGTH)
-    return normalized;
-  return `${characters.slice(0, MAX_SESSION_TITLE_LENGTH - 1).join("").trimEnd()}…`;
+  let title = "";
+  for (const character of normalized) {
+    if (title.length + character.length >= MAX_SESSION_TITLE_LENGTH)
+      break;
+    title += character;
+  }
+  return `${title.trimEnd()}…`;
 }
 function sessionIdOk(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_SESSION_ID_LENGTH;
@@ -3631,10 +3634,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
+      const field2 = shape[key]._zod;
+      if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field.values)
+        for (const v of field2.values)
           propValues[key].add(v);
       }
     }
@@ -15253,10 +15256,19 @@ var model = external_exports.string().min(1).max(512);
 var project = external_exports.string().min(1).max(4096);
 var usageStatisticsParamsSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+  timeZone: external_exports.string().min(1).max(128).refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Unsupported usage statistics timezone").optional(),
   harness: harness.optional(),
   model: model.nullable().optional(),
   project: project.nullable().optional(),
-  /** One local date inside the range. */
+  /** One date in the query timezone inside the range. */
   date: localDate.optional()
 });
 var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -15292,7 +15304,7 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
 });
 var usageStatisticsResultSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
-  /** First local date of the range; null for all time. */
+  /** First date in the query timezone (Host local when omitted); null for all time. */
   from: localDate.nullable(),
   to: localDate,
   /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -15332,7 +15344,7 @@ var usageStatisticsResultSchema = external_exports.strictObject({
   totals: usageStatisticsTotalsSchema,
   /** Each date and Harness of the range: every filter except the day. */
   daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
   hourly: external_exports.array(external_exports.strictObject({
     weekday: external_exports.number().int().min(0).max(6),
     hour: external_exports.number().int().min(0).max(23),
@@ -15372,6 +15384,51 @@ var hostInteractionIdSchema = opaqueIdSchema.brand();
 var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
 var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+// ../../shared-contracts/dist/thread-questions.js
+var field = external_exports.discriminatedUnion("type", [
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("choice"),
+    prompt: external_exports.string(),
+    options: external_exports.array(external_exports.object({
+      value: external_exports.string().min(1),
+      label: external_exports.string(),
+      description: external_exports.string().optional()
+    })).min(1),
+    multiple: external_exports.boolean(),
+    allowOther: external_exports.boolean(),
+    optional: external_exports.boolean()
+  }),
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("text"),
+    prompt: external_exports.string(),
+    multiline: external_exports.boolean(),
+    secret: external_exports.literal(false),
+    optional: external_exports.boolean(),
+    placeholder: external_exports.string().optional(),
+    prefill: external_exports.string().optional()
+  })
+]);
+var threadQuestionSchema = external_exports.object({
+  interactionId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  title: external_exports.string().optional(),
+  questions: external_exports.array(field).min(1)
+}).refine(({ questions }) => questions.some((q) => q.type === "choice" && q.multiple), {
+  message: "Shared cards require at least one multi-select question"
+});
+var threadQuestionsListParamsSchema = external_exports.strictObject({ threadId: external_exports.string().min(1) });
+var threadQuestionsResultSchema = external_exports.object({ questions: external_exports.array(threadQuestionSchema) });
+var threadQuestionRespondParamsSchema = external_exports.strictObject({
+  threadId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  interactionId: external_exports.string().min(1),
+  answers: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())),
+  cancelled: external_exports.boolean().default(false)
+});
+var threadQuestionRespondResultSchema = external_exports.object({ accepted: external_exports.literal(true) });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -15392,6 +15449,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
   "codexhost/harness/installation",
+  "codexhost/harness/installation/start",
+  "codexhost/harness/installation/status",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
   "codexhost/harness/web-ui/open",
@@ -15467,7 +15526,18 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text) => text.length <= maximum));
+var composerIndicatorsSchema = external_exports.array(external_exports.object({
+  kind: external_exports.literal("countdown"),
+  id: external_exports.string().min(1).max(64),
+  expiresAtUnix: nonNegativeSafeIntegerSchema,
+  label: indicatorTextSchema(256).optional(),
+  tooltip: indicatorTextSchema(1024).optional()
+}).strict()).max(2).refine((entries) => new Set(entries.map(({ id }) => id)).size === entries.length, {
+  message: "Composer indicator IDs must be unique"
+});
 var threadUsageSnapshotSchema = external_exports.object({
+  composerIndicators: composerIndicatorsSchema.optional(),
   inputTokens: nonNegativeSafeIntegerSchema.optional(),
   cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -15875,7 +15945,9 @@ var harnessSessionCapabilitiesSchema = external_exports.object({
   }).strict().optional(),
   autonomousTurns: external_exports.object({
     observe: external_exports.boolean()
-  }).strict().optional()
+  }).strict().optional(),
+  /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+  steer: external_exports.boolean().optional()
 }).strict();
 var harnessConfigurationStateSchema = external_exports.object({
   effectiveModel: harnessModelRefSchema.optional(),
@@ -15922,7 +15994,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -16005,6 +16079,15 @@ var threadOwnershipListResultSchema = external_exports.object({
     seen.add(thread.threadId);
   }
 });
+var threadSteeringInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  /** The text about to be steered; a Harness command always stops and restarts. */
+  text: external_exports.string().optional()
+}).strict();
+var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+var threadSteeringInspectResultSchema = external_exports.object({
+  delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+}).strict();
 
 // ../../shared-contracts/dist/harness-plugins.js
 var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -16106,6 +16189,10 @@ var harnessInstallationStateSchema = external_exports.object({
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
+  /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+  versionKind: external_exports.enum(["cli", "application"]).optional(),
+  /** Official download opened by the user; does not imply an automatic installation. */
+  manualUpdateUrl: external_exports.url().max(2048).refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Manual updates require a credential-free HTTPS URL").optional(),
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
@@ -16113,6 +16200,20 @@ var harnessInstallationStateSchema = external_exports.object({
   notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
+var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("succeeded"),
+    result: harnessInstallationStateSchema
+  }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("failed"),
+    error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+  }).strict()
+]);
 
 // ../../shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -16504,6 +16605,42 @@ function validateHostApprovalResponse(interaction, response) {
   return interaction.actions.some(({ id }) => id === response.actionId) ? null : invalidRequest("Approval Response contains an undeclared action ID");
 }
 
+// ../../harness-adapter/dist/question.js
+function invalidRequest2(message) {
+  return { code: "invalidRequest", message, retryable: false };
+}
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest2("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest2("Question Response contains an unknown Question ID");
+    }
+  }
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest2("Question Response omits a required answer");
+    }
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest2("Text Question accepts at most one answer");
+      }
+      continue;
+    }
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest2("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest2("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
+}
+
 // ../../harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -16562,6 +16699,18 @@ function sanitizeDiagnosticTail(value) {
   return redacted.length <= DIAGNOSTIC_TAIL_MAX_LENGTH ? redacted : redacted.slice(-DIAGNOSTIC_TAIL_MAX_LENGTH);
 }
 
+// ../../harness-adapter/dist/steer.js
+function unsupportedSteer(harnessLabel) {
+  return {
+    ok: false,
+    error: {
+      code: "unsupported",
+      message: `${harnessLabel} cannot steer an active Turn natively`,
+      retryable: false
+    }
+  };
+}
+
 // ../../harness-adapter/dist/usage.js
 var tokenFields = [
   "inputTokens",
@@ -16589,6 +16738,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -16611,26 +16761,27 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
-  for (const field of [
+  const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
+  for (const field2 of [
     "totalCredits",
     "contextUsagePercent",
     "apiOutputTokensPerSecond"
   ]) {
-    const candidate = value[field];
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+      throw new Error(`Harness Usage '${field2}' must be a finite non-negative number`);
     }
   }
-  for (const field of tokenFields) {
-    const candidate = value[field];
+  for (const field2 of tokenFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
-  for (const field of safeIntegerFields) {
-    const candidate = value[field];
+  for (const field2 of safeIntegerFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
@@ -16639,10 +16790,10 @@ function parseHostUsage(value) {
   if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
-  for (const field of percentFields) {
-    const candidate = value[field];
+  for (const field2 of percentFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+      throw new Error(`Harness Usage '${field2}' must be between 0 and 100`);
     }
   }
   if (value.sessionCacheUsage !== void 0) {
@@ -16681,9 +16832,9 @@ function parseHostUsage(value) {
     if (value.costSource !== "publicPrice") {
       throw new Error("Harness Usage 'unpricedModels' must be provided with a 'publicPrice' cost");
     }
-    return { ...value, unpricedModels: [...models] };
+    return { ...value, ...indicators, unpricedModels: [...models] };
   }
-  return { ...value };
+  return { ...value, ...indicators };
 }
 var requestTokenFields = [
   "inputTokens",
@@ -21868,10 +22019,10 @@ function stringField(value, key) {
 function numberField(value, key) {
   if (!isRecord6(value))
     return void 0;
-  const field = value[key];
-  if (field === null)
+  const field2 = value[key];
+  if (field2 === null)
     return null;
-  return typeof field === "number" && Number.isFinite(field) ? field : void 0;
+  return typeof field2 === "number" && Number.isFinite(field2) ? field2 : void 0;
 }
 function decodeBytes(value) {
   if (!Array.isArray(value) || value.length === 0)
@@ -22070,13 +22221,13 @@ function isRecord7(value) {
 function idField(value, key) {
   if (!isRecord7(value))
     return void 0;
-  const field = value[key];
-  if (typeof field === "string") {
-    const trimmed = field.trim();
+  const field2 = value[key];
+  if (typeof field2 === "string") {
+    const trimmed = field2.trim();
     return trimmed.length > 0 ? trimmed : void 0;
   }
-  if (typeof field === "number" && Number.isFinite(field))
-    return String(field);
+  if (typeof field2 === "number" && Number.isFinite(field2))
+    return String(field2);
   return void 0;
 }
 function stringField2(value, key) {
@@ -23281,6 +23432,210 @@ function grokPermissionModeSessionMeta(permissionMode) {
   };
 }
 
+// dist/permission-confirmation.js
+import { stripVTControlCharacters } from "node:util";
+var GROK_PERMISSION_MODE_METHOD = "_x.ai/yolo_mode_changed";
+var permissionManagerLog = "xai_grok_workspace::permission::manager=info";
+function grokPermissionLogFilter(existing) {
+  return existing ? `${existing},${permissionManagerLog}` : permissionManagerLog;
+}
+var GrokPermissionConfirmation = class {
+  #expected;
+  #completion = Promise.withResolvers();
+  #yolo;
+  #auto;
+  #buffer = "";
+  constructor(mode) {
+    this.#expected = grokPermissionModeSessionMeta(mode);
+  }
+  get completed() {
+    return this.#completion.promise;
+  }
+  accept(chunk) {
+    this.#buffer += chunk;
+    let newline2;
+    while ((newline2 = this.#buffer.indexOf("\n")) !== -1) {
+      const line = stripVTControlCharacters(this.#buffer.slice(0, newline2)).trimEnd();
+      this.#buffer = this.#buffer.slice(newline2 + 1);
+      const match = /^\d{4}-\d{2}-\d{2}T\S+\s+INFO\s+(?:.*?: )?(always-approve|auto permission mode) set to: (true|false)$/.exec(line);
+      if (!match)
+        continue;
+      const value = match[2] === "true";
+      if (match[1] === "always-approve")
+        this.#yolo = value;
+      else
+        this.#auto = value;
+      if (this.#yolo !== void 0 && this.#yolo !== this.#expected.yoloMode || this.#auto !== void 0 && this.#auto !== this.#expected.autoMode) {
+        this.reject(new Error("Grok did not apply the requested Permission Mode"));
+      } else if (this.#yolo !== void 0 && this.#auto !== void 0) {
+        this.#completion.resolve(void 0);
+      }
+    }
+    if (this.#buffer.length > 16384)
+      this.#buffer = "";
+  }
+  reject(error53) {
+    this.#completion.reject(error53);
+  }
+};
+
+// dist/grok-questions.js
+var GROK_ASK_USER_QUESTION_METHOD = "_x.ai/ask_user_question";
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseGrokQuestionRequest(value) {
+  if (!isRecord12(value) || !nonEmptyString(value.sessionId) || !nonEmptyString(value.toolCallId) || value.mode !== "default" && value.mode !== "plan" || !Array.isArray(value.questions) || value.questions.length === 0)
+    throw new Error("Grok question requires sessionId, toolCallId, mode and nonempty questions");
+  const seen = /* @__PURE__ */ new Set();
+  const questions = value.questions.map((question) => {
+    if (!isRecord12(question) || !nonEmptyString(question.question) || seen.has(question.question) || !Array.isArray(question.options) || question.multiSelect != null && typeof question.multiSelect !== "boolean" || question.multi_select != null && typeof question.multi_select !== "boolean")
+      throw new Error("Grok question text must be unique and options/multiSelect must be valid");
+    if (question.multiSelect != null && question.multi_select != null && question.multiSelect !== question.multi_select)
+      throw new Error("Grok question contains conflicting multi-select flags");
+    seen.add(question.question);
+    const labels = /* @__PURE__ */ new Set();
+    const options = question.options.map((option) => {
+      if (!isRecord12(option) || !nonEmptyString(option.label) || labels.has(option.label) || typeof option.description !== "string" || option.preview != null && typeof option.preview !== "string")
+        throw new Error("Grok question options require unique labels and text descriptions/previews");
+      labels.add(option.label);
+      return {
+        label: option.label,
+        description: option.description,
+        ...typeof option.preview === "string" ? { preview: option.preview } : {}
+      };
+    });
+    return {
+      question: question.question,
+      options,
+      multiple: question.multiSelect === true || question.multi_select === true
+    };
+  });
+  return { sessionId: value.sessionId, toolCallId: value.toolCallId, mode: value.mode, questions };
+}
+var GrokQuestions = class {
+  turnId;
+  randomUUID;
+  emit;
+  #pending = /* @__PURE__ */ new Map();
+  #seenToolCalls = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(turnId, randomUUID2, emit) {
+    this.turnId = turnId;
+    this.randomUUID = randomUUID2;
+    this.emit = emit;
+  }
+  has(interactionId) {
+    return this.#pending.has(interactionId);
+  }
+  ask(request) {
+    if (this.#closed || this.#seenToolCalls.has(request.toolCallId))
+      return Promise.resolve({ outcome: "cancelled" });
+    this.#seenToolCalls.add(request.toolCallId);
+    const interaction = {
+      type: "question",
+      interactionId: hostInteractionIdSchema.parse(this.randomUUID()),
+      turnId: this.turnId,
+      title: "Grok",
+      questions: request.questions.map((question, index) => question.options.length ? {
+        id: `q${index}`,
+        type: "choice",
+        prompt: question.question,
+        options: question.options.map(({ label, description, preview }) => ({
+          value: label,
+          label,
+          description: [description, preview].filter(Boolean).join("\n\n")
+        })),
+        multiple: question.multiple,
+        allowOther: true,
+        optional: true
+      } : {
+        id: `q${index}`,
+        type: "text",
+        prompt: question.question,
+        multiline: true,
+        secret: false,
+        optional: true
+      })
+    };
+    return new Promise((resolve) => {
+      this.#pending.set(interaction.interactionId, { request, interaction, resolve });
+      this.emit({ kind: "interaction", interaction });
+    });
+  }
+  respond(command) {
+    const pending = this.#pending.get(command.interactionId);
+    if (!pending)
+      return this.#error("invalidState", "Grok Question is not pending");
+    if (command.response.type !== "question")
+      return this.#error("invalidRequest", "Grok Question requires a Question Response");
+    const response = command.response;
+    const error53 = validateHostQuestionResponse(pending.interaction, response);
+    if (error53)
+      return { ok: false, error: error53 };
+    if (response.cancelled) {
+      this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+      return { ok: true, value: { accepted: true } };
+    }
+    const answers = /* @__PURE__ */ new Map();
+    const annotations = /* @__PURE__ */ new Map();
+    for (const [index, question] of pending.request.questions.entries()) {
+      const values = response.answers[`q${index}`];
+      if (!values?.length)
+        continue;
+      if (values.some((answer) => !nonEmptyString(answer)) || new Set(values).size !== values.length)
+        return this.#error("invalidRequest", "Grok answers must be nonempty and unique");
+      const selected = values.map((answer) => question.options.find(({ label }) => label === answer));
+      const other = values.filter((_, position) => !selected[position]);
+      if (other.length > 1)
+        return this.#error("invalidRequest", "Grok question accepts only one Other response");
+      answers.set(question.question, selected.map((option) => option?.label ?? "Other"));
+      const previews = selected.flatMap((option) => option?.preview !== void 0 ? [option.preview] : []);
+      if (previews.length || other.length)
+        annotations.set(question.question, {
+          ...previews.length ? { preview: previews.join("\n\n") } : {},
+          ...other.length ? { notes: other[0] } : {}
+        });
+    }
+    this.#settle(pending, {
+      outcome: "accepted",
+      answers: Object.fromEntries(answers),
+      ...annotations.size ? { annotations: Object.fromEntries(annotations) } : {}
+    }, "responded");
+    return { ok: true, value: { accepted: true } };
+  }
+  withdraw(toolCallId) {
+    for (const pending of this.#pending.values()) {
+      if (pending.request.toolCallId === toolCallId)
+        this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+    }
+  }
+  cancel() {
+    this.#closed = true;
+    for (const pending of this.#pending.values())
+      this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+  }
+  #settle(pending, response, reason) {
+    this.#pending.delete(pending.interaction.interactionId);
+    pending.resolve(response);
+    this.emit({
+      kind: "event",
+      event: {
+        type: "interaction.closed",
+        interactionId: pending.interaction.interactionId,
+        turnId: this.turnId,
+        reason
+      }
+    });
+  }
+  #error(code, message) {
+    return { ok: false, error: { code, message, retryable: false } };
+  }
+};
+
 // dist/acp-transport.js
 var GrokTransportError = class extends Error {
   kind;
@@ -23292,16 +23647,16 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function acpToolName(update, metadata) {
-  if (!isRecord12(update))
+  if (!isRecord13(update))
     return void 0;
   if (typeof update.name === "string" && update.name.length > 0)
     return update.name;
-  const meta3 = isRecord12(update._meta) ? update._meta : metadata;
-  const tool = meta3 && isRecord12(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
+  const meta3 = isRecord13(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord13(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
   return tool && typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
 }
 function errorText(error53) {
@@ -23357,7 +23712,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord12(error53) || error53.code !== "ESRCH")
+    if (!isRecord13(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
@@ -23400,6 +23755,10 @@ function transportEvent(update, metadata) {
   const subagent = grokSubagentEventFromUpdate(extension);
   if (subagent)
     return subagent;
+  if (extension.sessionUpdate === "interaction_resolved") {
+    const toolCallId = extension.tool_call_id ?? extension.toolCallId;
+    return typeof toolCallId === "string" && toolCallId.trim().length > 0 ? { type: "interaction.resolved", toolCallId, ...metadata ? { metadata } : {} } : null;
+  }
   switch (update.sessionUpdate) {
     case "user_message_chunk":
     case "agent_message_chunk":
@@ -23467,7 +23826,7 @@ async function readNativeSignals(options, sessionId) {
   }
 }
 function isMissingFile(error53) {
-  return isRecord12(error53) && error53.code === "ENOENT";
+  return isRecord13(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
@@ -23490,7 +23849,7 @@ async function locateGrokNativeSession(options, sessionId) {
     try {
       summaryRaw = await readFile3(path12.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
-      if (isMissingFile(error53) || isRecord12(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord13(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -23502,10 +23861,10 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord12(parsed))
+    if (!isRecord13(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord12(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
+    const cwd = isRecord13(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
     const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path12.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
@@ -23538,12 +23897,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord12(record2) || !isRecord12(record2.params))
+    if (!isRecord13(record2) || !isRecord13(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord12(params.update))
+    if (params.sessionId !== sessionId || !isRecord13(params.update))
       continue;
-    const metadata = isRecord12(params._meta) ? params._meta : void 0;
+    const metadata = isRecord13(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -23557,6 +23916,8 @@ var GrokAcpTransport = class {
   #child = null;
   #closed = false;
   #closing = false;
+  #closePromise = null;
+  #permissionConfirmation = null;
   #connection = null;
   #initialize = null;
   #replay = null;
@@ -23605,7 +23966,7 @@ var GrokAcpTransport = class {
     if (!this.#connection)
       throw new GrokTransportError("unavailable", "Grok ACP is unavailable");
     const result = await withTimeout(this.#connection.request("_x.ai/session/usage", { sessionId: this.sessionId }), this.#options.commandTimeoutMs, "Grok Session usage");
-    return isRecord12(result) ? result.usage : void 0;
+    return isRecord13(result) ? result.usage : void 0;
   }
   async readHistory(sessionId, cwd = this.#options.cwd) {
     return readGrokNativeHistory({ ...this.#options, cwd }, sessionId);
@@ -23756,7 +24117,11 @@ var GrokAcpTransport = class {
     const invocation = grokInvocation(executable, process.platform, this.#startupModelId);
     const child = spawn(invocation.command, invocation.arguments, {
       cwd: this.#options.cwd,
-      env: { ...process.env, ...this.#options.environment },
+      env: {
+        ...process.env,
+        ...this.#options.environment,
+        RUST_LOG: grokPermissionLogFilter(this.#options.environment?.RUST_LOG ?? process.env.RUST_LOG)
+      },
       detached: process.platform !== "win32",
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
@@ -23765,6 +24130,7 @@ var GrokAcpTransport = class {
     this.#child = child;
     child.stderr.on("data", (chunk) => {
       this.#stderrTail = sanitizeDiagnosticTail(`${this.#stderrTail}${chunk.toString()}`);
+      this.#permissionConfirmation?.accept(chunk.toString());
     });
     await withTimeout(new Promise((resolve, reject) => {
       child.once("spawn", resolve);
@@ -23774,7 +24140,8 @@ var GrokAcpTransport = class {
     const connection = new ClientSideConnection(() => ({
       sessionUpdate: (params) => this.#handleUpdate(params),
       requestPermission: (params) => this.#handlePermission(params),
-      extNotification: (method, params) => this.#handleExtensionNotification(method, params)
+      extNotification: (method, params) => this.#handleExtensionNotification(method, params),
+      extMethod: (method, params) => this.#handleExtMethod(method, params)
     }), stream);
     this.#connection = connection;
     child.once("error", (error53) => this.#fault(new GrokTransportError("processExited", error53.message)));
@@ -23794,14 +24161,16 @@ var GrokAcpTransport = class {
     this.#initialize = initialize;
     return initialize;
   }
-  async runTurn(text, onEvent, onPermission) {
+  async runTurn(text, onEvent, onPermission, onQuestion = async () => ({ outcome: "cancelled" })) {
     const connection = this.#connection;
     if (!connection || !this.#sessionId || this.#closed || this.#closing) {
       throw new GrokTransportError("unavailable", "Grok ACP Session is unavailable");
     }
     if (this.#activePrompt)
       throw new Error("Grok ACP Session already has an active Prompt");
-    const active = { onEvent, onPermission };
+    if (this.#permissionConfirmation)
+      throw new GrokTransportError("unavailable", "Grok ACP Session has an active operation");
+    const active = { onEvent, onPermission, onQuestion };
     this.#activePrompt = active;
     try {
       return await connection.prompt({
@@ -23819,7 +24188,7 @@ var GrokAcpTransport = class {
     if (!connection || !this.#sessionId || this.#closed || this.#closing) {
       throw new GrokTransportError("unavailable", "Grok ACP Session is unavailable");
     }
-    if (this.#activePrompt || this.#activeCompact) {
+    if (this.#activePrompt || this.#activeCompact || this.#permissionConfirmation) {
       throw new GrokTransportError("unavailable", "Grok ACP Session already has an active operation");
     }
     const active = { onEvent, cancellationRequested: false };
@@ -23852,13 +24221,15 @@ var GrokAcpTransport = class {
     const connection = this.#connection;
     if (!connection || !this.#sessionId)
       throw new Error("Grok ACP Session is unavailable");
+    if (this.#permissionConfirmation)
+      throw new GrokTransportError("unavailable", "Grok ACP Session has an active operation");
     const response = await connection.request("session/set_model", {
       sessionId: this.#sessionId,
       modelId,
       ...reasoningEffort ? { reasoningEffort } : {},
       ...contextWindowTokens !== void 0 ? { _meta: { contextWindow: contextWindowTokens } } : {}
     });
-    if (!isRecord12(response) || !isRecord12(response._meta) || !isRecord12(response._meta.model)) {
+    if (!isRecord13(response) || !isRecord13(response._meta) || !isRecord13(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -23875,14 +24246,57 @@ var GrokAcpTransport = class {
       this.#activeCompact.cancellationRequested = true;
     return connection.cancel({ sessionId: this.#sessionId });
   }
-  async close() {
+  async setPermissionMode(permissionModeId) {
+    const mode = decodeGrokPermissionModeId(permissionModeId);
+    const connection = this.#connection;
+    const sessionId = this.#sessionId;
+    if (!connection || !sessionId || this.#closed || this.#closing) {
+      throw new GrokTransportError("unavailable", "Grok ACP Session is unavailable");
+    }
+    if (this.#activePrompt || this.#activeCompact || this.#permissionConfirmation) {
+      throw new GrokTransportError("unavailable", "Grok ACP Session has an active operation");
+    }
+    const confirmation = new GrokPermissionConfirmation(mode);
+    this.#permissionConfirmation = confirmation;
+    try {
+      await withTimeout(Promise.all([
+        confirmation.completed,
+        (async () => {
+          const flags = grokPermissionModeSessionMeta(mode);
+          await connection.notify(GROK_PERMISSION_MODE_METHOD, {
+            yolo_mode: flags.yoloMode,
+            auto_mode: flags.autoMode,
+            permission_mode: mode
+          });
+          const response = await connection.request("_x.ai/session/info", { sessionId });
+          if (!isRecord13(response) || !isRecord13(response.result) || response.result.sessionId !== sessionId) {
+            throw new Error("Grok did not confirm the target Session");
+          }
+        })()
+      ]), this.#options.commandTimeoutMs, "Grok Permission Mode confirmation");
+      if (this.#closed || this.#closing)
+        throw new Error("Grok Session closed during configuration");
+    } catch (cause) {
+      const error53 = new GrokTransportError("protocolError", "Grok Permission Mode could not be confirmed; reopen the Session to continue", { cause });
+      this.#fault(error53);
+      await this.close();
+      throw error53;
+    } finally {
+      this.#permissionConfirmation = null;
+    }
+  }
+  close() {
+    return this.#closePromise ??= this.#close();
+  }
+  async #close() {
     if (this.#closed)
       return;
     this.#closing = true;
+    this.#permissionConfirmation?.reject(new Error("Grok Session closed during configuration"));
     const child = this.#child;
     const connection = this.#connection;
     if (connection && this.#sessionId && this.#initialize?.agentCapabilities?.sessionCapabilities?.close) {
-      await connection.closeSession({ sessionId: this.#sessionId }).catch(() => void 0);
+      await withTimeout(connection.closeSession({ sessionId: this.#sessionId }), this.#options.closeTimeoutMs, "Grok Session close").catch(() => void 0);
     }
     if (child?.stdin.writable)
       child.stdin.end();
@@ -23910,7 +24324,7 @@ var GrokAcpTransport = class {
       this.#availableCommands = parseGrokAvailableCommands(update.availableCommands);
       return;
     }
-    const metadata = isRecord12(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord13(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -23925,7 +24339,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord12(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord13(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -23935,7 +24349,22 @@ var GrokAcpTransport = class {
     }
     return this.#activePrompt.onPermission({ request: params, options: params.options });
   }
+  async #handleExtMethod(method, params) {
+    if (method !== GROK_ASK_USER_QUESTION_METHOD)
+      throw RequestError.methodNotFound(method);
+    let request;
+    try {
+      request = parseGrokQuestionRequest(params);
+    } catch (error53) {
+      throw RequestError.invalidParams(void 0, errorText(error53));
+    }
+    const active = this.#activePrompt;
+    if (!active || this.#closed || this.#closing || this.#replay !== null || this.#activeCompact !== null || request.sessionId !== this.#sessionId)
+      return { outcome: "cancelled" };
+    return { ...await active.onQuestion(request) };
+  }
   #fault(error53) {
+    this.#permissionConfirmation?.reject(error53);
     if (this.#closing || this.#closed)
       return;
     this.#options.onFault?.(error53);
@@ -24066,7 +24495,7 @@ var SessionImportScope = class {
 // dist/session-import.js
 var MAX_METADATA_BYTES = 4 * 1024 * 1024;
 var SUBAGENT_SESSION_KINDS = /* @__PURE__ */ new Set(["subagent", "subagent_resume"]);
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readJson(file2, signal) {
@@ -24079,7 +24508,7 @@ function processAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (error53) {
-    return isRecord13(error53) && error53.code === "EPERM";
+    return isRecord14(error53) && error53.code === "EPERM";
   }
 }
 async function firstUserText(file2, signal) {
@@ -24096,10 +24525,10 @@ async function firstUserText(file2, signal) {
       } catch {
         continue;
       }
-      const update = isRecord13(entry) && isRecord13(entry.params) ? entry.params.update : null;
-      if (!isRecord13(update) || update.sessionUpdate !== "user_message_chunk")
+      const update = isRecord14(entry) && isRecord14(entry.params) ? entry.params.update : null;
+      if (!isRecord14(update) || update.sessionUpdate !== "user_message_chunk")
         continue;
-      const text = isRecord13(update.content) ? update.content.text : null;
+      const text = isRecord14(update.content) ? update.content.text : null;
       return typeof text === "string" ? text : "";
     }
     return null;
@@ -24176,7 +24605,7 @@ var GrokSessionImport = class {
     if (!Array.isArray(entries))
       return active;
     for (const entry of entries) {
-      if (isRecord13(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
+      if (isRecord14(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
         active.add(entry.session_id);
     }
     return active;
@@ -24225,7 +24654,7 @@ var GrokSessionImport = class {
         return null;
       try {
         const summary = await readJson(files[0], signal);
-        if (!isRecord13(summary) || !isRecord13(summary.info) || summary.info.id !== nativeSessionId)
+        if (!isRecord14(summary) || !isRecord14(summary.info) || summary.info.id !== nativeSessionId)
           return null;
         if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
           return null;
@@ -24452,7 +24881,7 @@ var GrokSubagentLifecycle = class {
 };
 
 // dist/grok-models.js
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -24464,7 +24893,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord14(candidate) || !nonBlank(candidate.label))
+    if (!isRecord15(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -24475,7 +24904,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord14(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord15(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -24487,12 +24916,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord14(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord15(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord14(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord15(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (Array.isArray(metadata.contextWindows) && metadata.contextWindows.includes(5e5)) {
       defaultContextWindowTokensByModel.set(ref.data.id, 5e5);
@@ -24531,10 +24960,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord14(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord15(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord14(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord15(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model2 = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model2;
@@ -24558,7 +24987,7 @@ import os6 from "node:os";
 import path14 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -24567,7 +24996,7 @@ function finitePercent(value) {
   return Math.min(100, Math.max(0, value));
 }
 function nonNegativeCentValue(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return void 0;
   const amount = value.val === void 0 ? 0 : value.val;
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
@@ -24591,7 +25020,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord15(entry) || typeof entry.product !== "string")
+    if (!isRecord16(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     const labels = {
@@ -24612,10 +25041,10 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord15(value) || !isRecord15(value.config))
+  if (!isRecord16(value) || !isRecord16(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord15(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord16(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const periodType = periodTypeFrom(period?.type);
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
   let usedPercent = finitePercent(config2.creditUsagePercent);
@@ -24642,11 +25071,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord15(auth))
+  if (!isRecord16(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord15(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord16(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord15(value) || typeof value.key !== "string")
+    if (!isRecord16(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -24717,7 +25146,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -24734,7 +25163,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -24758,7 +25187,7 @@ function usageFromNative(value) {
   }
 }
 function usageFromResponse(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   const buckets = [
     value.input_tokens,
@@ -24787,10 +25216,10 @@ var GrokTurnUsage = class {
   #durationMs = 0;
   #latestCacheHit;
   constructor(base, emptySession = false) {
-    for (const field of summedUsageFields) {
-      const value = base?.[field];
+    for (const field2 of summedUsageFields) {
+      const value = base?.[field2];
       if (value !== void 0)
-        this.#totals[field] = value;
+        this.#totals[field2] = value;
     }
     this.#cacheComplete = base?.sessionCacheUsage !== void 0 || emptySession;
   }
@@ -24829,10 +25258,10 @@ var GrokTurnUsage = class {
     if (usage?.inputTokens === void 0 || usage.cachedInputTokens === void 0)
       this.#cacheComplete = false;
     if (usage) {
-      for (const field of summedUsageFields) {
-        const value = usage[field];
+      for (const field2 of summedUsageFields) {
+        const value = usage[field2];
         if (value !== void 0)
-          this.#totals[field] = (this.#totals[field] ?? 0) + value;
+          this.#totals[field2] = (this.#totals[field2] ?? 0) + value;
       }
       if (duration3 > 0 && usage.outputTokens !== void 0) {
         this.#outputTokens += usage.outputTokens;
@@ -24858,7 +25287,7 @@ var GrokTurnUsage = class {
   }
 };
 function usageFromSignals(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   try {
     return parseHostUsage({
@@ -24878,7 +25307,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -24886,7 +25315,7 @@ function nativeCostTicks(value) {
   return ticks;
 }
 function sessionCostFromNative(value, initialCostUsd) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return void 0;
   if (value.costIsPartial !== void 0 && value.costIsPartial !== false)
     return void 0;
@@ -24915,7 +25344,7 @@ function sessionUsageFromHistory(events) {
       continue;
     const usage = usageFromNative(event.usage);
     const ticks2 = nativeCostTicks(event.usage);
-    const complete = isRecord16(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
+    const complete = isRecord17(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
     latestByKey.set(key, { usage, complete, ...ticks2 !== void 0 ? { ticks: ticks2 } : {} });
   }
   if (latestByKey.size === 0)
@@ -24926,11 +25355,11 @@ function sessionUsageFromHistory(events) {
   for (const entry of latestByKey.values()) {
     if (!entry.usage)
       continue;
-    for (const field of summedUsageFields) {
-      const value = entry.usage[field];
+    for (const field2 of summedUsageFields) {
+      const value = entry.usage[field2];
       if (value === void 0)
         continue;
-      totals2[field] = (totals2[field] ?? 0) + value;
+      totals2[field2] = (totals2[field2] ?? 0) + value;
     }
     if (entry.ticks === void 0)
       continue;
@@ -24969,7 +25398,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord16(update.cost) ? update.cost : null;
+      const cost = isRecord17(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -25009,7 +25438,7 @@ function capabilitiesForModels(modelState) {
       selectModel: modelState.catalog.models.length > 0,
       selectThinkingOption: modelState.catalog.thinkingOptions.length > 0,
       selectPermissionMode: true,
-      permissionModeScope: "atCreate"
+      permissionModeScope: "live"
     },
     history: { fork: true, forkAcrossCwd: true, rollbackLastTurn: true },
     subagents: { observe: true, readTranscript: true }
@@ -25163,6 +25592,8 @@ var GrokHarnessSession = class {
       return { ok: false, error: invalidState("Grok Session is not open") };
     if ("commandId" in command)
       return this.#executeHarnessCommand(command);
+    if (command.type === "turn.steer")
+      return unsupportedSteer("Grok");
     if (command.type === "turn.cancel")
       return this.#cancel(command);
     if (command.type === "interaction.respond")
@@ -25205,6 +25636,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command,
+      questions: new GrokQuestions(command.turnId, this.#randomUUID, (output) => this.#channel.emit(output)),
       usage: new GrokTurnUsage(this.#usage, this.#snapshot.turns.length === 0),
       agent: null,
       agentMessageId: null,
@@ -25226,7 +25658,7 @@ var GrokHarnessSession = class {
     };
     this.#active = active;
     this.#event({ type: "turn.started", turnId: command.turnId });
-    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request)).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
+    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request), (request) => this.#active === active && this.#phase === "open" && !active.cancellationRequested ? active.questions.ask(request) : Promise.resolve({ outcome: "cancelled" })).finally(() => active.questions.cancel()).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
       status: "failed",
       error: normalizeError(error53, "nativeFailure")
     }));
@@ -25295,6 +25727,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command: { type: "turn.start", turnId: command.turnId, input: [] },
+      questions: new GrokQuestions(command.turnId, this.#randomUUID, (output) => this.#channel.emit(output)),
       agent: null,
       agentMessageId: null,
       rawAgentText: "",
@@ -25442,14 +25875,29 @@ var GrokHarnessSession = class {
         }
       };
     }
-    return {
-      ok: false,
-      error: {
-        code: "invalidRequest",
-        message: "Grok Permission Mode is fixed at Session creation",
-        retryable: false
-      }
-    };
+    if (this.#active || this.#configuring) {
+      return {
+        ok: false,
+        error: {
+          code: "sessionBusy",
+          message: "Grok Session cannot configure permissions during another operation",
+          retryable: true
+        }
+      };
+    }
+    this.#configuring = true;
+    try {
+      await this.#transport.setPermissionMode(command.permissionModeId);
+      if (this.#phase !== "open")
+        return { ok: false, error: invalidState("Grok Session is closed") };
+      this.#state = { ...this.#state, effectivePermissionModeId: command.permissionModeId };
+      this.#event({ type: "session.state.changed", state: this.#state });
+      return { ok: true, value: { completed: true } };
+    } catch (error53) {
+      return { ok: false, error: normalizeError(error53, "nativeFailure") };
+    } finally {
+      this.#configuring = false;
+    }
   }
   async #cancel(command) {
     const active = this.#active;
@@ -25459,6 +25907,7 @@ var GrokHarnessSession = class {
     if (active.cancellationRequested)
       return { ok: true, value: { cancellationRequested: true } };
     active.cancellationRequested = true;
+    active.questions.cancel();
     for (const approval of active.approvals.values()) {
       approval.resolve({ outcome: { outcome: "cancelled" } });
     }
@@ -25471,9 +25920,11 @@ var GrokHarnessSession = class {
   }
   async #respond(command) {
     const active = this.#active;
+    if (active?.questions.has(command.interactionId))
+      return active.questions.respond(command);
     const pending = active?.approvals.get(command.interactionId);
     if (!active || !pending)
-      return { ok: false, error: invalidState("Grok Approval is not pending") };
+      return { ok: false, error: invalidState("Grok Interaction is not pending") };
     if (command.response.type !== "approval") {
       return {
         ok: false,
@@ -25534,6 +25985,10 @@ var GrokHarnessSession = class {
   #handleEvent(active, event) {
     if (this.#active !== active || this.#phase !== "open")
       return;
+    if (event.type === "interaction.resolved") {
+      active.questions.withdraw(event.toolCallId);
+      return;
+    }
     const requestUsage = active.usage?.observe(event);
     if (requestUsage) {
       this.#publishUsage(requestUsage, active.command.turnId, true);
@@ -25933,6 +26388,7 @@ var GrokHarnessSession = class {
   #finish(active, outcome, usage = null, nativeTurnRef) {
     if (this.#active !== active)
       return;
+    active.questions.cancel();
     const itemOutcome = outcome;
     this.#completeReasoning(active, itemOutcome);
     this.#completeAgent(active, itemOutcome);
@@ -25989,6 +26445,7 @@ var GrokHarnessSession = class {
     const active = this.#active;
     if (active) {
       active.cancellationRequested = true;
+      active.questions.cancel();
       for (const approval of active.approvals.values())
         approval.resolve({ outcome: { outcome: "cancelled" } });
       await this.#transport.cancel().catch(() => void 0);
@@ -26343,6 +26800,7 @@ var GrokAdapter = class {
           ]);
         }
       }
+      await transport.setPermissionMode(initialPermissionModeId);
       const history = await transport.getHistory();
       let initialUsage = input.kind === "resume" || input.kind === "fork" || input.kind === "rollbackLastTurn" ? combineUsage(sessionUsageFromHistory(history), usageFromSignals(opened.signals)) : null;
       if (contextWindow !== void 0 && initialUsage?.contextUsedTokens !== void 0) {