@prismatic-io/lux 0.0.2-preview.27 → 0.0.2-preview.29

package/src/drivers/cursor/README.md

@@ -1,14 +1,15 @@
 # Cursor driver
 
 The `cursor` driver uses Cursor CLI's ACP transport. Install Cursor CLI and
-authenticate it before running Lux. The executable is normally named `agent`;
-set `command` to its absolute path if another application owns that name.
+authenticate it before running Lux. Lux defaults to the unambiguous
+`cursor-agent` executable because other harnesses also install `agent`.
+Set `command` to an absolute path or to `agent` if that is your Cursor installation.
 
 ```ts
 {
   name: "cursor",
   config: {
-    command: "/absolute/path/to/cursor/agent",
+    command: "/absolute/path/to/cursor-agent",
     model: "YOUR_CURSOR_MODEL_ID",
     // Optional: one of low, medium, high, xhigh; applied only when ACP advertises it.
     // reasoningEffort: "low",
@@ -16,11 +17,13 @@ set `command` to its absolute path if another application owns that name.
 }
 ```
 
-`model` is required. Cursor's model list is account-scoped (`agent
+`model` is required. Cursor's model list is account-scoped (`cursor-agent
 --list-models` after login), so the harness catalog keeps it open: any ID is
 accepted in configuration and in a `matrix`, and some IDs encode reasoning
-effort. Lux passes that ID through `--model` and rejects a different model when
-the session reports one. If `reasoningEffort` is supplied (`low`, `medium`,
+effort. Use the exact ACP model ID, including bracketed settings such as
+`composer-2.5[fast=true]`. Lux passes the ID through `--model`, selects it with
+ACP when the session advertises a model selector, and rejects a different
+reported model. If `reasoningEffort` is supplied (`low`, `medium`,
 `high`, or `xhigh`), Lux requires a matching advertised ACP thought-level
 selector and checks the response confirms the requested value before sending
 the prompt. No default effort is applied.
@@ -49,8 +52,11 @@ managed process tree before collecting artifacts. Aborting a run also terminates
 the managed tree. Unsupported client filesystem/terminal operations are not
 advertised and unsupported requests receive a JSON-RPC error.
 
-The adapter is covered by synthetic protocol and lifecycle tests. Its initial
-implementation has not been validated against an authenticated Cursor session.
+The adapter has synthetic protocol and lifecycle tests plus an opt-in live
+smoke task: `mise run smoke:harnesses -- cursor` from the repository root.
+The live task checks tool evidence, exact file output, and normal completion;
+it uses your installed CLI, existing login, and model quota. Cursor CLI
+`2026.09.23-86fc751` passed the basic authenticated file-copy smoke on 2026-09-30.
 
 Protocol references:
 

package/src/drivers/cursor/config.ts

@@ -4,7 +4,7 @@ import { cursorCatalog } from "../../core/index.js";
 
 export const CursorDriverConfigSchema = z
   .object({
-    command: z.string().min(1).default("agent"),
+    command: z.string().min(1).default("cursor-agent"),
     model: z.string().min(1),
     reasoningEffort: z.enum(cursorCatalog.efforts).optional(),
     mode: z.enum(["agent", "plan", "ask"]).default("agent"),

package/src/drivers/cursor/index.ts

@@ -14,6 +14,7 @@ import {
 } from "../../core/index.js";
 import { AcpEvents } from "../shared/acp-events.js";
 import { permissionRequestText, records } from "../shared/acp-interaction.js";
+import { acpModel, selectAcpModel } from "../shared/acp-session.js";
 import { AcpTransport, asRecord, type RpcId, type RpcRecord } from "../shared/acp-transport.js";
 import { walkArtifacts } from "../shared/artifacts.js";
 import { buildCursorArgs, type CursorDriverConfig, CursorDriverConfigSchema } from "./config.js";
@@ -91,6 +92,9 @@ class CursorDriver implements AgentDriver {
       let session = await this.request("session/new", { cwd: this.cwd, mcpServers: [] });
       if (typeof session.sessionId !== "string") throw new Error("Cursor ACP omitted sessionId");
       this.sessionId = session.sessionId;
+      session = await selectAcpModel("Cursor", session, this.config.model, (method, params) =>
+        this.request(method, params),
+      );
       if (this.config.reasoningEffort) {
         const selection = effortSelector(session, this.config.reasoningEffort);
         const updated = await this.request("session/set_config_option", {
@@ -104,10 +108,7 @@ class CursorDriver implements AgentDriver {
           throw new Error("Cursor ACP did not apply the requested reasoning effort");
         session = { ...session, ...updated };
       }
-      const model =
-        records(session.configOptions).find(
-          (option) => option.category === "model" || option.id === "model",
-        )?.currentValue ?? asRecord(session.models)?.currentModelId;
+      const model = acpModel(session);
       if (typeof model === "string" && model !== this.config.model)
         throw new Error(
           `Cursor ACP selected '${model}' instead of requested '${this.config.model}'`,
@@ -182,8 +183,11 @@ class CursorDriver implements AgentDriver {
         });
         return;
       }
-      if (++this.interruptCount > this.config.maxInterrupts)
-        throw new Error("Cursor exceeded maxInterrupts");
+      if (++this.interruptCount > this.config.maxInterrupts) {
+        this.transport?.write({ id, result: { outcome: { outcome: "cancelled" } } });
+        this.fail(new Error("Cursor exceeded maxInterrupts"), "max-interactions");
+        return;
+      }
       const interruptId = `cursor-${id}`;
       if (this.interrupts.has(interruptId)) throw new Error("Cursor reused a pending request ID");
       this.interrupts.set(interruptId, { id, method, params });
@@ -245,7 +249,7 @@ class CursorDriver implements AgentDriver {
     );
   }
 
-  private fail(error: unknown, exitReason: "error" | "idle-timeout" = "error"): void {
+  private fail(error: unknown, exitReason: DriverEventMap["error"]["exitReason"] = "error"): void {
     if (this.terminal) return;
     this.terminal = true;
     clearTimeout(this.idleTimer);

package/src/drivers/shared/acp-session.ts

@@ -0,0 +1,40 @@
+import { records } from "./acp-interaction.js";
+import { asRecord, type RpcRecord } from "./acp-transport.js";
+
+export const acpModel = (session: RpcRecord): unknown =>
+  records(session.configOptions).find(
+    (option) => option.category === "model" || option.id === "model",
+  )?.currentValue ?? asRecord(session.models)?.currentModelId;
+
+const hasOption = (options: unknown, value: string): boolean =>
+  records(options).some((option) => option.value === value || hasOption(option.options, value));
+
+export const selectAcpModel = async (
+  label: string,
+  session: RpcRecord,
+  model: string,
+  request: (method: string, params: RpcRecord) => Promise<RpcRecord>,
+): Promise<RpcRecord> => {
+  let selected = session;
+  const selector = records(session.configOptions).find(
+    (option) => option.category === "model" || option.id === "model",
+  );
+  if (
+    acpModel(session) !== model &&
+    typeof selector?.id === "string" &&
+    hasOption(selector.options, model)
+  ) {
+    const updated = await request("session/set_config_option", {
+      sessionId: session.sessionId,
+      configId: selector.id,
+      value: model,
+    });
+    selected = { ...session, ...updated };
+  }
+  const reported = acpModel(selected);
+  if (typeof reported === "string" && reported !== model)
+    throw new Error(
+      `${label} ACP selected '${reported}' instead of requested '${model}'; use an exact model ID advertised by the ACP session`,
+    );
+  return selected;
+};

package/src/index.ts

@@ -265,6 +265,12 @@ export {
   type StartContext,
   selectModelAndReasoningEffort,
 } from "./core/driver.js";
+export {
+  type ContainerExecution,
+  ContainerExecutionSchema,
+  type DriverExecution,
+  DriverExecutionSchema,
+} from "./core/driver-execution.js";
 export {
   type DriverMetric,
   type DriverMetricDescriptor,

package/src/orchestrator/config.ts

@@ -74,7 +74,7 @@ const LifecycleHooksPluginSchema = z.custom<LifecycleHooksPlugin>().superRefine(
   if (issue) ctx.addIssue({ code: "custom", message: issue });
 });
 
-const LuxConfigSchema = z
+export const LuxConfigSchema = z
   .object({
     environment: EnvironmentDeclarationSchema.optional(),
     casesRoot: z.string().optional(),
@@ -194,6 +194,9 @@ const builtinDrivers: DriverPlugin<never>[] = [
   subprocessDriver,
   mcpProbeDriver,
 ];
+export const isBuiltinDriver = (plugin: DriverPlugin): boolean =>
+  builtinDrivers.some((builtin) => builtin === plugin);
+
 const builtinAnswerers: AnswererPlugin<never>[] = [
   personaAnswerer,
   claudeCodeAnswerer,

package/src/orchestrator/doctor.ts

@@ -4,6 +4,7 @@ import { resolve } from "node:path";
 import { glob } from "tinyglobby";
 import { z } from "zod";
 import { RubricConfigSchema } from "../assertions/rubric/index.js";
+import { driverExecutionOf } from "../core/driver-execution.js";
 import {
   casePermutations,
   type EvalCase,
@@ -143,6 +144,7 @@ const effectiveDriverReference = (local: unknown, fallback: unknown): unknown =>
   return {
     name: refName(local),
     config: mergeRecords(rawRefConfig(fallback), rawRefConfig(local)),
+    execution: driverExecutionOf(local) ?? driverExecutionOf(fallback),
   };
 };
 
@@ -511,7 +513,7 @@ const caseDriverFailure = (
       rawRefConfig(reference),
       `case '${caseId}' driver '${name}'`,
     );
-    validateDriverCapabilities(plugin, config, required);
+    validateDriverCapabilities(plugin, config, required, driverExecutionOf(reference));
     return null;
   } catch (error) {
     return firstLine(error);

package/src/orchestrator/driver-capabilities.ts

@@ -1,12 +1,17 @@
 import type { DriverCapability, DriverPlugin } from "../core/driver.js";
+import type { DriverExecution } from "../core/driver-execution.js";
 
 export const validateDriverCapabilities = (
   plugin: DriverPlugin,
   config: unknown,
   required: readonly DriverCapability[] = [],
+  execution?: DriverExecution,
 ): void => {
   if (required.length === 0) return;
-  const capabilities = plugin.runtime?.(config).capabilities;
+  const capabilities = {
+    ...plugin.runtime?.(config).capabilities,
+    ...(execution?.kind === "container" ? { isolation: true } : {}),
+  };
   const missing = required.filter((capability) => capabilities?.[capability] !== true);
   if (missing.length > 0) {
     throw new Error(

package/src/orchestrator/driver-identity.ts

@@ -1,4 +1,5 @@
 import type { DriverPlugin, DriverRuntime } from "../core/driver.js";
+import { driverExecutionOf } from "../core/driver-execution.js";
 import type { Registry } from "../core/registry.js";
 import { cliIdentity } from "./experiment-runtime-identity.js";
 import { validatePluginConfig } from "./validate-plugin-config.js";
@@ -21,7 +22,14 @@ const resolvedDriver = (
 
 export const referencedDriverRuntime = (reference: unknown, registry: Registry): DriverRuntime => {
   const resolved = resolvedDriver(reference, registry);
-  return resolved?.plugin.runtime?.(resolved.config) ?? { commands: [], capabilities: {} };
+  const runtime = resolved?.plugin.runtime?.(resolved.config) ?? { commands: [], capabilities: {} };
+  const execution = driverExecutionOf(reference);
+  return execution?.kind === "container"
+    ? {
+        commands: [execution.command ?? "docker"],
+        capabilities: { ...runtime.capabilities, isolation: true },
+      }
+    : runtime;
 };
 
 export const experimentDriverIdentity = async (
@@ -29,6 +37,8 @@ export const experimentDriverIdentity = async (
   registry: Registry,
   rootDir: string,
 ): Promise<unknown> => {
+  if (driverExecutionOf(reference)?.kind === "container")
+    throw new Error("container execution does not yet support controlled experiments");
   const resolved = resolvedDriver(reference, registry);
   if (!resolved) return null;
   const { plugin, config } = resolved;

package/src/orchestrator/orchestrator.ts

@@ -1,4 +1,6 @@
 import { basename, extname, join, resolve } from "node:path";
+import { ContainerDriver } from "../container/driver.js";
+import { driverExecutionOf } from "../core/driver-execution.js";
 import { type EnvironmentDeclaration, EnvironmentDeclarationSchema } from "../core/environment.js";
 import {
   type Answerer,
@@ -28,6 +30,7 @@ import {
   registryForEvalCase,
   valuesForFixtures,
 } from "./case-extensions.js";
+import { isBuiltinDriver } from "./config.js";
 import { validateDriverCapabilities } from "./driver-capabilities.js";
 import { evaluatorImplementationHash } from "./evaluator-identity.js";
 import {
@@ -249,6 +252,7 @@ export const resolveDriverReference = (
   return {
     name: driverNameOf(local),
     config: mergePluginConfig(driverConfigOf(base), driverConfigOf(local)),
+    execution: driverExecutionOf(local) ?? driverExecutionOf(base),
   };
 };
 
@@ -390,8 +394,20 @@ export class Orchestrator {
       `answerer '${answererName}'`,
     );
 
-    validateDriverCapabilities(driverPlugin, driverCfg, evalCase.requires);
-    const driver = await driverPlugin.create(driverCfg);
+    const execution = driverExecutionOf(driverRef);
+    if (execution?.kind === "container" && request.experimentId)
+      throw new Error("container execution does not yet support controlled experiments");
+    if (
+      execution?.kind === "container" &&
+      !execution.driverModule &&
+      !isBuiltinDriver(driverPlugin)
+    )
+      throw new Error("custom container drivers require execution.driverModule in the image");
+    validateDriverCapabilities(driverPlugin, driverCfg, evalCase.requires, execution);
+    const driver =
+      execution?.kind === "container"
+        ? new ContainerDriver(driverName, driverCfg, execution)
+        : await driverPlugin.create(driverCfg);
     let answerer: Answerer;
     try {
       answerer = await answererPlugin.create(answererCfg);
@@ -427,7 +443,7 @@ export class Orchestrator {
           permutationId: request.permutationId,
           answererName,
           answererConfig: answererCfg,
-          driverConfigHash: valueHash(driverCfg),
+          driverConfigHash: valueHash(execution ? { config: driverCfg, execution } : driverCfg),
           answererConfigHash: valueHash(answererCfg),
           validatedAssertionsHash,
           graderConfigHash: graderHash,