@co0ontty/wand 4.7.1 → 4.8.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "b9e0ce7ddfbbf2b457b63913046f620bac942e54",
-  "builtAt": "2026-07-16T17:50:19.552Z",
-  "version": "4.7.1",
+  "commit": "8688b5cf30adc66cff2a50d9cfa34a6b1b9a4adc",
+  "builtAt": "2026-07-17T00:33:01.780Z",
+  "version": "4.8.0",
   "channel": "stable"
 }

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { CardExpandDefaults, ExecutionMode, WandConfig } from "./types.js";
+import { CardExpandDefaults, ExecutionMode, SessionProvider, WandConfig } from "./types.js";
 import type { WandStorage } from "./storage.js";
 /**
  * 通过 UI 设置面板可改的"用户偏好"字段。这些字段从 SQLite app_config 表读取，
@@ -49,5 +49,5 @@ export declare function getProviderDefaultModels(config: Pick<WandConfig, "defau
     codex: string;
     opencode: string;
 };
-export declare function getDefaultModelForProvider(config: Pick<WandConfig, "defaultModel" | "defaultCodexModel" | "defaultOpenCodeModel">, provider: "claude" | "codex" | "opencode" | undefined): string;
+export declare function getDefaultModelForProvider(config: Pick<WandConfig, "defaultModel" | "defaultCodexModel" | "defaultOpenCodeModel">, provider: SessionProvider | undefined): string;
 export declare function normalizeMode(input: string | undefined, fallback: ExecutionMode): ExecutionMode;

package/dist/config.js

@@ -280,7 +280,7 @@ export function applyStoragePreferences(config, storage) {
     const defaults = defaultConfig();
     if (storage.hasPreference(preferenceStorageKey("defaultProvider"))) {
         const v = storage.getPreference(preferenceStorageKey("defaultProvider"), defaults.defaultProvider ?? "claude");
-        if (v === "claude" || v === "codex" || v === "opencode")
+        if (v === "claude" || v === "codex" || v === "opencode" || v === "grok")
             config.defaultProvider = v;
     }
     if (storage.hasPreference(preferenceStorageKey("defaultSessionKind"))) {
@@ -363,7 +363,7 @@ export function writePreferenceToStorage(config, storage, key, value, options =
     const dbKey = preferenceStorageKey(key);
     switch (key) {
         case "defaultProvider": {
-            if (value !== "claude" && value !== "codex" && value !== "opencode")
+            if (value !== "claude" && value !== "codex" && value !== "opencode" && value !== "grok")
                 throw new Error(`无效 Provider: ${value}`);
             storage.setPreference(dbKey, value);
             config.defaultProvider = value;
@@ -628,7 +628,7 @@ function mergeWithDefaults(input) {
         android: normalizeAndroidApkConfig(input.android) ?? defaults.android,
         macos: normalizeMacosDmgConfig(input.macos) ?? defaults.macos,
         cardDefaults: normalizeCardDefaults(input.cardDefaults),
-        defaultProvider: input.defaultProvider === "codex" || input.defaultProvider === "opencode" ? input.defaultProvider : "claude",
+        defaultProvider: input.defaultProvider === "codex" || input.defaultProvider === "opencode" || input.defaultProvider === "grok" ? input.defaultProvider : "claude",
         defaultSessionKind: input.defaultSessionKind === "pty" ? "pty" : "structured",
         defaultModel: typeof input.defaultModel === "string" ? input.defaultModel.trim() : defaults.defaultModel,
         defaultCodexModel: typeof input.defaultCodexModel === "string" ? input.defaultCodexModel.trim() : defaults.defaultCodexModel,
@@ -653,7 +653,7 @@ export function getProviderDefaultModels(config) {
 }
 export function getDefaultModelForProvider(config, provider) {
     const defaults = getProviderDefaultModels(config);
-    return provider === "codex" ? defaults.codex : provider === "opencode" ? defaults.opencode : defaults.claude;
+    return provider === "codex" ? defaults.codex : provider === "opencode" ? defaults.opencode : provider === "grok" ? "" : defaults.claude;
 }
 export function normalizeMode(input, fallback) {
     return isExecutionMode(input) ? input : fallback;

package/dist/path-repair.js

@@ -6,7 +6,7 @@ import path from "node:path";
 import process from "node:process";
 import { spawn, spawnSync } from "node:child_process";
 /** 关键的 CLI 工具，会被诊断输出。 */
-const PROBE_COMMANDS = ["claude", "codex", "opencode"];
+const PROBE_COMMANDS = ["claude", "codex", "opencode", "grok"];
 const DEEP_PROBE_TIMEOUT_MS = 4000;
 /**
  * 构造候选 bin 目录列表（按优先级，前面的更可信）。
@@ -27,6 +27,7 @@ function candidateBinDirs() {
         path.join(home, ".local", "bin"),
         path.join(home, "bin"),
         path.join(home, ".bun", "bin"),
+        path.join(home, ".grok", "bin"),
         path.join(home, ".volta", "bin"),
         path.join(home, ".cargo", "bin"),
         path.join(home, ".deno", "bin"),
@@ -259,7 +260,8 @@ function probeLoginShell(shell, timeoutMs) {
     const script = `printf 'PATH\\x1f%s\\n' "$PATH"; ` +
         `printf 'CLAUDE\\x1f%s\\n' "$(command -v claude 2>/dev/null)"; ` +
         `printf 'CODEX\\x1f%s\\n' "$(command -v codex 2>/dev/null)"; ` +
-        `printf 'OPENCODE\\x1f%s\\n' "$(command -v opencode 2>/dev/null)"`;
+        `printf 'OPENCODE\\x1f%s\\n' "$(command -v opencode 2>/dev/null)"; ` +
+        `printf 'GROK\\x1f%s\\n' "$(command -v grok 2>/dev/null)"`;
     return new Promise((resolve, reject) => {
         const child = spawn(shell, ["-l", "-c", script], {
             env: {
@@ -299,7 +301,7 @@ function probeLoginShell(shell, timeoutMs) {
                     reject(new Error(`login shell exited ${code}: ${stderr.trim().slice(0, 200)}`));
                     return;
                 }
-                const out = { path: "", claude: null, codex: null, opencode: null };
+                const out = { path: "", claude: null, codex: null, opencode: null, grok: null };
                 for (const line of stdout.split("\n")) {
                     const idx = line.indexOf("\x1f");
                     if (idx < 0)
@@ -316,6 +318,8 @@ function probeLoginShell(shell, timeoutMs) {
                         out.codex = val;
                     else if (key === "OPENCODE")
                         out.opencode = val;
+                    else if (key === "GROK")
+                        out.grok = val;
                 }
                 resolve(out);
             });

package/dist/process-manager.js

@@ -22,7 +22,9 @@ import { ProviderHistoryScanner, } from "./provider-history-scanner.js";
 function resolveProviderFromCommand(command) {
     if (/^codex\b/.test(command.trim()))
         return "codex";
-    return /^opencode\b/.test(command.trim()) ? "opencode" : "claude";
+    if (/^opencode\b/.test(command.trim()))
+        return "opencode";
+    return /^grok\b/.test(command.trim()) ? "grok" : "claude";
 }
 /**
  * Tokenize the restricted shell-command subset accepted by the command
@@ -2010,6 +2012,21 @@ export class ProcessManager extends EventEmitter {
             }
             return result;
         }
+        if (provider === "grok") {
+            let result = command;
+            const trimmedModel = model?.trim();
+            if (trimmedModel && trimmedModel !== "default" && !/--model(?:\s|=)/.test(result) && !/(?:^|\s)-m(?:\s|$)/.test(result)) {
+                result += ` --model '${trimmedModel.replace(/'/g, "'\\''")}'`;
+            }
+            const effort = thinkingEffortToOpenCodeVariant(thinkingEffort ?? null);
+            if (effort && !/--(?:reasoning-)?effort(?:\s|=)/.test(result)) {
+                result += ` --effort '${effort.replace(/'/g, "'\\''")}'`;
+            }
+            if ((mode === "managed" || mode === "full-access" || mode === "auto-edit") && !/--(?:always-approve|yolo)(?:\s|$)/.test(result)) {
+                result += " --always-approve";
+            }
+            return result;
+        }
         const isClaudeCmd = /^(?:claude|npx\s+claude|[^\s]+\/claude)(?:\s|$)/.test(command);
         if (!isClaudeCmd)
             return command;

package/dist/server-session-routes.js

@@ -10,6 +10,7 @@ import { getErrorMessage } from "./error-utils.js";
 import { isProviderSessionId } from "./resume-policy.js";
 import { parseBoundedInteger } from "./request-limits.js";
 import { asyncRoute } from "./express-async.js";
+import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
 export function parseExecutionMode(value, fallback) {
     if (value === undefined)
         return fallback;
@@ -311,7 +312,7 @@ function isMergeActionAllowed(snapshot) {
 }
 export function registerSessionRoutes(app, processes, structured, storage, defaultMode, config, sessions, onSessionCreated) {
     const sessionResponseDTO = (snapshot) => {
-        const windowed = windowMessagesForTransport(snapshot.messages ?? [], config.cardDefaults ?? {});
+        const windowed = windowMessagesForTransport(enrichStructuredMessages(snapshot.messages ?? []), config.cardDefaults ?? {});
         return toSessionDetailDTO(snapshot, {
             messages: windowed.messages,
             messageOffset: windowed.messageOffset,
@@ -324,11 +325,11 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
     app.post("/api/structured-sessions", asyncRoute(async (req, res) => {
         const body = req.body;
         try {
-            if (body.provider && body.provider !== "claude" && body.provider !== "codex" && body.provider !== "opencode") {
-                res.status(400).json({ error: "结构化会话当前仅支持 Claude、Codex 或 OpenCode provider。" });
+            if (body.provider && body.provider !== "claude" && body.provider !== "codex" && body.provider !== "opencode" && body.provider !== "grok") {
+                res.status(400).json({ error: "结构化会话当前仅支持 Claude、Codex、OpenCode 或 Grok provider。" });
                 return;
             }
-            const provider = body.provider === "codex" || body.provider === "opencode" ? body.provider : "claude";
+            const provider = body.provider === "codex" || body.provider === "opencode" || body.provider === "grok" ? body.provider : "claude";
             const rawModel = typeof body.model === "string" ? body.model.trim() : "";
             const origin = parseSessionCreationOrigin(body);
             const snapshot = structured.createSession({
@@ -803,7 +804,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const rawBudget = req.query.blockBudget;
             if (typeof rawBudget === "string" && /^\d+$/.test(rawBudget) && Number(rawBudget) > 0) {
                 const blockBudget = parseBoundedInteger(rawBudget, 1, 1, 2_000);
-                const windowed = blockWindowMessagesForTransport(snapshot.messages ?? [], config.cardDefaults ?? {}, blockBudget);
+                const windowed = blockWindowMessagesForTransport(enrichStructuredMessages(snapshot.messages ?? []), config.cardDefaults ?? {}, blockBudget);
                 res.json(toSessionDetailDTO(snapshot, {
                     output: transcriptOutput,
                     messages: windowed.messages,
@@ -815,7 +816,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
                 return;
             }
             // 与 WS init 对齐：只回最近一窗 turn + offset/total，更早的走 /messages 翻页。
-            const windowed = windowMessagesForTransport(snapshot.messages ?? [], config.cardDefaults ?? {});
+            const windowed = windowMessagesForTransport(enrichStructuredMessages(snapshot.messages ?? []), config.cardDefaults ?? {});
             res.json(toSessionDetailDTO(snapshot, {
                 output: transcriptOutput,
                 messages: windowed.messages,
@@ -835,7 +836,7 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(404).json({ error: "未找到该会话，可能已被删除。" });
             return;
         }
-        const all = snapshot.messages ?? [];
+        const all = enrichStructuredMessages(snapshot.messages ?? []);
         const total = all.length;
         // 块级翻页（iOS）：?turn=<i>&blockOffset=<当前 leading 偏移>&blockLimit=<N>
         // 取该 turn 的 [start, blockOffset) 段（start = max(0, blockOffset - blockLimit)）。
@@ -853,8 +854,11 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             const blockLimit = Math.min(Math.max(Number.isFinite(rawBlockLimit) ? rawBlockLimit : 40, 1), 200);
             const blockEnd = Math.min(Math.max(Number.isFinite(rawBlockOffset) ? rawBlockOffset : blockTotal, 0), blockTotal);
             const blockStart = Math.max(0, blockEnd - blockLimit);
-            const blocks = sliceTurnBlocksForTransport(turn, blockStart, blockEnd, config.cardDefaults ?? {});
-            res.json({ turnIndex, blocks, blockOffset: blockStart, blockTotal });
+            const blocks = enrichStructuredMessages([{
+                    ...turn,
+                    content: sliceTurnBlocksForTransport(turn, blockStart, blockEnd, config.cardDefaults ?? {}),
+                }])[0].content;
+            res.json({ wandProtocolVersion: WAND_PROTOCOL_VERSION, turnIndex, blocks, blockOffset: blockStart, blockTotal });
             return;
         }
         const rawLimit = parseInt(String(req.query.limit ?? ""), 10);
@@ -862,8 +866,8 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
         const limit = Math.min(Math.max(Number.isFinite(rawLimit) ? rawLimit : 40, 1), 200);
         const offset = Math.min(Math.max(Number.isFinite(rawOffset) ? rawOffset : 0, 0), total);
         const end = Math.min(offset + limit, total);
-        const slice = truncateMessagesForTransport(all.slice(offset, end), config.cardDefaults ?? {});
-        res.json({ messages: slice, offset, total });
+        const slice = enrichStructuredMessages(truncateMessagesForTransport(all.slice(offset, end), config.cardDefaults ?? {}));
+        res.json({ wandProtocolVersion: WAND_PROTOCOL_VERSION, messages: slice, offset, total });
     });
     app.post("/api/sessions/:id/resume", (req, res) => {
         const sessionId = req.params.id;

package/dist/server.js

@@ -725,6 +725,7 @@ export async function startServer(config, configPath, options = {}) {
                 { label: "Claude Structured", runner: "claude-cli-print" },
                 { label: "Codex Structured", runner: "codex-cli-exec" },
                 { label: "OpenCode Structured", runner: "opencode-cli-run" },
+                { label: "Grok Structured", runner: "grok-cli-headless" },
             ],
             structuredChatPersona,
             cardDefaults: config.cardDefaults,
@@ -950,7 +951,9 @@ export async function startServer(config, configPath, options = {}) {
                 ? "codex"
                 : body.provider === "opencode" || /^opencode\b/.test(body.command.trim())
                     ? "opencode"
-                    : "claude";
+                    : body.provider === "grok" || /^grok\b/.test(body.command.trim())
+                        ? "grok"
+                        : "claude";
             const effectiveModel = rawModel || getDefaultModelForProvider(config, provider) || undefined;
             const reqCols = typeof body.cols === "number" && Number.isFinite(body.cols) ? body.cols : undefined;
             const reqRows = typeof body.rows === "number" && Number.isFinite(body.rows) ? body.rows : undefined;

package/dist/session-transport.d.ts

@@ -6,6 +6,7 @@ export interface SessionListItemDTO extends SessionBaseDTO {
     output: "";
 }
 export interface SessionDetailDTO extends SessionBaseDTO {
+    wandProtocolVersion: number;
     output: string;
     outputOffset: number;
     outputTotal: number;

package/dist/session-transport.js

@@ -1,3 +1,4 @@
+import { enrichStructuredMessages, WAND_PROTOCOL_VERSION } from "./structured-client-protocol.js";
 export const SESSION_TRANSPORT_OUTPUT_LIMIT = 200_000;
 /** Explicit allow-list separating the server's session object from its wire DTO. */
 function sessionBase(snapshot) {
@@ -53,11 +54,12 @@ export function toSessionDetailDTO(snapshot, options = {}) {
     const outputOffset = Math.max(0, rawOutput.length - outputLimit);
     return {
         ...sessionBase(snapshot),
+        wandProtocolVersion: WAND_PROTOCOL_VERSION,
         output: outputOffset > 0 ? rawOutput.slice(outputOffset) : rawOutput,
         outputOffset,
         outputTotal: rawOutput.length,
         outputTruncated: outputOffset > 0,
-        ...(options.messages !== undefined ? { messages: options.messages } : {}),
+        ...(options.messages !== undefined ? { messages: enrichStructuredMessages(options.messages) } : {}),
         ...(options.messageOffset !== undefined ? { messageOffset: options.messageOffset } : {}),
         ...(options.messageTotal !== undefined ? { messageTotal: options.messageTotal } : {}),
         ...(options.leadingBlockOffset !== undefined ? { leadingBlockOffset: options.leadingBlockOffset } : {}),

package/dist/storage.js

@@ -169,7 +169,7 @@ function parseQueuedMessages(raw) {
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : undefined;
 }
 function inferSessionProvider(row) {
-    if (row.provider === "claude" || row.provider === "codex" || row.provider === "opencode") {
+    if (row.provider === "claude" || row.provider === "codex" || row.provider === "opencode" || row.provider === "grok") {
         return row.provider;
     }
     if (row.runner === "claude-cli" || row.runner === "claude-cli-print") {
@@ -181,10 +181,14 @@ function inferSessionProvider(row) {
     if (row.runner === "opencode-cli-run") {
         return "opencode";
     }
+    if (row.runner === "grok-cli-headless")
+        return "grok";
     if (/^codex\b/i.test(row.command.trim()))
         return "codex";
     if (/^opencode\b/i.test(row.command.trim()))
         return "opencode";
+    if (/^grok\b/i.test(row.command.trim()))
+        return "grok";
     return /^claude\b/i.test(row.command.trim()) ? "claude" : undefined;
 }
 function parseWorktreeInfo(raw) {

package/dist/structured-client-protocol.d.ts

@@ -0,0 +1,7 @@
+import type { ConversationTurn } from "./types.js";
+export declare const WAND_PROTOCOL_VERSION = 2;
+/**
+ * Add Wand-owned semantics without mutating persisted provider blocks.
+ * This is the external interface consumed by every client.
+ */
+export declare function enrichStructuredMessages(messages: ConversationTurn[]): ConversationTurn[];

package/dist/structured-client-protocol.js

@@ -0,0 +1,168 @@
+export const WAND_PROTOCOL_VERSION = 2;
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function text(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function arrayValue(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value !== "string" || !value.trimStart().startsWith("["))
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function questionsFromInput(input) {
+    const rawQuestions = arrayValue(input.questions) ?? [];
+    const questions = [];
+    for (const rawQuestion of rawQuestions) {
+        const question = record(rawQuestion);
+        if (!question)
+            continue;
+        const options = (arrayValue(question.options) ?? []).flatMap((rawOption, index) => {
+            const option = record(rawOption);
+            if (!option)
+                return [];
+            return [{
+                    label: text(option.label) ?? `选项 ${index + 1}`,
+                    ...(text(option.description) ? { description: text(option.description) } : {}),
+                }];
+        });
+        if (options.length === 0)
+            continue;
+        questions.push({
+            question: text(question.question) ?? "",
+            ...(text(question.header) ? { header: text(question.header) } : {}),
+            multiSelect: question.multiSelect === true,
+            options,
+        });
+    }
+    return questions;
+}
+function toolResultText(block) {
+    if (block.type !== "tool_result")
+        return "";
+    if (typeof block.content === "string")
+        return block.content;
+    return block.content.map((part) => text(part.text) ?? "").join("");
+}
+function tasksFromSegment(messages, start, end) {
+    let latestTodoWrite = null;
+    let targetId = null;
+    const resultByToolId = new Map();
+    for (let i = start; i < end; i++) {
+        for (const block of messages[i]?.content ?? []) {
+            if (block.type === "tool_result")
+                resultByToolId.set(block.tool_use_id, toolResultText(block));
+            if (block.type === "tool_use" && ["TodoWrite", "TaskCreate", "TaskUpdate", "TaskList"].includes(block.name)) {
+                targetId = block.id;
+                if (block.name === "TodoWrite")
+                    latestTodoWrite = block;
+            }
+        }
+    }
+    if (latestTodoWrite) {
+        const todos = arrayValue(latestTodoWrite.input.todos) ?? arrayValue(latestTodoWrite.input.plan) ?? [];
+        const items = todos.flatMap((rawTodo, index) => {
+            const todo = record(rawTodo);
+            if (!todo)
+                return [];
+            return [{
+                    id: text(todo.id) ?? String(index + 1),
+                    content: text(todo.content) ?? text(todo.subject) ?? "",
+                    status: text(todo.status) ?? "pending",
+                    ...(text(todo.activeForm) ? { activeForm: text(todo.activeForm) } : {}),
+                }];
+        });
+        return { items, targetId: latestTodoWrite.id };
+    }
+    const tasks = new Map();
+    let fallbackId = 0;
+    let sawTaskTool = false;
+    for (let i = start; i < end; i++) {
+        for (const block of messages[i]?.content ?? []) {
+            if (block.type !== "tool_use")
+                continue;
+            if (block.name === "TaskCreate") {
+                sawTaskTool = true;
+                fallbackId++;
+                const match = resultByToolId.get(block.id)?.match(/#([^\s]+)/);
+                const id = match?.[1] ?? String(fallbackId);
+                tasks.set(id, {
+                    id,
+                    content: text(block.input.subject) ?? text(block.input.description) ?? `Task #${id}`,
+                    status: "pending",
+                    ...(text(block.input.activeForm) ? { activeForm: text(block.input.activeForm) } : {}),
+                });
+            }
+            else if (block.name === "TaskUpdate") {
+                sawTaskTool = true;
+                const id = String(block.input.taskId ?? "");
+                if (!id)
+                    continue;
+                const previous = tasks.get(id) ?? { id, content: `Task #${id}`, status: "pending" };
+                tasks.set(id, {
+                    ...previous,
+                    ...(text(block.input.subject) ? { content: text(block.input.subject) } : {}),
+                    ...(text(block.input.status) ? { status: text(block.input.status) } : {}),
+                    ...(text(block.input.activeForm) ? { activeForm: text(block.input.activeForm) } : {}),
+                });
+            }
+        }
+    }
+    return {
+        items: sawTaskTool ? [...tasks.values()].filter((task) => task.status !== "deleted") : [],
+        targetId,
+    };
+}
+/**
+ * Add Wand-owned semantics without mutating persisted provider blocks.
+ * This is the external interface consumed by every client.
+ */
+export function enrichStructuredMessages(messages) {
+    const enriched = messages.map((turn) => ({
+        ...turn,
+        content: turn.content.map((block) => {
+            if (block.type !== "tool_use" || block.name !== "AskUserQuestion")
+                return block;
+            const questions = questionsFromInput(block.input);
+            return questions.length > 0
+                ? { ...block, semantic: { kind: "question_request", questions } }
+                : block;
+        }),
+    }));
+    let segmentStart = 0;
+    for (let i = 0; i <= enriched.length; i++) {
+        const startsNextSegment = i === enriched.length
+            || (i > segmentStart && enriched[i]?.role === "user"
+                && enriched[i].content.some((block) => block.type === "text"));
+        if (!startsNextSegment)
+            continue;
+        const { items, targetId } = tasksFromSegment(enriched, segmentStart, i);
+        if (targetId && items.length > 0) {
+            for (let turnIndex = i - 1; turnIndex >= segmentStart; turnIndex--) {
+                const blockIndex = enriched[turnIndex].content.findIndex((block) => block.type === "tool_use" && block.id === targetId);
+                if (blockIndex < 0)
+                    continue;
+                const block = enriched[turnIndex].content[blockIndex];
+                if (block.type === "tool_use") {
+                    enriched[turnIndex].content[blockIndex] = {
+                        ...block,
+                        semantic: { kind: "task_list", items },
+                    };
+                }
+                break;
+            }
+        }
+        segmentStart = i;
+    }
+    return enriched;
+}

package/dist/structured-grok-adapter.d.ts

@@ -0,0 +1,12 @@
+import { spawn } from "node:child_process";
+import type { StructuredRunnerAdapter, StructuredRunnerContext, StructuredRunnerExecution, StructuredRunnerObserver, StructuredRunnerTurnState } from "./structured-runner.js";
+import type { SessionSnapshot } from "./types.js";
+export type GrokTurnState = StructuredRunnerTurnState;
+export declare function buildGrokArgs(session: SessionSnapshot, prompt: string): string[];
+/** Apply one official Grok Build `streaming-json` event. */
+export declare function applyGrokEvent(state: GrokTurnState, event: Record<string, unknown>): string | null;
+export declare class GrokRunner implements StructuredRunnerAdapter {
+    private readonly spawnProcess;
+    constructor(spawnProcess?: typeof spawn);
+    start(context: StructuredRunnerContext, observer: StructuredRunnerObserver): StructuredRunnerExecution;
+}

package/dist/structured-grok-adapter.js

@@ -0,0 +1,156 @@
+import { spawn } from "node:child_process";
+import { thinkingEffortToGrokEffort } from "./structured-provider-common.js";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function buildGrokArgs(session, prompt) {
+    const args = ["--no-auto-update", "-p", prompt, "--output-format", "streaming-json"];
+    const model = session.selectedModel?.trim();
+    if (model && model !== "default")
+        args.push("--model", model);
+    const effort = thinkingEffortToGrokEffort(session.thinkingEffort);
+    if (effort)
+        args.push("--effort", effort);
+    if (session.autoApprovePermissions === true
+        || session.mode === "full-access"
+        || session.mode === "managed"
+        || session.mode === "auto-edit") {
+        args.push("--always-approve");
+    }
+    if (session.claudeSessionId)
+        args.push("--resume", session.claudeSessionId);
+    return args;
+}
+/** Apply one official Grok Build `streaming-json` event. */
+export function applyGrokEvent(state, event) {
+    const type = typeof event.type === "string" ? event.type : "";
+    if (type === "text" && typeof event.data === "string" && event.data) {
+        const previous = state.blocks.at(-1);
+        if (previous?.type === "text")
+            previous.text += event.data;
+        else
+            state.blocks.push({ type: "text", text: event.data });
+        state.result += event.data;
+        return null;
+    }
+    if (type === "thought" && typeof event.data === "string" && event.data) {
+        const previous = state.blocks.at(-1);
+        if (previous?.type === "thinking")
+            previous.thinking += event.data;
+        else
+            state.blocks.push({ type: "thinking", thinking: event.data });
+        return null;
+    }
+    if (type === "end") {
+        if (typeof event.sessionId === "string" && event.sessionId)
+            state.sessionId = event.sessionId;
+        const usage = asRecord(event.usage);
+        const modelUsage = asRecord(event.modelUsage);
+        const totalCostUsd = typeof event.total_cost_usd === "number"
+            ? event.total_cost_usd
+            : Object.values(modelUsage ?? {}).reduce((sum, item) => {
+                const cost = asRecord(item)?.costUSD;
+                return sum + (typeof cost === "number" ? cost : 0);
+            }, 0);
+        state.usage = {
+            inputTokens: typeof usage?.input_tokens === "number" ? usage.input_tokens : 0,
+            outputTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : 0,
+            reasoningOutputTokens: typeof usage?.reasoning_tokens === "number" ? usage.reasoning_tokens : 0,
+            cacheReadInputTokens: typeof usage?.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0,
+            ...(totalCostUsd > 0 ? { totalCostUsd } : {}),
+        };
+        return null;
+    }
+    if (type === "error") {
+        return typeof event.message === "string" && event.message ? event.message : "Grok failed";
+    }
+    return null;
+}
+export class GrokRunner {
+    spawnProcess;
+    constructor(spawnProcess = spawn) {
+        this.spawnProcess = spawnProcess;
+    }
+    start(context, observer) {
+        const args = buildGrokArgs(context.session, context.prompt);
+        const spawnedAt = new Date().toISOString();
+        const child = this.spawnProcess("grok", args, {
+            cwd: context.session.cwd,
+            env: context.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const state = {
+            blocks: [],
+            result: "",
+            sessionId: context.session.claudeSessionId,
+            model: context.session.selectedModel ?? context.session.structuredState?.model,
+        };
+        let lineBuffer = "";
+        let stderr = "";
+        let primaryError = null;
+        let settled = false;
+        const finish = (exitCode, signal, spawnError) => ({
+            state, exitCode, signal, stderr, primaryError, ...(spawnError ? { spawnError } : {}),
+        });
+        const processLine = (line) => {
+            if (!observer.isActive())
+                return;
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            try {
+                const event = JSON.parse(trimmed);
+                observer.onEvent?.(event);
+                primaryError = applyGrokEvent(state, event) ?? primaryError;
+                observer.onUpdate(state);
+            }
+            catch { /* Grok diagnostics belong on stderr; ignore non-JSON stdout defensively. */ }
+        };
+        const completion = new Promise((resolve) => {
+            child.stdout?.on("data", (chunk) => {
+                if (!observer.isActive())
+                    return;
+                const text = chunk.toString();
+                observer.onStdout?.(text);
+                lineBuffer += text;
+                const lines = lineBuffer.split("\n");
+                lineBuffer = lines.pop() ?? "";
+                for (const line of lines)
+                    processLine(line);
+            });
+            child.stderr?.on("data", (chunk) => {
+                if (!observer.isActive())
+                    return;
+                const text = chunk.toString();
+                observer.onStderr?.(text);
+                stderr += text;
+            });
+            child.on("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(finish(null, null, error));
+            });
+            child.on("close", (exitCode, signal) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (lineBuffer.trim())
+                    processLine(lineBuffer);
+                resolve(finish(exitCode, signal));
+            });
+        });
+        return {
+            args,
+            spawnedAt,
+            pid: child.pid ?? null,
+            completion,
+            interrupt: () => { try {
+                child.kill("SIGTERM");
+            }
+            catch { /* best effort */ } },
+        };
+    }
+}

package/dist/structured-provider-common.d.ts

@@ -9,3 +9,4 @@ export declare function thinkingEffortToClaudeCliEffort(effort: SessionSnapshot[
 export declare function thinkingEffortToClaudeSlashEffort(effort: SessionSnapshot["thinkingEffort"]): string;
 export declare function thinkingEffortToCodexReasoningEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;
 export declare function thinkingEffortToOpenCodeVariant(effort: SessionSnapshot["thinkingEffort"]): string | null;
+export declare function thinkingEffortToGrokEffort(effort: SessionSnapshot["thinkingEffort"]): string | null;