@prismatic-io/lux 0.0.2-preview.23 → 0.0.2-preview.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/lux",
-  "version": "0.0.2-preview.23",
+  "version": "0.0.2-preview.24",
   "description": "Coding-agent evaluation and improvement with deterministic assertions, optional LLM judges, and first-class human-in-the-loop runs.",
   "license": "MIT",
   "homepage": "https://github.com/prismatic-io/lux",

package/skills/lux-answerer/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lux-answerer
-version: 0.0.2-preview.23
+version: 0.0.2-preview.24
 description: Play the persona for a running Lux orchestrator that uses the claude-code answerer. Read structured events on stdout, decide answers from persona + context, write JSON to its answer channel.
 user-invocable: false
 allowed-tools: Bash, Read

package/src/answerers/persona/index.ts

@@ -75,7 +75,7 @@ const responseInstruction = (interrupt: Interrupt): string => {
     return "Answer the free-text question directly. Output only the answer, without a follow-up question or appended conversation decision.";
   }
   if (interrupt.kind === "approve") {
-    return 'Decide whether the persona approves this exact request. Output only JSON: {"approved":true|false,"reason":"..."}.';
+    return 'Decide whether the persona approves this exact request. Output only JSON, without Markdown fences or surrounding prose: {"approved":true|false,"reason":"..."}.';
   }
   if (isConversationTurnInterrupt(interrupt)) {
     return 'Decide whether the task needs another user reply. Output only {"action":"stop"} if it is complete, blocked on real user-side work outside the chat, or the persona would naturally end the conversation. Never pretend external work happened. Otherwise output only {"action":"reply","text":"<the persona\'s brief reply>"}.';
@@ -224,7 +224,8 @@ const parseApprovalResponse = (
   text: string,
 ): { approved: boolean; reason?: string | undefined } => {
   const trimmed = text.trim();
-  const parsed = PersonaApprovalResponseSchema.safeParse(tryParseJson(trimmed));
+  const fenced = /^```(?:json)?\r?\n([\s\S]*?)\r?\n```$/.exec(trimmed);
+  const parsed = PersonaApprovalResponseSchema.safeParse(tryParseJson(fenced?.[1] ?? trimmed));
   if (parsed.success) return parsed.data;
   return { approved: false, reason: trimmed };
 };

package/src/cli/init-templates.ts

@@ -1,4 +1,11 @@
-type StarterDriver = "subprocess" | "claude-code" | "codex" | "cursor" | "copilot" | "antigravity";
+type StarterDriver =
+  | "subprocess"
+  | "claude-code"
+  | "codex"
+  | "cursor"
+  | "copilot"
+  | "antigravity"
+  | "grok-build";
 
 export const luxConfigBody = (
   withExperiment: boolean,
@@ -22,6 +29,7 @@ export const luxConfigBody = (
       "claude-code": 'reasoningEffort: "low"',
       codex: 'reasoningEffort: "low"',
       cursor: "",
+      "grok-build": 'reasoningEffort: "low", permissionMode: "auto"',
       copilot: 'reasoningEffort: "low"',
       antigravity: 'reasoningEffort: "low"',
     };

package/src/cli/init.ts

@@ -13,7 +13,7 @@ import {
   STARTER_PROMPT_BODY,
 } from "./init-templates.js";
 
-const EXPLICIT_MODEL_DRIVERS = new Set(["cursor", "copilot", "antigravity"]);
+const EXPLICIT_MODEL_DRIVERS = new Set(["cursor", "copilot", "antigravity", "grok-build"]);
 
 const InitOptionsSchema = z
   .object({
@@ -21,7 +21,15 @@ const InitOptionsSchema = z
     force: z.boolean().default(false),
     experiment: z.boolean().default(false),
     driver: z
-      .enum(["subprocess", "claude-code", "codex", "cursor", "copilot", "antigravity"])
+      .enum([
+        "subprocess",
+        "claude-code",
+        "codex",
+        "cursor",
+        "copilot",
+        "antigravity",
+        "grok-build",
+      ])
       .optional(),
     model: z.string().min(1).optional(),
   })

package/src/cli/program.ts

@@ -167,7 +167,15 @@ export const buildCli = () =>
         force: z.boolean().optional().describe("Overwrite existing files"),
         experiment: z.boolean().optional().describe("Also scaffold an optimization campaign"),
         driver: z
-          .enum(["subprocess", "claude-code", "codex", "cursor", "copilot", "antigravity"])
+          .enum([
+            "subprocess",
+            "claude-code",
+            "codex",
+            "cursor",
+            "copilot",
+            "antigravity",
+            "grok-build",
+          ])
           .optional()
           .describe("Starter driver (default: deterministic subprocess)"),
         model: nonEmptyString.optional().describe("Explicit subject model; required for Cursor"),

package/src/core/harness-catalogs/grok-build.ts

@@ -0,0 +1,19 @@
+import { defineHarnessCatalog } from "../harness-catalog.js";
+
+const efforts = ["low", "medium", "high", "xhigh"] as const;
+
+export const grokBuildCatalog = defineHarnessCatalog({
+  driver: "grok-build",
+  verified: "2026-09-24",
+  sources: [
+    "grok 1.0.40: models and ACP initialize modelState",
+    "https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/15-agent-mode.md",
+  ],
+  efforts,
+  models: {
+    "grok-4.7": efforts,
+    "grok-4.7-build-fast": efforts,
+    "grok-4.6": efforts,
+    "grok-4.5": ["low", "medium", "high"],
+  },
+});

package/src/core/harness-catalogs/index.ts

@@ -4,8 +4,16 @@ import { claudeCodeCatalog } from "./claude-code.js";
 import { codexCatalog } from "./codex.js";
 import { copilotCatalog } from "./copilot.js";
 import { cursorCatalog } from "./cursor.js";
+import { grokBuildCatalog } from "./grok-build.js";
 
-export { antigravityCatalog, claudeCodeCatalog, codexCatalog, copilotCatalog, cursorCatalog };
+export {
+  antigravityCatalog,
+  claudeCodeCatalog,
+  codexCatalog,
+  copilotCatalog,
+  cursorCatalog,
+  grokBuildCatalog,
+};
 
 export const builtInHarnessCatalogs = [
   claudeCodeCatalog,
@@ -13,6 +21,7 @@ export const builtInHarnessCatalogs = [
   copilotCatalog,
   cursorCatalog,
   antigravityCatalog,
+  grokBuildCatalog,
 ] as const;
 
 export type BuiltInHarnessCatalog = (typeof builtInHarnessCatalogs)[number];

package/src/drivers/grok-build/README.md

@@ -0,0 +1,112 @@
+# Grok.build driver
+
+The `grok-build` driver runs the native Grok.build CLI over ACP (`grok agent
+--no-leader stdio`). Install Grok.build and run `grok login` first. This is
+separate from selecting a Grok model in the Copilot driver.
+
+```ts
+{
+  defaultDriver: {
+    name: "grok-build",
+    config: {
+      model: "grok-4.5",
+      reasoningEffort: "low",
+      permissionMode: "auto",
+      sandbox: "workspace",
+    },
+  },
+  defaultAnswerer: "persona",
+}
+```
+
+Or scaffold an eval project:
+
+```sh
+lux init --driver grok-build --model grok-4.5
+```
+
+An explicit model is required; effort defaults to `low`. Lux selects both through
+`session/set_config_option` and verifies the returned values before prompting.
+Grok 1.0.40 can choose a different model on `session/new` despite the CLI model
+flag, so passing that flag alone is insufficient.
+
+## Permissions
+
+The default `auto` mode uses Grok's native safety checks, including its LLM
+classifier, to approve routine operations. It is not blanket approval. `default`
+(ask) is also supported. Lux does not expose always-approve, arbitrary extra
+arguments, or the CLI `--allow`/`--deny` flags. In Grok 1.0.40, those rule flags
+are ignored by the agent subcommand. Project permission rules require Grok folder trust. Lux leaves
+`trustProject: false` by default; an untrusted fixture's rules are ignored by
+Grok. Enable `trustProject: true` only for reviewed fixtures: it also permits
+project configuration such as hooks and MCP servers. Then put native rules in
+`.grok/config.toml` and assert the expected denial. CLI `dontAsk` is also omitted because the ACP launch path does not propagate that
+policy.
+
+For example, this native rule denies the smoke test's command:
+
+```toml
+[[permission.rules]]
+action = "deny"
+tool = "bash"
+pattern = "printf *"
+```
+
+Change `action` to `"ask"` to exercise Lux's answerer explicitly. The live
+smoke task opts into trust only for its own generated ask/deny fixtures.
+
+ACP permission requests become Lux `approve` interrupts, including the tool
+call details. The configured answerer handles those requests; `persona` uses an
+LLM with the case's task and persona constraints. Lux selects only `allow_once`
+or `reject_once`, never a remembered grant. The persona parser accepts strict
+approval JSON either bare or in one complete JSON Markdown fence; ambiguous
+text and invalid fields still deny the operation. If the agent offers no matching
+one-operation option, Lux cancels and reports an error rather than widening the
+grant. Native auto decisions are handled inside Grok and are not Lux interrupts.
+
+Permission reviews have a separate `permissionTimeoutMs` (150 seconds by
+default), while ordinary inactivity uses `idleTimeoutMs` (10 minutes). Startup
+RPCs time out after 30 seconds. Cancelled turns, process failures, unanswered
+reviews, and turns ending with pending approvals cannot count as successful runs.
+A completed turn can still contain denied tool calls: assert the expected files
+or tool results to determine whether the task succeeded.
+
+## Scope and limitations
+
+Lux requests the native `workspace` sandbox and a private process with
+`--no-leader`. `read-only` and `strict` profiles are available; disabling the
+sandbox is not a driver option. The workspace profile allows filesystem reads,
+network access, and writes to the working directory, Grok state, and temporary
+directories. It is not configuration isolation: Grok still loads user/project
+settings, compatible Claude settings, hooks, skills, and MCP configuration.
+The driver reports configuration isolation, usage, and cost as unavailable;
+controlled experiments requiring those capabilities remain unsupported.
+
+The interaction surface currently supports tool permissions. Other ACP client
+requests receive an explicit unsupported-method response. Run evidence includes
+agent messages, reasoning, tool calls/results, and collected files. Use artifact
+assertions alongside `run-succeeded`.
+
+## Validation
+
+Synthetic tests cover explicit model/effort selection, one-operation approvals
+and rejections, refusal to substitute remembered grants, permission timeouts,
+process exit during review, cancellation, idle timeout, and cleanup.
+
+Live smoke validation uses Grok.build 1.0.40 with `grok-4.5` at low effort.
+
+The opt-in live smoke task runs three real evals: a local shell write under auto
+review, an explicit ask rule answered by Lux's LLM persona, and an explicit deny
+rule that must produce a failed tool result without creating the file. It
+requires Grok and Claude Code logins and consumes model usage. Evidence stays
+in the temporary directory printed by the task:
+
+```sh
+LUX_GROK_MODEL=grok-4.5 mise run smoke:grok-build
+```
+
+References:
+
+- [Grok ACP guide](https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/15-agent-mode.md)
+- [Grok permissions](https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/22-permissions-and-safety.md)
+- [Grok sandbox](https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/18-sandbox.md)

package/src/drivers/grok-build/config.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { applyCatalogEffort, grokBuildCatalog } from "../../core/index.js";
+
+export const GrokBuildDriverConfigSchema = z
+  .object({
+    command: z.string().min(1).default("grok"),
+    model: z.string().min(1),
+    reasoningEffort: z.enum(grokBuildCatalog.efforts).default("low"),
+    permissionMode: z.enum(["auto", "default"]).default("auto"),
+    trustProject: z.boolean().default(false),
+    sandbox: z.enum(["workspace", "read-only", "strict"]).default("workspace"),
+    cwd: z.string().optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    startupTimeoutMs: z.number().int().positive().default(30_000),
+    idleTimeoutMs: z.number().int().positive().default(600_000),
+    permissionTimeoutMs: z.number().int().positive().default(150_000),
+    maxInterrupts: z.number().int().positive().default(20),
+    maxLineBytes: z.number().int().positive().default(10_000_000),
+    maxQueuedBytes: z.number().int().positive().default(20_000_000),
+    maxToolCalls: z.number().int().positive().default(10_000),
+  })
+  .strict()
+  .transform(applyCatalogEffort(grokBuildCatalog));
+
+export type GrokBuildDriverConfig = z.infer<typeof GrokBuildDriverConfigSchema>;
+
+export const buildGrokBuildArgs = (config: GrokBuildDriverConfig): string[] => [
+  "--permission-mode",
+  config.permissionMode,
+  "--sandbox",
+  config.sandbox,
+  ...(config.trustProject ? ["--trust"] : []),
+  "agent",
+  "--no-leader",
+  "--model",
+  config.model,
+  "--reasoning-effort",
+  config.reasoningEffort,
+  "stdio",
+];

package/src/drivers/grok-build/index.ts

@@ -0,0 +1,329 @@
+import { realpath } from "node:fs/promises";
+import {
+  type AgentDriver,
+  type Answer,
+  type Artifact,
+  type DriverEventMap,
+  defineDriver,
+  discoverCliVersion,
+  type ReadyState,
+  type StartContext,
+  selectModelAndReasoningEffort,
+  TypedEmitter,
+} from "../../core/index.js";
+import { AcpEvents } from "../shared/acp-events.js";
+import { permissionAnswer, permissionRequestText, records } from "../shared/acp-interaction.js";
+import { AcpTransport, asRecord, type RpcId, type RpcRecord } from "../shared/acp-transport.js";
+import { walkArtifacts } from "../shared/artifacts.js";
+import {
+  buildGrokBuildArgs,
+  type GrokBuildDriverConfig,
+  GrokBuildDriverConfigSchema,
+} from "./config.js";
+
+class GrokBuildDriver implements AgentDriver {
+  private readonly emitter = new TypedEmitter<DriverEventMap>();
+  private readonly events: AcpEvents;
+  private transport: AcpTransport | undefined;
+  private sessionId: string | undefined;
+  private cwd: string | undefined;
+  private artifactsDir: string | undefined;
+  private ready = false;
+  private runPromise: Promise<void> | undefined;
+  private terminal = false;
+  private idleTimer: NodeJS.Timeout | undefined;
+  private interruptCount = 0;
+  private readonly interrupts = new Map<
+    string,
+    { id: RpcId; params: RpcRecord; timer: NodeJS.Timeout }
+  >();
+
+  private readonly config: GrokBuildDriverConfig;
+
+  constructor(config: GrokBuildDriverConfig) {
+    this.config = config;
+    this.events = new AcpEvents("grok-build", config.maxToolCalls, config.maxQueuedBytes);
+  }
+
+  on<K extends keyof DriverEventMap>(
+    event: K,
+    handler: (e: DriverEventMap[K]) => void | Promise<void>,
+  ): void {
+    this.emitter.on(event, handler);
+  }
+  off<K extends keyof DriverEventMap>(
+    event: K,
+    handler: (e: DriverEventMap[K]) => void | Promise<void>,
+  ): void {
+    this.emitter.off(event, handler);
+  }
+
+  async start(ctx: StartContext): Promise<ReadyState> {
+    if (this.transport || this.terminal)
+      throw new Error("Grok.build driver cannot be started twice or after close");
+    this.cwd = await realpath(this.config.cwd ?? ctx.artifactsDir);
+    this.artifactsDir = await realpath(ctx.artifactsDir);
+    const cliVersion = await discoverCliVersion(this.config.command);
+    const transport = new AcpTransport({
+      label: "Grok.build ACP",
+      command: this.config.command,
+      args: buildGrokBuildArgs(this.config),
+      cwd: this.cwd,
+      env: { ...process.env, ...this.config.env },
+      signal: ctx.abortSignal,
+      maxLineBytes: this.config.maxLineBytes,
+      maxQueuedBytes: this.config.maxQueuedBytes,
+      onMessage: (message) => this.message(message),
+      onFailure: (error) => this.fail(error),
+      onActivity: () => this.bumpIdleTimer(),
+    });
+    this.transport = transport;
+    try {
+      await transport.spawned();
+      const initialized = await this.request("initialize", {
+        protocolVersion: 1,
+        clientInfo: { name: "lux", version: "1" },
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      });
+      if (initialized.protocolVersion !== 1)
+        throw new Error("Grok.build ACP returned an unsupported protocol version");
+      if (asRecord(initialized._meta)?.grokShell !== true)
+        throw new Error("Expected Grok.build ACP; check the configured command points to grok");
+      const session = await this.request("session/new", {
+        cwd: this.cwd,
+        mcpServers: [],
+        _meta: { autoMode: this.config.permissionMode === "auto", yoloMode: false },
+      });
+      if (typeof session.sessionId !== "string")
+        throw new Error("Grok.build ACP omitted sessionId");
+      this.sessionId = session.sessionId;
+      let nativeConfig = session.configOptions;
+      for (const [configId, value] of [
+        ["model", this.config.model],
+        ["reasoning_effort", this.config.reasoningEffort],
+      ] as const) {
+        const updated = await this.request("session/set_config_option", {
+          sessionId: this.sessionId,
+          configId,
+          value,
+        });
+        nativeConfig = updated.configOptions;
+        if (records(nativeConfig).find((option) => option.id === configId)?.currentValue !== value)
+          throw new Error(`Grok.build ACP did not apply requested ${configId} '${value}'`);
+      }
+      this.ready = true;
+      this.bumpIdleTimer();
+      this.runPromise = this.run(ctx.prompt).catch((error: unknown) => this.fail(error));
+      return {
+        agentId: "grok-build",
+        model: this.config.model,
+        ...(typeof asRecord(initialized._meta)?.agentVersion === "string"
+          ? { agentVersion: String(asRecord(initialized._meta)?.agentVersion) }
+          : {}),
+        detail: {
+          sessionId: this.sessionId,
+          transport: "acp",
+          protocolVersion: 1,
+          ...(cliVersion ? { cliVersion } : {}),
+          permissionMode: this.config.permissionMode,
+          sandbox: this.config.sandbox,
+          trustProject: this.config.trustProject,
+          reasoningEffort: this.config.reasoningEffort,
+          modelResolution: "reported",
+          nativeConfig: nativeConfig ?? [],
+          usageAvailability: "unknown",
+          isolation: "none",
+        },
+      };
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+
+  private request(method: string, params: RpcRecord): Promise<RpcRecord> {
+    if (!this.transport) throw new Error("Grok.build ACP has not started");
+    return this.transport.request(method, params, this.config.startupTimeoutMs);
+  }
+
+  private async run(prompt: string): Promise<void> {
+    const result = await this.transport?.request("session/prompt", {
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text: prompt }],
+    });
+    await this.transport?.drained();
+    if (this.terminal) return;
+    if (result?.stopReason !== "end_turn")
+      throw new Error(`Grok.build stopped with ${String(result?.stopReason ?? "unknown reason")}`);
+    if (this.interrupts.size > 0)
+      throw new Error("Grok.build ended with pending permission requests");
+    this.terminal = true;
+    clearTimeout(this.idleTimer);
+    await this.emitter.emit("done", {
+      exitReason: "done",
+      summary: {
+        sessionId: this.sessionId,
+        stopReason: result.stopReason,
+        usageAvailability: "unknown",
+      },
+    });
+  }
+
+  private async message(message: RpcRecord): Promise<void> {
+    if (this.terminal) return;
+    const method = String(message.method);
+    const params = asRecord(message.params) ?? {};
+    const id = message.id;
+    if (typeof id === "number" || typeof id === "string") {
+      if (params.sessionId !== this.sessionId) {
+        this.transport?.write({ id, error: { code: -32602, message: "Unknown session" } });
+        return;
+      }
+      if (method !== "session/request_permission") {
+        this.transport?.write({
+          id,
+          error: { code: -32601, message: `Unsupported method: ${method}` },
+        });
+        return;
+      }
+      if (++this.interruptCount > this.config.maxInterrupts) {
+        this.transport?.write({ id, result: { outcome: { outcome: "cancelled" } } });
+        throw new Error("Grok.build exceeded maxInterrupts");
+      }
+      const interruptId = `grok-build-${id}`;
+      if (this.interrupts.has(interruptId))
+        throw new Error("Grok.build reused a pending request ID");
+      const timer = setTimeout(() => {
+        this.transport?.write({ id, result: { outcome: { outcome: "cancelled" } } });
+        this.interrupts.delete(interruptId);
+        this.fail(
+          new Error(
+            `Grok.build permission review timed out after ${this.config.permissionTimeoutMs}ms`,
+          ),
+        );
+      }, this.config.permissionTimeoutMs);
+      this.interrupts.set(interruptId, { id, params, timer });
+      clearTimeout(this.idleTimer);
+      void this.emitter
+        .emit("interrupt", {
+          kind: "approve",
+          id: interruptId,
+          request: `${permissionRequestText(params)}\n\nOperation details:\n${JSON.stringify(params.toolCall)}`,
+          context: params,
+        })
+        .catch((error: unknown) => this.fail(error));
+      return;
+    }
+    if (method === "session/update") {
+      if (params.sessionId !== this.sessionId) return;
+      const update = asRecord(params.update);
+      if (update)
+        for (const event of this.events.update(update)) await this.emitter.emit("progress", event);
+    }
+  }
+
+  async respond(answer: Answer): Promise<void> {
+    if (this.terminal) throw new Error("Grok.build is closed");
+    const pending = this.interrupts.get(answer.id);
+    if (!pending) throw new Error(`Grok.build has no pending interrupt '${answer.id}'`);
+    const result = permissionAnswer(pending.params, answer);
+    this.transport?.write({ id: pending.id, result });
+    if (asRecord(result.outcome)?.outcome === "cancelled") {
+      this.fail(new Error("Grok.build offered no matching one-operation permission option"));
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.interrupts.delete(answer.id);
+    this.bumpIdleTimer();
+  }
+
+  private bumpIdleTimer(): void {
+    clearTimeout(this.idleTimer);
+    if (!this.ready || this.terminal || this.interrupts.size > 0) return;
+    this.idleTimer = setTimeout(
+      () =>
+        this.fail(
+          new Error(`Grok.build emitted no event for ${this.config.idleTimeoutMs}ms`),
+          "idle-timeout",
+        ),
+      this.config.idleTimeoutMs,
+    );
+  }
+
+  private fail(error: unknown, exitReason: "error" | "idle-timeout" = "error"): void {
+    if (this.terminal) return;
+    this.terminal = true;
+    clearTimeout(this.idleTimer);
+    for (const pending of this.interrupts.values()) clearTimeout(pending.timer);
+    if (this.ready)
+      void this.transport?.drained().then(() =>
+        this.emitter.emit("error", {
+          exitReason,
+          reason: error instanceof Error ? error.message : String(error),
+        }),
+      );
+    void this.transport?.close();
+  }
+
+  async quiesce(): Promise<void> {
+    clearTimeout(this.idleTimer);
+    const cancelling = !this.terminal && this.sessionId !== undefined;
+    this.terminal = true;
+    for (const pending of this.interrupts.values()) clearTimeout(pending.timer);
+    if (cancelling) {
+      for (const pending of this.interrupts.values())
+        this.transport?.write({ id: pending.id, result: { outcome: { outcome: "cancelled" } } });
+      this.transport?.write({ method: "session/cancel", params: { sessionId: this.sessionId } });
+      let timer: NodeJS.Timeout | undefined;
+      try {
+        await Promise.race([
+          this.runPromise,
+          new Promise<void>((resolve) => {
+            timer = setTimeout(resolve, 200);
+          }),
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    for (const pending of this.interrupts.values()) clearTimeout(pending.timer);
+    this.interrupts.clear();
+    await this.transport?.close();
+  }
+
+  async collect(): Promise<Artifact[]> {
+    await this.quiesce();
+    if (!this.cwd) return [];
+    const artifacts = await walkArtifacts(this.cwd);
+    return this.cwd === this.artifactsDir
+      ? artifacts
+      : artifacts.map((artifact) => ({ ...artifact, root: this.cwd as string }));
+  }
+
+  async close(): Promise<void> {
+    await this.quiesce();
+    this.emitter.removeAllListeners();
+  }
+}
+
+export const grokBuildDriver = defineDriver({
+  name: "grok-build",
+  configSchema: GrokBuildDriverConfigSchema,
+  runtime: (config) => ({
+    commands: [config.command],
+    capabilities: {
+      interactive: true,
+      "tool-calls": true,
+      "tool-results": true,
+      artifacts: true,
+      usage: false,
+      cost: false,
+      isolation: false,
+    },
+  }),
+  selectHarness: selectModelAndReasoningEffort,
+  create: (config) => new GrokBuildDriver(config),
+});
+
+export type { GrokBuildDriverConfig };
+export { buildGrokBuildArgs, GrokBuildDriverConfigSchema };

package/src/index.ts

@@ -364,6 +364,7 @@ export {
   codexCatalog,
   copilotCatalog,
   cursorCatalog,
+  grokBuildCatalog,
   harnessCatalogFor,
 } from "./core/harness-catalogs/index.js";
 export {
@@ -528,6 +529,12 @@ export {
   CursorDriverConfigSchema,
   cursorDriver,
 } from "./drivers/cursor/index.js";
+export {
+  buildGrokBuildArgs,
+  type GrokBuildDriverConfig,
+  GrokBuildDriverConfigSchema,
+  grokBuildDriver,
+} from "./drivers/grok-build/index.js";
 export {
   type McpProbeDriverConfig,
   McpProbeDriverConfigSchema,
@@ -539,13 +546,11 @@ export {
   SubprocessDriverConfigSchema,
   subprocessDriver,
 } from "./drivers/subprocess/index.js";
-
 export {
   createReflectiveOptimizer,
   type ReflectiveOptimizerConfig,
   ReflectiveOptimizerConfigSchema,
 } from "./optimization/reflective.js";
-
 // Supported programmatic orchestration.
 export {
   applyCandidate,

package/src/orchestrator/config.ts

@@ -29,6 +29,7 @@ import { claudeCodeDriver } from "../drivers/claude-code/index.js";
 import { codexDriver } from "../drivers/codex/index.js";
 import { copilotDriver } from "../drivers/copilot/index.js";
 import { cursorDriver } from "../drivers/cursor/index.js";
+import { grokBuildDriver } from "../drivers/grok-build/index.js";
 import { mcpProbeDriver } from "../drivers/mcp/index.js";
 import { subprocessDriver } from "../drivers/subprocess/index.js";
 
@@ -188,6 +189,7 @@ const builtinDrivers: DriverPlugin<never>[] = [
   codexDriver,
   cursorDriver,
   copilotDriver,
+  grokBuildDriver,
   antigravityDriver,
   subprocessDriver,
   mcpProbeDriver,