@karlorz/codexhost-cli-win32-arm64 0.13.3-7 → 0.14.0-0

package/app/plugins/grok/plugin.mjs

@@ -581,44 +581,8 @@ function createGrokUsageStatistics(environment) {
 // dist/grok-adapter.js
 import { randomUUID as randomUUID2 } from "node:crypto";
 
-// dist/grok-credential-export.js
+// dist/grok-text-item-id.js
 import { createHash } from "node:crypto";
-import { readFile as readFile2 } from "node:fs/promises";
-import os3 from "node:os";
-import path6 from "node:path";
-async function readGrokCredentials(environment) {
-  if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((v) => v?.trim()))
-    return [];
-  try {
-    const home = environment.GROK_HOME ?? path6.join(environment.HOME ?? os3.homedir(), ".grok");
-    const auth = JSON.parse(await readFile2(path6.join(home, "auth.json"), "utf8"));
-    const client2 = "b1a00492-073a-47ea-816f-4c329264a828";
-    const entry = auth[`https://auth.x.ai::${client2}`] ?? auth["https://auth.x.ai"];
-    if (!entry || entry.oidc_issuer !== "https://auth.x.ai" || entry.oidc_client_id !== client2)
-      return [];
-    if (![entry.key, entry.refresh_token, entry.user_id].every((v) => typeof v === "string" && v.length))
-      return [];
-    const expires = Date.parse(entry.expires_at);
-    if (!Number.isFinite(expires))
-      return [];
-    return [
-      {
-        source: {
-          id: `grok:${createHash("sha256").update(entry.user_id).digest("hex")}`,
-          harnessId: "grok",
-          provider: "xai",
-          label: typeof entry.email === "string" && entry.email ? entry.email : "Grok"
-        },
-        oauth: { access: entry.key, refresh: entry.refresh_token, expires: expires - 3e5 }
-      }
-    ];
-  } catch {
-    return [];
-  }
-}
-
-// dist/grok-adapter.js
-import path18 from "node:path";
 
 // ../../../node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -15271,10 +15235,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({
@@ -15310,7 +15283,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. */
@@ -15350,7 +15323,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),
@@ -15441,6 +15414,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/grok-computer-use/get",
@@ -15518,7 +15493,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(),
@@ -15926,7 +15912,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(),
@@ -16058,6 +16046,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;
@@ -16179,6 +16176,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(),
@@ -16186,6 +16187,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);
@@ -16615,6 +16630,51 @@ var voiceSettingsStateSchema = external_exports.strictObject({
 // ../../shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
+// dist/grok-text-item-id.js
+function grokTextItemId(sessionId, turnIndex, kind, ordinal) {
+  const identity = JSON.stringify([sessionId, turnIndex, kind, ordinal]);
+  return hostItemIdSchema.parse(`grok-text-${createHash("sha256").update(identity).digest("hex")}`);
+}
+
+// dist/grok-credential-export.js
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile2 } from "node:fs/promises";
+import os3 from "node:os";
+import path6 from "node:path";
+async function readGrokCredentials(environment) {
+  if ([environment.XAI_API_KEY, environment.GROK_API_KEY, environment.GROK_TOKEN].some((v) => v?.trim()))
+    return [];
+  try {
+    const home = environment.GROK_HOME ?? path6.join(environment.HOME ?? os3.homedir(), ".grok");
+    const auth = JSON.parse(await readFile2(path6.join(home, "auth.json"), "utf8"));
+    const client2 = "b1a00492-073a-47ea-816f-4c329264a828";
+    const entry = auth[`https://auth.x.ai::${client2}`] ?? auth["https://auth.x.ai"];
+    if (!entry || entry.oidc_issuer !== "https://auth.x.ai" || entry.oidc_client_id !== client2)
+      return [];
+    if (![entry.key, entry.refresh_token, entry.user_id].every((v) => typeof v === "string" && v.length))
+      return [];
+    const expires = Date.parse(entry.expires_at);
+    if (!Number.isFinite(expires))
+      return [];
+    return [
+      {
+        source: {
+          id: `grok:${createHash2("sha256").update(entry.user_id).digest("hex")}`,
+          harnessId: "grok",
+          provider: "xai",
+          label: typeof entry.email === "string" && entry.email ? entry.email : "Grok"
+        },
+        oauth: { access: entry.key, refresh: entry.refresh_token, expires: expires - 3e5 }
+      }
+    ];
+  } catch {
+    return [];
+  }
+}
+
+// dist/grok-adapter.js
+import path18 from "node:path";
+
 // ../../harness-plugin-files/dist/grok-computer-use.js
 import { randomUUID } from "node:crypto";
 import { access, mkdir as mkdir2, readFile as readFile3, rename, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
@@ -16995,6 +17055,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",
@@ -17022,6 +17094,7 @@ var usageFields = /* @__PURE__ */ new Set([
   ...safeIntegerFields,
   ...percentFields,
   "sessionCacheUsage",
+  "composerIndicators",
   "totalCostUsd",
   "totalCredits",
   "contextUsagePercent",
@@ -17044,6 +17117,7 @@ function parseHostUsage(value) {
       throw new Error(`Harness Usage contains unknown field '${key}'`);
     }
   }
+  const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
   for (const field of [
     "totalCredits",
     "contextUsagePercent",
@@ -17114,9 +17188,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",
@@ -22924,7 +22998,11 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
   let nativePromptIndex = 0;
   let currentPromptIndex = null;
   let agent = null;
+  let agentMessageId;
+  let agentIndex = 0;
   let reasoning = null;
+  let reasoningMessageId;
+  let reasoningIndex = 0;
   const tools = /* @__PURE__ */ new Map();
   const generatedImages = /* @__PURE__ */ new Map();
   const mediaRoots = grokMediaResolveRoots(cwd, sessionDirectory);
@@ -23122,6 +23200,8 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
     });
     turnIndex += 1;
     messageIndex = 0;
+    agentIndex = 0;
+    reasoningIndex = 0;
     nativeTurnKey = null;
     currentPromptIndex = null;
     input = "";
@@ -23135,6 +23215,8 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
       });
       turnIndex = turns.length;
       messageIndex = 0;
+      agentIndex = 0;
+      reasoningIndex = 0;
       nativeTurnKey = null;
       nativePromptIndex = event.targetPromptIndex;
       currentPromptIndex = null;
@@ -23199,20 +23281,28 @@ function mapGrokReplay(replay, harnessId, sessionId, cwd, knownTurnRefs = [], to
         outcome
       });
     } else if (event.type === "agent.text") {
+      if (agent && agentMessageId !== event.messageId)
+        completeAgent();
       if (!agent) {
         completeReasoning();
+        agentMessageId = event.messageId;
+        ++messageIndex;
         agent = {
           type: "agentMessage",
-          itemId: stableId("message", turnIndex, ++messageIndex),
+          itemId: grokTextItemId(sessionId, turnIndex, "agentMessage", ++agentIndex),
           text: ""
         };
       }
       agent = { ...agent, text: agent.text + event.text };
     } else if (event.type === "agent.thought") {
+      if (reasoning && reasoningMessageId !== event.messageId)
+        completeReasoning();
       if (!reasoning) {
+        reasoningMessageId = event.messageId;
+        ++messageIndex;
         reasoning = {
           type: "reasoning",
-          itemId: stableId("reasoning", turnIndex, ++messageIndex),
+          itemId: grokTextItemId(sessionId, turnIndex, "reasoning", ++reasoningIndex),
           text: ""
         };
       }
@@ -24023,6 +24113,53 @@ function grokCodexhostSessionMeta(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/acp-transport.js
 var GrokTransportError = class extends Error {
   kind;
@@ -24307,6 +24444,8 @@ var GrokAcpTransport = class {
   #child = null;
   #closed = false;
   #closing = false;
+  #closePromise = null;
+  #permissionConfirmation = null;
   #connection = null;
   #initialize = null;
   #replay = null;
@@ -24507,7 +24646,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,
@@ -24516,6 +24659,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);
@@ -24553,6 +24697,8 @@ var GrokAcpTransport = class {
     }
     if (this.#activePrompt)
       throw new Error("Grok ACP Session already has an active Prompt");
+    if (this.#permissionConfirmation)
+      throw new GrokTransportError("unavailable", "Grok ACP Session has an active operation");
     const active = { onEvent, onPermission, onElicitation };
     this.#activePrompt = active;
     try {
@@ -24571,7 +24717,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 };
@@ -24604,6 +24750,8 @@ 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,
@@ -24631,14 +24779,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 (!isRecord14(response) || !isRecord14(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();
@@ -24708,6 +24899,7 @@ var GrokAcpTransport = class {
     return { ...await this.#activePrompt.onElicitation(parsed.request) };
   }
   #fault(error53) {
+    this.#permissionConfirmation?.reject(error53);
     if (this.#closing || this.#closed)
       return;
     this.#options.onFault?.(error53);
@@ -25781,7 +25973,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 }
@@ -25935,6 +26127,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")
@@ -25977,6 +26171,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command,
+      textIdentity: { turnIndex: this.#snapshot.turns.length, agentMessage: 0, reasoning: 0 },
       usage: new GrokTurnUsage(this.#usage, this.#snapshot.turns.length === 0),
       agent: null,
       agentMessageId: null,
@@ -26068,6 +26263,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command: { type: "turn.start", turnId: command.turnId, input: [] },
+      textIdentity: { turnIndex: this.#snapshot.turns.length, agentMessage: 0, reasoning: 0 },
       agent: null,
       agentMessageId: null,
       rawAgentText: "",
@@ -26216,14 +26412,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;
@@ -26475,7 +26686,7 @@ var GrokHarnessSession = class {
     if (!active.agent) {
       active.agent = {
         type: "agentMessage",
-        itemId: hostItemIdSchema.parse(this.#randomUUID()),
+        itemId: grokTextItemId(this.#transport.sessionId, active.textIdentity.turnIndex, "agentMessage", ++active.textIdentity.agentMessage),
         text: ""
       };
       active.rawAgentText = "";
@@ -26507,7 +26718,7 @@ var GrokHarnessSession = class {
     if (!active.reasoning) {
       active.reasoning = {
         type: "reasoning",
-        itemId: hostItemIdSchema.parse(this.#randomUUID()),
+        itemId: grokTextItemId(this.#transport.sessionId, active.textIdentity.turnIndex, "reasoning", ++active.textIdentity.reasoning),
         text: ""
       };
       this.#event({ type: "item.started", turnId: active.command.turnId, item: active.reasoning });
@@ -27220,6 +27431,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) {