@prismatic-io/lux 0.0.2-preview.3 → 0.0.2-preview.32

package/src/drivers/codex/index.ts

@@ -3,32 +3,37 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { temporaryDirectory } from "tempy";
-import { z } from "zod";
+import { agentEnvironment } from "../../core/agent-environment.js";
+import { durationMs } from "../../core/duration.js";
 import {
   type AgentDriver,
   type Answer,
   type Artifact,
   type DriverEventMap,
-  type DriverPlugin,
+  defineDriver,
   discoverCliVersion,
-  type ParsedDriverEvent,
   type ReadyState,
   type StartContext,
+  selectModelAndReasoningEffort,
   spawnManagedProcess,
   type TokenUsage,
   TypedEmitter,
-  toolResultProgress,
 } from "../../core/index.js";
+import { resolveExecutable } from "../../core/platform-process.js";
+import { copyRegularFileNoFollow } from "../../core/secure-copy.js";
 import { walkArtifacts } from "../shared/artifacts.js";
-import { copyRegularFileNoFollow } from "../shared/secure-copy.js";
+import { configuredClaudeSourceHashes } from "../shared/experiment-behavior.js";
+import { prepareCodexExperimentConfig } from "../shared/experiment-policy.js";
 import { subprocessDriver } from "../subprocess/index.js";
 import {
   type AppTurnFacets,
+  appAgentLifecycleProgress,
   appItemProgress,
   appItemToolName,
   appTurnLabel,
   appUsage,
   asRecord,
+  CodexSubagentTracker,
   messageOf,
   type RpcId,
   type RpcRecord,
@@ -39,266 +44,14 @@ import {
   type CodexConfigValue,
   type CodexDriverConfig,
   CodexDriverConfigSchema,
+  codexConfigOverrides,
 } from "./config.js";
 
+import { makeParseEvent } from "./exec-events.js";
+
 const LUX_BOOKKEEPING_FILES = new Set(["events.jsonl", "case.json", "run.json", "grading.json"]);
 const commandName = (command: string): string => command.split(/[\\/]/).at(-1) ?? command;
 
-const CodexUsageSchema = z.object({
-  input_tokens: z.number().nonnegative().catch(0),
-  cached_input_tokens: z.number().nonnegative().catch(0),
-  output_tokens: z.number().nonnegative().catch(0),
-});
-
-const parseUsage = (raw: unknown): TokenUsage | null => {
-  const usage = CodexUsageSchema.safeParse(raw).data;
-  if (!usage) return null;
-  return {
-    input: Math.max(0, usage.input_tokens - usage.cached_input_tokens),
-    output: usage.output_tokens,
-    cacheRead: usage.cached_input_tokens,
-    cacheCreation: 0,
-  };
-};
-
-const resultText = (content: unknown): string => {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter(
-      (block): block is { type: "text"; text: string } =>
-        typeof block === "object" &&
-        block !== null &&
-        (block as { type?: unknown }).type === "text" &&
-        typeof (block as { text?: unknown }).text === "string",
-    )
-    .map((block) => block.text)
-    .join("\n");
-};
-
-const startedItemProgress = (
-  item: Record<string, unknown>,
-  id: string,
-): ParsedDriverEvent | null => {
-  if (item.type === "command_execution") {
-    return {
-      tag: "progress",
-      progress: {
-        id: `tc-${id}`,
-        kind: "tool-call",
-        payload: { name: "command_execution", input: { command: item.command }, toolUseId: id },
-        ts: Date.now(),
-      },
-    };
-  }
-  if (item.type === "mcp_tool_call") {
-    const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
-    const server = typeof item.server === "string" ? item.server : undefined;
-    return {
-      tag: "progress",
-      progress: {
-        id: `tc-${id}`,
-        kind: "tool-call",
-        payload: {
-          name: tool,
-          input: item.arguments ?? item.input,
-          toolUseId: id,
-          ...(server ? { server } : {}),
-        },
-        ts: Date.now(),
-      },
-    };
-  }
-  if (item.type === "web_search") {
-    return {
-      tag: "progress",
-      progress: {
-        id: `tc-${id}`,
-        kind: "tool-call",
-        payload: { name: "web_search", input: { query: item.query }, toolUseId: id },
-        ts: Date.now(),
-      },
-    };
-  }
-  if (item.type === "file_change") {
-    return {
-      tag: "progress",
-      progress: {
-        id: `tc-${id}`,
-        kind: "tool-call",
-        payload: { name: "file_change", input: { changes: item.changes }, toolUseId: id },
-        ts: Date.now(),
-      },
-    };
-  }
-  return null;
-};
-
-const completedItemProgress = (
-  item: Record<string, unknown>,
-  id: string,
-): ParsedDriverEvent | null => {
-  if (item.type === "agent_message" && typeof item.text === "string") {
-    return {
-      tag: "progress",
-      progress: {
-        id: `am-${id}`,
-        kind: "agent-message",
-        payload: { text: item.text },
-        ts: Date.now(),
-      },
-    };
-  }
-  if (item.type === "reasoning") {
-    const text = typeof item.text === "string" ? item.text : item.summary;
-    return {
-      tag: "progress",
-      progress: { id: `reasoning-${id}`, kind: "reasoning", payload: { text }, ts: Date.now() },
-    };
-  }
-  if (item.type === "mcp_tool_call") {
-    const tool = typeof item.tool === "string" ? item.tool : String(item.name ?? "mcp_tool_call");
-    const raw =
-      item.result && typeof item.result === "object"
-        ? (item.result as Record<string, unknown>)
-        : item;
-    const content = raw.content ?? item.result ?? [];
-    const structuredContent = raw.structuredContent ?? raw.structured_content;
-    return {
-      tag: "progress",
-      progress: toolResultProgress(
-        0,
-        {
-          name: tool,
-          toolUseId: id,
-          content,
-          ...(structuredContent && typeof structuredContent === "object"
-            ? { structuredContent: structuredContent as Record<string, unknown> }
-            : {}),
-          isError:
-            raw.isError === true ||
-            raw.is_error === true ||
-            item.status === "failed" ||
-            (item.error !== undefined && item.error !== null),
-          text: resultText(content) || (typeof item.error === "string" ? item.error : ""),
-        },
-        Date.now(),
-      ),
-    };
-  }
-  if (item.type === "command_execution") {
-    const output = item.aggregated_output ?? item.output ?? "";
-    const exitCode = typeof item.exit_code === "number" ? item.exit_code : undefined;
-    return {
-      tag: "progress",
-      progress: toolResultProgress(
-        0,
-        {
-          name: "command_execution",
-          toolUseId: id,
-          content: { output, ...(exitCode !== undefined ? { exitCode } : {}) },
-          isError: item.status === "failed" || (exitCode !== undefined && exitCode !== 0),
-          text: typeof output === "string" ? output : JSON.stringify(output),
-        },
-        Date.now(),
-      ),
-    };
-  }
-  if (item.type === "web_search" || item.type === "file_change") {
-    const isWebSearch = item.type === "web_search";
-    const content = isWebSearch
-      ? { query: item.query }
-      : { changes: item.changes, status: item.status };
-    let text = JSON.stringify(item.changes ?? []);
-    if (isWebSearch) text = typeof item.query === "string" ? item.query : "";
-    return {
-      tag: "progress",
-      progress: toolResultProgress(
-        0,
-        {
-          name: item.type,
-          toolUseId: id,
-          content,
-          isError: item.status === "failed",
-          text,
-        },
-        Date.now(),
-      ),
-    };
-  }
-  return null;
-};
-
-const itemProgress = (
-  item: Record<string, unknown>,
-  phase: "started" | "completed",
-): ParsedDriverEvent | null => {
-  const id = typeof item.id === "string" ? item.id : `${String(item.type)}-${Date.now()}`;
-  return phase === "started" ? startedItemProgress(item, id) : completedItemProgress(item, id);
-};
-
-const makeParseEvent = (config: CodexDriverConfig, cliVersion?: string) => {
-  let threadId: string | undefined;
-  return (line: string): ParsedDriverEvent | ParsedDriverEvent[] | null => {
-    let event: Record<string, unknown>;
-    try {
-      event = JSON.parse(line) as Record<string, unknown>;
-    } catch {
-      return null;
-    }
-    if (event.type === "thread.started") {
-      threadId = typeof event.thread_id === "string" ? event.thread_id : undefined;
-      return {
-        tag: "ready",
-        ready: {
-          agentId: "codex",
-          model: config.model,
-          detail: { ...(threadId ? { threadId } : {}), ...(cliVersion ? { cliVersion } : {}) },
-        },
-      };
-    }
-    if (event.type === "item.started" || event.type === "item.completed") {
-      if (!event.item || typeof event.item !== "object") return null;
-      return itemProgress(
-        event.item as Record<string, unknown>,
-        event.type === "item.started" ? "started" : "completed",
-      );
-    }
-    if (event.type === "turn.completed") {
-      const usage = parseUsage(event.usage);
-      const events: ParsedDriverEvent[] = [];
-      if (usage) {
-        events.push({
-          tag: "progress",
-          progress: {
-            id: `usage-${threadId ?? Date.now()}`,
-            kind: "usage",
-            payload: usage,
-            ts: Date.now(),
-          },
-        });
-      }
-      events.push({
-        tag: "done",
-        done: { exitReason: "done", summary: { threadId, ...(usage ? { usage } : {}) } },
-      });
-      return events;
-    }
-    if (event.type === "turn.failed" || event.type === "error") {
-      const nestedMessage =
-        event.error && typeof event.error === "object"
-          ? (event.error as Record<string, unknown>).message
-          : undefined;
-      let message = "codex reported an error";
-      if (typeof event.message === "string") message = event.message;
-      else if (typeof event.error === "string") message = event.error;
-      else if (typeof nestedMessage === "string") message = nestedMessage;
-      return { tag: "error", error: { exitReason: "error", reason: message } };
-    }
-    return null;
-  };
-};
-
 class CodexAppServerDriverImpl implements AgentDriver {
   private readonly emitter = new TypedEmitter<DriverEventMap>();
   private readonly config: CodexDriverConfig;
@@ -308,6 +61,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
   private runDir: string | null = null;
   private isolatedWorkspace: string | null = null;
   private isolatedStateDir: string | null = null;
+  private isolationConfig: Record<string, CodexConfigValue> = {};
   private threadId: string | null = null;
   private cliVersion: string | undefined;
   private nextRequestId = 1;
@@ -316,7 +70,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
     { resolve: (result: RpcRecord) => void; reject: (error: Error) => void }
   >();
   private readonly interrupts = new Map<string, { id: RpcId; method: string; params: RpcRecord }>();
-  private readonly subagentParents = new Map<string, string>();
+  private readonly subagents = new CodexSubagentTracker();
   private readonly turnFacets = new Map<string, AppTurnFacets>();
   private interruptCount = 0;
   private idleTimer: NodeJS.Timeout | null = null;
@@ -345,6 +99,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
     let cwd =
       this.config.cwd ?? (this.config.cwdMode === "artifacts" ? ctx.artifactsDir : ctx.runDir);
     let env = this.config.env;
+    let launchCommand = this.config.command;
     if (this.config.isolation) {
       const workspace = await realpath(temporaryDirectory({ prefix: "lux-codex-workspace-" }));
       await cp(ctx.artifactsDir, workspace, { recursive: true });
@@ -372,6 +127,45 @@ class CodexAppServerDriverImpl implements AgentDriver {
         CODEX_CONFIG_HOME: stateDir,
       };
     }
+    if (this.config.isolation) {
+      const reads = await Promise.all(
+        this.config.isolation.allowRead.map((path) => realpath(path)),
+      );
+      const executable = resolveExecutable(
+        this.config.command,
+        { ...agentEnvironment(process.env, this.config.inheritEnv), ...env },
+        undefined,
+        cwd,
+      );
+      if (executable) {
+        launchCommand = await realpath(executable);
+        reads.push(executable, launchCommand);
+      }
+      // Native filesystem tools relaunch the CLI inside the subject sandbox.
+      // Workspace requirements reload process configuration during a turn.
+      // A thread-only profile is accepted at startup but fails that reload.
+      this.isolationConfig = {
+        allow_login_shell: false,
+        project_doc_max_bytes: 0,
+        projects: { [cwd]: { trust_level: "untrusted" } },
+        default_permissions: "lux-isolated",
+        permissions: {
+          "lux-isolated": {
+            filesystem: {
+              ":minimal": "read",
+              [cwd]: "write",
+              ...Object.fromEntries(reads.map((path) => [path, "read"])),
+            },
+            network: { enabled: true },
+          },
+        },
+        features: {
+          ...((this.config.config?.features as Record<string, CodexConfigValue>) ?? {}),
+          shell_snapshot: false,
+          shell_snapshot_v2: false,
+        },
+      };
+    }
     this.collectDir = cwd;
     this.artifactsDir = ctx.artifactsDir;
     this.runDir = ctx.runDir;
@@ -382,16 +176,23 @@ class CodexAppServerDriverImpl implements AgentDriver {
       commandName(this.config.command) === "codex"
         ? await discoverCliVersion(this.config.command)
         : undefined;
-    const managed = spawnManagedProcess(this.config.command, buildAppServerArgs(this.config), {
-      cwd,
-      env: {
-        ...process.env,
-        LUX_RUN_DIR: ctx.runDir,
-        LUX_ARTIFACTS_DIR: ctx.artifactsDir,
-        ...env,
+    const managed = spawnManagedProcess(
+      launchCommand,
+      buildAppServerArgs({
+        ...this.config,
+        config: { ...this.config.config, ...this.isolationConfig },
+      }),
+      {
+        cwd,
+        env: {
+          ...agentEnvironment(process.env, this.config.inheritEnv),
+          LUX_RUN_DIR: ctx.runDir,
+          LUX_ARTIFACTS_DIR: ctx.artifactsDir,
+          ...env,
+        },
+        signal: ctx.abortSignal,
       },
-      signal: ctx.abortSignal,
-    });
+    );
     this.process = managed;
     managed.child.stderr.setEncoding("utf8");
     let stderrTail = "";
@@ -436,41 +237,35 @@ class CodexAppServerDriverImpl implements AgentDriver {
       capabilities: { experimentalApi: true, requestAttestation: false },
     });
     this.notify("initialized");
-    const isolationReads = this.config.isolation
-      ? await Promise.all(this.config.isolation.allowRead.map((path) => realpath(path)))
-      : [];
     const threadConfig: Record<string, CodexConfigValue> = {
-      ...(this.config.config ?? {}),
-      model_reasoning_effort: this.config.reasoningEffort,
-      ...(this.config.isolation
-        ? {
-            project_doc_max_bytes: 0,
-            projects: { [cwd]: { trust_level: "untrusted" } },
-            permissions: {
-              "lux-isolated": {
-                filesystem: {
-                  ":minimal": "read",
-                  ":workspace_roots": { ".": "write" },
-                  ...Object.fromEntries(isolationReads.map((path) => [path, "read"])),
-                },
-                network: { enabled: true },
-              },
-            },
-          }
+      ...codexConfigOverrides(this.config),
+      ...(this.config.reasoningEffort
+        ? { model_reasoning_effort: this.config.reasoningEffort }
         : {}),
+      ...this.isolationConfig,
     };
     const started = await this.request("thread/start", {
       model: this.config.model,
       cwd,
-      runtimeWorkspaceRoots: this.config.addDirs ?? [],
+      runtimeWorkspaceRoots: this.config.isolation
+        ? [cwd, ...(this.config.addDirs ?? [])]
+        : (this.config.addDirs ?? []),
       approvalPolicy: this.config.approvalPolicy,
-      approvalsReviewer: "user",
+      approvalsReviewer: this.config.approvalsReviewer,
       ...(this.config.isolation
         ? { permissions: "lux-isolated" }
         : { sandbox: this.config.sandbox }),
       config: threadConfig,
       ephemeral: this.config.ephemeral,
     });
+    if (
+      this.config.approvalsReviewer === "auto_review" &&
+      started.approvalsReviewer !== "auto_review"
+    ) {
+      throw new Error(
+        "codex app-server did not enable the requested auto_review approvals reviewer",
+      );
+    }
     const thread = asRecord(started.thread);
     if (!thread || typeof thread.id !== "string") {
       throw new Error("codex app-server returned an invalid thread/start response");
@@ -481,6 +276,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
       model: typeof started.model === "string" ? started.model : this.config.model,
       detail: {
         threadId: thread.id,
+        approvalsReviewer: this.config.approvalsReviewer,
         ...(typeof thread.sessionId === "string" ? { sessionId: thread.sessionId } : {}),
         ...(this.cliVersion ? { cliVersion: this.cliVersion } : {}),
       },
@@ -586,6 +382,11 @@ class CodexAppServerDriverImpl implements AgentDriver {
       : withRoot;
   }
 
+  async verificationWorkspace(): Promise<string | undefined> {
+    await this.quiesce();
+    return this.isolatedWorkspace ?? undefined;
+  }
+
   async quiesce(): Promise<void> {
     this.clearIdleTimer();
     await this.process?.terminate();
@@ -659,6 +460,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
   }
 
   private async dispatch(message: RpcRecord): Promise<void> {
+    if (this.terminal) return;
     const method = typeof message.method === "string" ? message.method : "";
     const params = asRecord(message.params) ?? {};
     if (message.id !== undefined && method) {
@@ -669,6 +471,14 @@ class CodexAppServerDriverImpl implements AgentDriver {
       await this.handleItemNotification(method, params);
       return;
     }
+    if (
+      (method === "thread/tokenUsage/updated" ||
+        method === "turn/completed" ||
+        method === "error") &&
+      typeof params.threadId === "string" &&
+      params.threadId !== this.threadId
+    )
+      return;
     if (method === "thread/tokenUsage/updated") {
       this.handleTokenUsageNotification(params);
       return;
@@ -702,28 +512,28 @@ class CodexAppServerDriverImpl implements AgentDriver {
     const toolName = item ? appItemToolName(item) : null;
     if (toolName && !facets.tools.includes(toolName)) facets.tools.push(toolName);
     if (turnId) this.turnFacets.set(turnId, facets);
-    this.recordSubagentParents(item);
-    const parentToolUseId =
-      typeof params.threadId === "string" ? this.subagentParents.get(params.threadId) : undefined;
+    const threadId = typeof params.threadId === "string" ? params.threadId : undefined;
+    this.subagents.record(item, threadId, this.threadId);
+    const agent = this.subagents.attribution(threadId, this.threadId);
     const event = item
-      ? appItemProgress(item, method === "item/started" ? "started" : "completed", parentToolUseId)
+      ? appItemProgress(item, method === "item/started" ? "started" : "completed", agent)
       : null;
     if (event?.tag === "progress") await this.emitter.emit("progress", event.progress);
-  }
-
-  private recordSubagentParents(item: RpcRecord | null): void {
-    if (item?.type !== "collabAgentToolCall" || typeof item.id !== "string") return;
-    const receiverThreadIds = Array.isArray(item.receiverThreadIds)
-      ? item.receiverThreadIds.filter((value): value is string => typeof value === "string")
-      : [];
-    for (const receiverThreadId of receiverThreadIds) {
-      this.subagentParents.set(receiverThreadId, item.id);
+    if (item) {
+      for (const lifecycle of appAgentLifecycleProgress(
+        item,
+        method === "item/started" ? "started" : "completed",
+        agent,
+        event?.tag === "progress" ? event.progress.ts : Date.now(),
+      )) {
+        await this.emitter.emit("progress", lifecycle);
+      }
     }
   }
 
   private handleTokenUsageNotification(params: RpcRecord): void {
     const tokenUsage = asRecord(params.tokenUsage);
-    const usage = appUsage(tokenUsage?.last);
+    const usage = appUsage(tokenUsage?.total) ?? appUsage(tokenUsage?.last);
     if (usage) this.latestUsage = usage;
   }
 
@@ -775,6 +585,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
   }
 
   private handleErrorNotification(params: RpcRecord): void {
+    if (params.willRetry === true) return;
     const error = asRecord(params.error);
     let errorMessage = "codex app-server reported an error";
     if (typeof params.message === "string") errorMessage = params.message;
@@ -883,8 +694,8 @@ class CodexAppServerDriverImpl implements AgentDriver {
     this.idleTimer = setTimeout(() => {
       this.idleTimer = null;
       if (this.interrupts.size > 0) return;
-      this.fail(`no event for ${this.config.idleTimeoutMs}ms`, "idle-timeout");
-    }, this.config.idleTimeoutMs);
+      this.fail(`no event for ${durationMs(this.config.idleTimeout)}ms`, "idle-timeout");
+    }, durationMs(this.config.idleTimeout));
   }
 
   private clearIdleTimer(): void {
@@ -942,12 +753,13 @@ class CodexExecDriverImpl implements AgentDriver {
       command: this.config.command,
       args: buildArgs(this.config),
       cwd,
-      env: this.config.env,
+      env: agentEnvironment(process.env, this.config.inheritEnv, this.config.env),
+      inheritEnv: false,
       protocol: "custom",
       parseEvent: makeParseEvent(this.config, cliVersion),
       formatPrompt: (prompt) => prompt,
       closeStdinAfterPrompt: true,
-      idleTimeoutMs: this.config.idleTimeoutMs,
+      idleTimeout: this.config.idleTimeout,
       maxLineBytes: this.config.maxLineBytes,
       maxInterrupts: 1,
     });
@@ -982,14 +794,34 @@ class CodexExecDriverImpl implements AgentDriver {
   }
 }
 
-export const codexDriver: DriverPlugin<CodexDriverConfig> = {
+export const codexDriver = defineDriver({
   name: "codex",
   configSchema: CodexDriverConfigSchema,
+  runtime: (config) => ({
+    commands: [config.command],
+    capabilities: {
+      interactive: config.interactionMode === "app-server",
+      "tool-calls": true,
+      "tool-results": true,
+      artifacts: true,
+      subagents: config.interactionMode === "app-server",
+      usage: true,
+      cost: false,
+      isolation: Boolean(config.isolation),
+    },
+  }),
+  experiment: {
+    version: "1",
+    prepare: prepareCodexExperimentConfig,
+    identity: (config, { rootDir }) =>
+      configuredClaudeSourceHashes({ name: "codex", config }, rootDir),
+  },
+  selectHarness: selectModelAndReasoningEffort,
   create: (config) =>
     config.interactionMode === "app-server"
       ? new CodexAppServerDriverImpl(config)
       : new CodexExecDriverImpl(config),
-};
+});
 
 export type { CodexDriverConfig };
 export { appItemProgress, buildAppServerArgs, buildArgs, CodexDriverConfigSchema, makeParseEvent };

package/src/drivers/copilot/README.md

@@ -0,0 +1,60 @@
+# Copilot driver
+
+The `copilot` driver runs GitHub Copilot CLI as an Agent Client Protocol (ACP)
+server (`copilot --acp`). Install the CLI and run `copilot login` before Lux
+starts it. Your GitHub plan must allow Copilot CLI model access.
+
+```ts
+{
+  name: "copilot",
+  config: {
+    model: "YOUR_COPILOT_MODEL",
+    reasoningEffort: "low",
+    allowTools: ["shell(git:*)"],
+  },
+}
+```
+
+`model` is required because Copilot's `auto` selection can pick any model in
+the plan. Lux passes `--model` and `--effort` on the command line. Copilot's
+`--effort` accepts `none` through `max`, but each model honors only a subset
+and silently falls back on the rest, so the harness catalog in
+`core/harness-catalogs/copilot.ts` records the levels per model id and Lux
+rejects a level the model does not honor. Models whose levels are not published
+(Gemini, Grok, Kimi, MAI) are listed with no effort. When no effort is set, a
+model with levels runs at `low`. When ACP advertises a model selector, Lux
+selects and verifies the requested model; otherwise it records the model as
+requested rather than confirmed. `lux doctor` compares the catalog's model ids with
+`copilot help config` and warns when they differ.
+
+Tool permission requests arrive as ACP `session/request_permission` calls and
+become `approve` interrupts. Lux answers with the one-operation option only and
+never selects a remembered grant. `allowTools` and `denyTools` pass Copilot
+permission patterns; `allowAllTools` approves everything, which turns the
+interactive capability off. The `ask_user` tool is disabled because Copilot has
+no ACP wire for it. `askUser: true` is rejected before launching the CLI;
+permission interrupts remain supported through the normal Lux answerer.
+
+Copilot loads its native workspace instructions and bundled GitHub MCP server
+by default, matching ordinary harness execution. Set `customInstructions: false`
+or `builtinMcps: false` to disable them for a specific evaluation. Auto-update is
+always off. The driver provides no ambient-configuration isolation: Copilot still
+reads `~/.copilot` settings, MCP configuration, and credentials. Usage and
+cost are recorded as unknown; `--usage-output-file` cannot be combined with
+`--acp`.
+
+The adapter has synthetic protocol and lifecycle tests plus an opt-in live
+smoke task: `mise run smoke:harnesses -- copilot` from the repository root.
+The live task uses your installed CLI, existing login, and model quota. CLI
+`1.0.83` passed the authenticated file-copy smoke on 2026-09-30 after the account
+received a Copilot seat and CLI access. A seat alone does not enable the CLI:
+check the organization's Copilot CLI policy when GitHub returns a feature-access
+403. Lux also recognizes the CLI's native authorization diagnostic as an error
+even when Copilot ends the turn normally.
+
+Protocol references:
+
+- [Copilot CLI command-line reference](https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-programmatic-reference)
+- [Copilot CLI permissions](https://docs.github.com/en/copilot/concepts/agents/copilot-cli/about-copilot-cli)
+- [ACP session modes](https://agentclientprotocol.com/protocol/session-modes)
+- [ACP tool calls and permissions](https://agentclientprotocol.com/protocol/tool-calls)