@prismatic-io/lux 0.0.2-preview.21 → 0.0.2-preview.22

package/src/assertions/rubric/internal.ts

@@ -232,19 +232,47 @@ export const summarizeEvents = (
   evidence?: RubricEvidence,
 ): string => {
   const lines: string[] = [];
-  const selected = events.filter((event) => eventSelected(event, evidence));
+  const groups: RunEvent[][] = [];
+  let previous: RunEvent | undefined;
+  for (const event of events) {
+    if (eventSelected(event, evidence)) {
+      const sameSpeaker =
+        event.type === "progress" &&
+        previous?.type === "progress" &&
+        event.kind === "agent-message" &&
+        previous.kind === "agent-message" &&
+        event.agent?.id === previous.agent?.id;
+      if (sameSpeaker && groups.length > 0) groups.at(-1)?.push(event);
+      else groups.push([event]);
+    }
+    previous = event;
+  }
   // Grading only the tail would silently hide the start of a long run from
   // the judge; make the omission explicit rather than invisible.
-  if (selected.length > cap) {
-    lines.push(`[... ${selected.length - cap} earlier events omitted ...]`);
+  if (groups.length > cap) {
+    lines.push(`[... ${groups.length - cap} earlier events omitted ...]`);
   }
-  const tail = cap === 0 ? [] : selected.slice(-cap);
+  const tailGroups = cap === 0 ? [] : groups.slice(-cap);
+  const tail = tailGroups.flat();
   const agentTextAllotments = allotAgentText(tail, evidence?.maxAgentChars ?? 30_000);
   const toolDetail = evidence?.toolDetail ?? "names";
   const toolText = allotToolText(tail, evidence?.maxToolChars ?? 20_000, toolDetail);
-  for (const event of tail) {
-    const line = eventLine(event, agentTextAllotments, toolText.allotments, toolText.rendered);
-    if (line !== null) lines.push(line);
+  for (const group of tailGroups) {
+    if (group.length > 1) {
+      const parts: string[] = [];
+      for (const event of group) {
+        if (event.type !== "progress") continue;
+        const text = (event.payload as { text?: unknown })?.text;
+        if (typeof text !== "string") continue;
+        const take = agentTextAllotments.get(event) ?? 0;
+        if (take > 0) parts.push(text.slice(0, take));
+        if (take < text.length && parts.at(-1) !== "… [truncated]") parts.push("… [truncated]");
+      }
+      lines.push(`agent: ${parts.join("")}`);
+    } else if (group[0]) {
+      const line = eventLine(group[0], agentTextAllotments, toolText.allotments, toolText.rendered);
+      if (line !== null) lines.push(line);
+    }
   }
   return lines.join("\n");
 };

package/src/drivers/antigravity/README.md

@@ -27,18 +27,30 @@ Lux writes one `user` event with the case prompt, closes stdin, and reads
 `init`, `step_update`, and `result` events. Tool steps become paired
 `tool-call` and `tool-result` events keyed by step index, response deltas become
 `agent-message` progress, other steps stay visible as `antigravity-step`
-progress, and the final `result` usage is recorded as agent usage. A `result`
-whose status is not `SUCCESS` is an error; `WAITING` means a tool permission
-could not be granted headlessly. Allow the tool in Antigravity's settings or set
-`skipPermissions: true` inside a disposable environment.
+progress, and the final `result` usage is recorded as agent usage. The terminal
+response is also retained as message evidence when it was not already streamed.
+Both `DONE` and `ERROR` tool steps close the corresponding tool call; failed
+steps retain their error message. A result with `denied_actions` is an error even
+when Antigravity reports `SUCCESS`. `WAITING` and other non-success statuses are
+also errors. Configure the required scoped permissions in Antigravity before a
+headless evaluation; Lux does not retry a denial with broader permissions.
+
+Each run creates a fresh Antigravity project and passes its canonical working
+directory through `--add-dir` and an explicit task-workspace prompt preamble.
+Set `project` to reuse an explicitly configured
+project, and `addDirs` for additional reference directories. Process cwd alone
+does not select an Antigravity project. Project selection does not grant tool
+permissions: Antigravity 1.2.10 can still deny workspace writes in headless mode.
+`skipPermissions` remains false by default and must be explicitly enabled to
+bypass tool permission checks.
 
 The headless protocol carries no user questions or permission prompts, so the
 driver is not interactive and declares no isolation: Antigravity still reads
 its user settings and conversation history. Controlled experiments are not
 declared.
 
-The adapter is covered by synthetic protocol and lifecycle tests. It has not
-been validated against an authenticated Antigravity session.
+Regression tests cover the `ERROR` tool step followed by `SUCCESS` with denied
+actions observed in an authenticated Antigravity 1.2.10 session.
 
 Protocol references:
 

package/src/drivers/antigravity/config.ts

@@ -8,9 +8,12 @@ export const AntigravityDriverConfigSchema = z
     model: z.string().min(1),
     reasoningEffort: z.enum(antigravityCatalog.efforts).optional(),
     agent: z.string().min(1).optional(),
+    /** Use an existing project; otherwise each run creates a fresh project. */
+    project: z.string().min(1).optional(),
+    addDirs: z.array(z.string().min(1)).default([]),
     /**
      * Auto-approve every tool permission. Off by default: a headless turn that
-     * needs approval ends with a WAITING result and Lux reports it as an error.
+     * needs approval can report WAITING or SUCCESS with denied_actions; both fail.
      */
     skipPermissions: z.boolean().default(false),
     /** Enable Antigravity's terminal sandbox restrictions. */
@@ -26,13 +29,16 @@ export const AntigravityDriverConfigSchema = z
 
 export type AntigravityDriverConfig = z.infer<typeof AntigravityDriverConfigSchema>;
 
-export const buildAntigravityArgs = (config: AntigravityDriverConfig): string[] => [
+export const buildAntigravityArgs = (config: AntigravityDriverConfig, cwd?: string): string[] => [
   "--input-format",
   "stream-json",
   "--output-format",
   "stream-json",
   "--model",
   config.model,
+  ...(config.project ? ["--project", config.project] : ["--new-project"]),
+  ...(cwd ? ["--add-dir", cwd] : []),
+  ...config.addDirs.flatMap((directory) => ["--add-dir", directory]),
   ...(config.reasoningEffort ? ["--effort", config.reasoningEffort] : []),
   ...(config.agent ? ["--agent", config.agent] : []),
   ...(config.skipPermissions ? ["--dangerously-skip-permissions"] : []),

package/src/drivers/antigravity/events.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import {
   type ParsedDriverEvent,
@@ -38,6 +39,9 @@ const ResultSchema = z.looseObject({
   status: z.string().optional(),
   response: z.string().optional(),
   error: z.string().optional(),
+  denied_actions: z
+    .array(z.looseObject({ action: z.string(), display_name: z.string().optional() }))
+    .optional(),
   num_turns: z.number().optional(),
   usage: z.unknown().optional(),
 });
@@ -64,8 +68,8 @@ const parseUsage = (raw: unknown): TokenUsage | null => {
   const usage = UsageSchema.safeParse(raw).data;
   if (!usage) return null;
   return {
-    input: Math.max(0, usage.input_tokens - usage.cache_read_tokens),
-    output: usage.output_tokens + usage.thinking_tokens,
+    input: usage.input_tokens,
+    output: usage.output_tokens,
     cacheRead: usage.cache_read_tokens,
     cacheCreation: 0,
   };
@@ -125,7 +129,7 @@ const toolStepEvents = (
       ),
     });
   }
-  if (step.state === "DONE") {
+  if (step.state === "DONE" || step.state === "ERROR") {
     openTools.delete(step.step_index);
     const error = step.tool_info?.error;
     events.push({
@@ -136,8 +140,12 @@ const toolStepEvents = (
           name,
           toolUseId,
           content: step.tool_info?.output ?? null,
-          isError: error !== undefined,
-          text: error?.message ?? outputText(step.tool_info?.output),
+          isError: step.state === "ERROR" || error !== undefined,
+          text:
+            error?.message ??
+            (step.state === "ERROR"
+              ? "Antigravity tool failed"
+              : outputText(step.tool_info?.output)),
         },
         ts,
       ),
@@ -179,6 +187,21 @@ const resultEvent = (
   conversationId: string | undefined,
   usage: TokenUsage | null,
 ): ParsedDriverEvent => {
+  if (result?.denied_actions?.length) {
+    return {
+      tag: "error",
+      error: {
+        exitReason: "error",
+        reason: `Antigravity could not complete because tool permissions were denied: ${result.denied_actions.map(({ action }) => action).join(", ")}`,
+        summary: {
+          deniedActions: result.denied_actions,
+          ...(result.response !== undefined ? { response: result.response } : {}),
+          ...(conversationId ? { conversationId } : {}),
+          ...(usage ? { usage } : { usageAvailability: "unavailable" }),
+        },
+      },
+    };
+  }
   if (result?.status === "SUCCESS") {
     return {
       tag: "done",
@@ -211,6 +234,8 @@ export const makeParseEvent = (config: AntigravityDriverConfig, cliVersion?: str
   const openTools = new Set<number>();
   let conversationId: string | undefined;
   let usage: TokenUsage | null = null;
+  let responseStep: number | undefined;
+  let responseHash = createHash("sha256");
   return (line: string): ParsedDriverEvent | ParsedDriverEvent[] | null => {
     let raw: unknown;
     try {
@@ -228,8 +253,38 @@ export const makeParseEvent = (config: AntigravityDriverConfig, cliVersion?: str
     if (event.event === "step_update") {
       if (!event.step_update) return null;
       usage = parseUsage(event.step_update.usage) ?? usage;
+      if (event.step_update.step_type === "agent_response") {
+        if (responseStep !== event.step_update.step_index) {
+          responseHash = createHash("sha256");
+          responseStep = event.step_update.step_index;
+        }
+        responseHash.update(event.step_update.text_delta ?? "");
+      }
       return stepEvents(event.step_update, openTools, Date.now());
     }
-    return resultEvent(event.result, conversationId, parseUsage(event.result?.usage) ?? usage);
+    const terminal = resultEvent(
+      event.result,
+      conversationId,
+      parseUsage(event.result?.usage) ?? usage,
+    );
+    if (
+      event.result?.response &&
+      createHash("sha256").update(event.result.response).digest("hex") !==
+        responseHash.copy().digest("hex")
+    ) {
+      return [
+        {
+          tag: "progress",
+          progress: {
+            id: "antigravity-final-response",
+            kind: "agent-message",
+            payload: { text: event.result.response },
+            ts: Date.now(),
+          },
+        },
+        terminal,
+      ];
+    }
+    return terminal;
   };
 };

package/src/drivers/antigravity/index.ts

@@ -1,3 +1,4 @@
+import { realpath } from "node:fs/promises";
 import {
   type AgentDriver,
   type Answer,
@@ -42,17 +43,20 @@ class AntigravityDriver implements AgentDriver {
 
   async start(ctx: StartContext): Promise<ReadyState> {
     if (this.inner) throw new Error("Antigravity driver cannot be started twice");
-    this.cwd = this.config.cwd ?? ctx.artifactsDir;
+    this.cwd = await realpath(this.config.cwd ?? ctx.artifactsDir);
     this.artifactsDir = ctx.artifactsDir;
     const cliVersion = await discoverCliVersion(this.config.command);
     const inner = await subprocessDriver.create({
       command: this.config.command,
-      args: buildAntigravityArgs(this.config),
+      args: buildAntigravityArgs(this.config, this.cwd),
       cwd: this.cwd,
       env: this.config.env,
       protocol: "custom",
       parseEvent: makeParseEvent(this.config, cliVersion),
-      formatPrompt: formatAntigravityPrompt,
+      formatPrompt: (prompt) =>
+        formatAntigravityPrompt(
+          `The task workspace is ${JSON.stringify(this.cwd)}. Treat that directory as the current directory for this task and create task artifacts there.\n\n${prompt}`,
+        ),
       closeStdinAfterPrompt: true,
       idleTimeoutMs: this.config.idleTimeoutMs,
       maxLineBytes: this.config.maxLineBytes,

package/src/drivers/codex/config.ts

@@ -115,6 +115,27 @@ const tomlValue = (value: CodexConfigValue): string => {
     .join(",")}}`;
 };
 
+// Codex shell snapshots can replace the launching process's PATH. Pin only
+// executable-search variables here; never put other environment secrets in argv.
+export const codexConfigOverrides = (
+  config: CodexDriverConfig,
+): Record<string, CodexConfigValue> => {
+  const authored = config.config ?? {};
+  const paths = Object.fromEntries(
+    Object.entries(config.env ?? {}).filter(
+      ([key]) => key.toUpperCase() === "PATH" || key.toUpperCase() === "PATHEXT",
+    ),
+  );
+  if (Object.keys(paths).length === 0) return authored;
+  const object = (value: CodexConfigValue | undefined): Record<string, CodexConfigValue> =>
+    value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const policy = object(authored.shell_environment_policy);
+  return {
+    ...authored,
+    shell_environment_policy: { ...policy, set: { ...paths, ...object(policy.set) } },
+  };
+};
+
 export const buildExecArgs = (config: CodexDriverConfig): string[] => {
   const args = ["exec", "--json", "--color", "never", "--sandbox", config.sandbox];
   args.push("--model", config.model);
@@ -125,7 +146,7 @@ export const buildExecArgs = (config: CodexDriverConfig): string[] => {
   if (config.ignoreRules) args.push("--ignore-rules");
   if (config.strictConfig) args.push("--strict-config");
   for (const directory of config.addDirs ?? []) args.push("--add-dir", directory);
-  for (const [key, value] of Object.entries(config.config ?? {})) {
+  for (const [key, value] of Object.entries(codexConfigOverrides(config))) {
     args.push("--config", `${key}=${tomlValue(value)}`);
   }
   args.push(...effortArgs(config));
@@ -137,7 +158,7 @@ export const buildExecArgs = (config: CodexDriverConfig): string[] => {
 export const buildAppServerArgs = (config: CodexDriverConfig): string[] => {
   const args = ["app-server", "--stdio"];
   if (config.strictConfig) args.push("--strict-config");
-  for (const [key, value] of Object.entries(config.config ?? {})) {
+  for (const [key, value] of Object.entries(codexConfigOverrides(config))) {
     args.push("--config", `${key}=${tomlValue(value)}`);
   }
   args.push(...effortArgs(config));

package/src/drivers/codex/index.ts

@@ -41,6 +41,7 @@ import {
   type CodexConfigValue,
   type CodexDriverConfig,
   CodexDriverConfigSchema,
+  codexConfigOverrides,
 } from "./config.js";
 
 import { makeParseEvent } from "./exec-events.js";
@@ -189,7 +190,7 @@ class CodexAppServerDriverImpl implements AgentDriver {
       ? await Promise.all(this.config.isolation.allowRead.map((path) => realpath(path)))
       : [];
     const threadConfig: Record<string, CodexConfigValue> = {
-      ...(this.config.config ?? {}),
+      ...codexConfigOverrides(this.config),
       ...(this.config.reasoningEffort
         ? { model_reasoning_effort: this.config.reasoningEffort }
         : {}),

package/src/drivers/subprocess/index.ts

@@ -148,7 +148,7 @@ class SubprocessDriverImpl implements AgentDriver {
       throw new Error(`subprocess fixture values exceed ${MAX_FIXTURE_VALUES_BYTES} bytes`);
     }
     const managed = spawnManagedProcess(this.config.command, this.config.args ?? [], {
-      cwd: this.config.cwd ?? ctx.runDir,
+      cwd: this.config.cwd ?? ctx.artifactsDir,
       env: {
         ...(this.config.inheritEnv === false ? {} : process.env),
         ...this.config.env,

package/src/orchestrator/run-execution.ts

@@ -53,6 +53,7 @@ import {
   type RunFailurePhase,
   type RunLifecycleEffects,
 } from "./run-lifecycle.js";
+import { RunWorkspace } from "./run-workspace.js";
 import { isRunTraceLimit, type RunTraceLimitFailure } from "./trace-limits.js";
 
 /** Sentinel `casePath` for a pre-loaded case that has no file behind it. */
@@ -313,6 +314,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   private metadata: RunMetadata | undefined;
   private usage: RunUsage | undefined;
   private run: Run | undefined;
+  private workspace: RunWorkspace | undefined;
 
   private constructor(
     args: RunWithPluginsArgs,
@@ -369,10 +371,11 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     const { request, evalCase, casePath, driver } = this.args;
     this.lifecycle("run-loop");
     if (request.abortSignal?.aborted) return;
+    this.workspace = await RunWorkspace.create();
     const staged = await stageFixtures(evalCase.fixtures, {
       ...(request.fixturesRoot ? { fixturesRoot: request.fixturesRoot } : {}),
       casePath,
-      artifactsDir: this.runDir.artifactsDir,
+      artifactsDir: this.workspace.path,
     });
     this.fixturesHash = staged?.hash;
     if (request.abortSignal?.aborted) return;
@@ -387,7 +390,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       ...(this.args.fixtureValues.length > 0 ? { fixtureValues: this.args.fixtureValues } : {}),
       runsRoot: resolve(request.runsRoot),
       runDir: this.runDir.path,
-      artifactsDir: this.runDir.artifactsDir,
+      artifactsDir: this.workspace.path,
       abortSignal: request.abortSignal ?? new AbortController().signal,
     });
     this.append({ type: "ready", ...this.ready });
@@ -463,6 +466,12 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
   }
 
   async close(primaryError: unknown | null): Promise<void> {
+    if (this.workspace) {
+      await closeQuietly(async () => {
+        await this.args.driver.close();
+        await this.workspace?.archive(this.runDir.artifactsDir);
+      }, `run workspace ${this.workspace.path}`);
+    }
     if (primaryError instanceof Error) {
       (primaryError as Error & RunDirCarrier).luxRunDir = this.runDir.path;
     }
@@ -567,7 +576,11 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
     if (!this.ready) return { artifacts: [] };
     try {
       await this.args.driver.quiesce?.();
-      return { artifacts: await this.args.driver.collect() };
+      const artifacts = await this.args.driver.collect();
+      return {
+        artifacts:
+          (await this.workspace?.archive(this.runDir.artifactsDir, artifacts)) ?? artifacts,
+      };
     } catch (error) {
       const reason = errorMessage(error);
       this.runDir.events.append({

package/src/orchestrator/run-workspace.ts

@@ -0,0 +1,62 @@
+import { cp, lstat, mkdir, mkdtemp, realpath, rename, rm, rmdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { Artifact } from "../core/index.js";
+
+/** Keep package-manager discovery and repository ignore rules outside subject workspaces. */
+export class RunWorkspace {
+  private archived = false;
+  readonly path: string;
+
+  private constructor(path: string) {
+    this.path = path;
+  }
+
+  static async create(): Promise<RunWorkspace> {
+    const root = join(tmpdir(), `lux-workspaces-${process.getuid?.() ?? "user"}`);
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const metadata = await lstat(root);
+    if (
+      !metadata.isDirectory() ||
+      metadata.isSymbolicLink() ||
+      (process.getuid && metadata.uid !== process.getuid())
+    ) {
+      throw new Error(
+        `Lux workspace root must be a real directory owned by the current user: ${root}`,
+      );
+    }
+    return new RunWorkspace(await realpath(await mkdtemp(join(root, "run-"))));
+  }
+
+  async archive(destination: string, artifacts: Artifact[] = []): Promise<Artifact[]> {
+    if (!this.archived) {
+      const metadata = await lstat(this.path);
+      if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new Error(`run workspace must remain a real directory: ${this.path}`);
+      }
+      await rmdir(destination).catch((error: NodeJS.ErrnoException) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+      try {
+        await rename(this.path, destination);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "EXDEV") throw error;
+        await cp(this.path, destination, { recursive: true, verbatimSymlinks: true });
+        await rm(this.path, { recursive: true });
+      }
+      this.archived = true;
+    }
+    return artifacts.map((artifact) => {
+      if (!artifact.root) return artifact;
+      const path = relative(this.path, resolve(artifact.root));
+      if (path === "") {
+        const { root: _root, ...captured } = artifact;
+        return captured;
+      }
+      if (path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path)) {
+        return artifact;
+      }
+      return { ...artifact, root: join(destination, path) };
+    });
+  }
+}