@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/workspace-git-service.test.ts

@@ -5,6 +5,7 @@ import {
   mkdirSync,
   readFileSync,
   rmSync,
+  statSync,
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
@@ -87,6 +88,58 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("installs branch guard hook that blocks non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+
+      const hookPath = join(testDir, ".githooks", "reference-transaction");
+      expect(existsSync(hookPath)).toBe(true);
+      expect(statSync(hookPath).mode & 0o111).not.toBe(0);
+
+      const hookContent = readFileSync(hookPath, "utf-8");
+      expect(hookContent).toContain(
+        "assistant workspace git branches are disabled",
+      );
+
+      expect(() =>
+        execFileSync("git", ["branch", "apollo/test-branch"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
+    test("branch guard allows deleting old non-main branches", async () => {
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      execFileSync(
+        "git",
+        ["-c", "core.hooksPath=/dev/null", "branch", "old-branch"],
+        {
+          cwd: testDir,
+        },
+      );
+
+      execFileSync("git", ["branch", "-D", "old-branch"], { cwd: testDir });
+
+      const branches = execFileSync(
+        "git",
+        ["branch", "--format=%(refname:short)"],
+        {
+          cwd: testDir,
+          encoding: "utf-8",
+        },
+      );
+      expect(branches).not.toContain("old-branch");
+    });
+
     test("multiple ensureInitialized calls are idempotent", async () => {
       const service = new WorkspaceGitService(testDir);
 
@@ -368,11 +421,12 @@ describe("WorkspaceGitService", () => {
 
       await Promise.all(commits);
 
-      // All commits should have succeeded
-      const log = execFileSync("git", ["log", "--oneline"], {
-        cwd: testDir,
-        encoding: "utf-8",
-      });
+      // Read through the service so GIT_* vars set by CI runners are stripped
+      // (matches the env used for the commits themselves).
+      const { stdout: log } = await service.runReadOnlyGit([
+        "log",
+        "--oneline",
+      ]);
 
       for (let i = 0; i < 10; i++) {
         expect(log).toContain(`Add file ${i}`);
@@ -487,7 +541,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo on a feature branch
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -527,7 +581,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo then detach HEAD
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "content");
@@ -571,7 +625,7 @@ describe("WorkspaceGitService", () => {
       // This exercises the --discard-changes fallback in ensureOnMainLocked().
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, "file.txt"), "original content");
@@ -619,7 +673,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo without our gitignore rules
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       writeFileSync(join(testDir, ".gitignore"), "node_modules/\n");
@@ -648,7 +702,7 @@ describe("WorkspaceGitService", () => {
       // Set up a pre-existing git repo with the OLD broad data/ rule
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
       execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
-      execFileSync("git", ["config", "user.email", "test@test.com"], {
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
         cwd: testDir,
       });
       const oldGitignore =
@@ -711,6 +765,36 @@ describe("WorkspaceGitService", () => {
       expect(userEmail).toBe("assistant@vellum.ai");
     });
 
+    test("existing repo gets branch guard installed on init", async () => {
+      execFileSync("git", ["init", "-b", "main"], { cwd: testDir });
+      execFileSync("git", ["config", "user.name", "Test"], { cwd: testDir });
+      execFileSync("git", ["config", "user.email", "user@example.com"], {
+        cwd: testDir,
+      });
+      writeFileSync(join(testDir, "file.txt"), "content");
+      execFileSync("git", ["add", "-A"], { cwd: testDir });
+      execFileSync("git", ["commit", "-m", "init"], { cwd: testDir });
+
+      const service = new WorkspaceGitService(testDir);
+      await service.ensureInitialized();
+
+      const hooksPath = execFileSync("git", ["config", "core.hooksPath"], {
+        cwd: testDir,
+        encoding: "utf-8",
+      }).trim();
+      expect(hooksPath).toBe(".githooks");
+      expect(
+        existsSync(join(testDir, ".githooks", "reference-transaction")),
+      ).toBe(true);
+
+      expect(() =>
+        execFileSync("git", ["branch", "feature-after-init"], {
+          cwd: testDir,
+          encoding: "utf-8",
+        }),
+      ).toThrow(/assistant workspace git branches are disabled/);
+    });
+
     test("existing repo with correct config is idempotent", async () => {
       // Set up a repo that already has everything configured correctly
       execFileSync("git", ["init", "-b", "main"], { cwd: testDir });

package/src/__tests__/workspace-migration-088-deprecate-background-conversation-override.test.ts

@@ -0,0 +1,158 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { deprecateBackgroundConversationOverrideMigration } from "../workspace/migrations/088-deprecate-background-conversation-override.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-088-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function promptSystemDir(): string {
+  return join(workspaceDir, "prompts", "system");
+}
+
+function writeOverride(body: string): string {
+  const dir = promptSystemDir();
+  mkdirSync(dir, { recursive: true });
+  const filePath = join(dir, "08-background-conversation.md");
+  writeFileSync(filePath, body, "utf-8");
+  return filePath;
+}
+
+describe("088-deprecate-background-conversation-override migration", () => {
+  test("has expected id and description", () => {
+    expect(deprecateBackgroundConversationOverrideMigration.id).toBe(
+      "088-deprecate-background-conversation-override",
+    );
+    expect(
+      deprecateBackgroundConversationOverrideMigration.description,
+    ).toContain("08-background-conversation");
+  });
+
+  test("renames the override to .deprecated, preserving body", () => {
+    const body = "## Custom\n\nUser-customized background note.\n";
+    writeOverride(body);
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    const originalPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+
+    expect(existsSync(originalPath)).toBe(false);
+    expect(existsSync(deprecatedPath)).toBe(true);
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe(body);
+  });
+
+  test("no-ops when the override is absent", () => {
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(existsSync(deprecatedPath)).toBe(false);
+  });
+
+  test("does not touch unrelated section overrides", () => {
+    const dir = promptSystemDir();
+    mkdirSync(dir, { recursive: true });
+    const otherPath = join(dir, "07-external-content.md");
+    writeFileSync(otherPath, "## External Content\n\nUntouched.\n", "utf-8");
+    writeOverride("body");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    expect(readFileSync(otherPath, "utf-8")).toContain("Untouched");
+  });
+
+  test("is safe to re-run after the rename has happened", () => {
+    writeOverride("body");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe("body");
+  });
+
+  test("drops the .md and keeps the .deprecated copy when both exist", () => {
+    // A user re-created the override after a prior partial run. The bundled
+    // section is gone, so the .md would render unconditionally — drop it.
+    const dir = promptSystemDir();
+    mkdirSync(dir, { recursive: true });
+    const deprecatedPath = join(
+      dir,
+      "08-background-conversation.md.deprecated",
+    );
+    writeFileSync(deprecatedPath, "preserved.\n", "utf-8");
+    const recreatedPath = writeOverride("re-created body\n");
+
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    expect(existsSync(recreatedPath)).toBe(false);
+    expect(readFileSync(deprecatedPath, "utf-8")).toBe("preserved.\n");
+  });
+
+  test("down() restores the override when only .deprecated exists", () => {
+    writeOverride("body");
+    deprecateBackgroundConversationOverrideMigration.run(workspaceDir);
+
+    deprecateBackgroundConversationOverrideMigration.down(workspaceDir);
+
+    const overridePath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    const deprecatedPath = join(
+      promptSystemDir(),
+      "08-background-conversation.md.deprecated",
+    );
+    expect(existsSync(overridePath)).toBe(true);
+    expect(existsSync(deprecatedPath)).toBe(false);
+    expect(readFileSync(overridePath, "utf-8")).toBe("body");
+  });
+
+  test("down() is a no-op when only the .md exists", () => {
+    writeOverride("body");
+
+    expect(() =>
+      deprecateBackgroundConversationOverrideMigration.down(workspaceDir),
+    ).not.toThrow();
+
+    const overridePath = join(
+      promptSystemDir(),
+      "08-background-conversation.md",
+    );
+    expect(readFileSync(overridePath, "utf-8")).toBe("body");
+  });
+});

package/src/__tests__/workspace-migration-089-move-memory-tree-out-of-v3.test.ts

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { moveMemoryTreeOutOfV3Migration } from "../workspace/migrations/089-move-memory-tree-out-of-v3.js";
+
+describe("workspace migration 089 — move memory tree out of v3", () => {
+  let ws: string;
+
+  beforeEach(() => {
+    ws = fs.mkdtempSync(join(tmpdir(), "ws-mig-089-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(ws, { recursive: true, force: true });
+  });
+
+  function writeOldTree(): void {
+    const oldTree = join(ws, "memory", "v3", "tree");
+    fs.mkdirSync(join(oldTree, "people"), { recursive: true });
+    fs.writeFileSync(join(oldTree, "_root.md"), "root");
+    fs.writeFileSync(join(oldTree, "people", "alice.md"), "alice");
+  }
+
+  test("moves memory/v3/tree -> memory/tree (incl. nested) and drops the empty v3 wrapper", () => {
+    writeOldTree();
+    moveMemoryTreeOutOfV3Migration.run(ws);
+
+    expect(fs.existsSync(join(ws, "memory", "v3"))).toBe(false);
+    expect(
+      fs.readFileSync(join(ws, "memory", "tree", "_root.md"), "utf-8"),
+    ).toBe("root");
+    expect(
+      fs.readFileSync(
+        join(ws, "memory", "tree", "people", "alice.md"),
+        "utf-8",
+      ),
+    ).toBe("alice");
+  });
+
+  test("is idempotent — re-running after the move changes nothing", () => {
+    writeOldTree();
+    moveMemoryTreeOutOfV3Migration.run(ws);
+    moveMemoryTreeOutOfV3Migration.run(ws);
+
+    expect(
+      fs.readFileSync(join(ws, "memory", "tree", "_root.md"), "utf-8"),
+    ).toBe("root");
+  });
+
+  test("no-op on a fresh workspace with no old tree", () => {
+    moveMemoryTreeOutOfV3Migration.run(ws);
+    expect(fs.existsSync(join(ws, "memory", "tree"))).toBe(false);
+  });
+
+  test("never clobbers an existing memory/tree", () => {
+    writeOldTree();
+    const newTree = join(ws, "memory", "tree");
+    fs.mkdirSync(newTree, { recursive: true });
+    fs.writeFileSync(join(newTree, "_root.md"), "existing");
+
+    moveMemoryTreeOutOfV3Migration.run(ws);
+
+    // Destination preserved; source left in place for manual resolution.
+    expect(fs.readFileSync(join(newTree, "_root.md"), "utf-8")).toBe(
+      "existing",
+    );
+    expect(fs.existsSync(join(ws, "memory", "v3", "tree", "_root.md"))).toBe(
+      true,
+    );
+  });
+
+  test("down() restores memory/tree back to memory/v3/tree", () => {
+    const newTree = join(ws, "memory", "tree");
+    fs.mkdirSync(newTree, { recursive: true });
+    fs.writeFileSync(join(newTree, "_root.md"), "root");
+
+    moveMemoryTreeOutOfV3Migration.down(ws);
+
+    expect(fs.existsSync(join(ws, "memory", "tree"))).toBe(false);
+    expect(
+      fs.readFileSync(join(ws, "memory", "v3", "tree", "_root.md"), "utf-8"),
+    ).toBe("root");
+  });
+});

package/src/acp/__tests__/prepare-agent-env.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Tests for `prepareAgentEnv` — the shared helper that injects required env
+ * vars onto an `AcpAgentConfig` and preflights that they're set.
+ *
+ * The route-level test in `runtime/routes/acp-routes.test.ts` covers the same
+ * behavior through the HTTP handler; these tests pin the helper in isolation
+ * so the contract is clear and a future refactor can't silently break it.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub the secure-keys backend BEFORE importing the helper. Bun's
+// `mock.module` is process-global and only takes effect for imports that
+// follow it — the dynamic import below ensures correctness.
+const secureKeyStore = new Map<string, string>();
+
+mock.module("../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (key: string) => secureKeyStore.get(key),
+}));
+
+const { prepareAgentEnv } = await import("../prepare-agent-env.js");
+
+beforeEach(() => {
+  secureKeyStore.clear();
+});
+
+describe("prepareAgentEnv — claude-agent-acp gating", () => {
+  test("injects CLAUDE_CODE_OAUTH_TOKEN from the secure store when agent.env has no override", async () => {
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-AAA");
+
+    const prepared = await prepareAgentEnv({
+      command: "claude-agent-acp",
+      args: [],
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("vault-AAA");
+  });
+
+  test("accepts CLAUDE_CODE_OAUTH_TOKEN from agent.env (config.json override) with no vault entry", async () => {
+    const prepared = await prepareAgentEnv({
+      command: "claude-agent-acp",
+      args: [],
+      env: { CLAUDE_CODE_OAUTH_TOKEN: "config-BBB" },
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("config-BBB");
+  });
+
+  test("agent.env override wins over the secure-store entry (precedence pin)", async () => {
+    // The config-supplied env wins so users can rotate per-workspace without
+    // racing the vault. Mirrors the route-level precedence test.
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-CCC");
+
+    const prepared = await prepareAgentEnv({
+      command: "claude-agent-acp",
+      args: [],
+      env: { CLAUDE_CODE_OAUTH_TOKEN: "config-DDD" },
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("config-DDD");
+  });
+
+  test("preserves unrelated env vars on agent.env when injecting from the vault", async () => {
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-EEE");
+
+    const prepared = await prepareAgentEnv({
+      command: "claude-agent-acp",
+      args: [],
+      env: { OTHER_VAR: "keep-me" },
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("vault-EEE");
+    expect(prepared.env?.OTHER_VAR).toBe("keep-me");
+  });
+
+  test("throws FailedDependencyError when no token is provided from either route", async () => {
+    // secureKeyStore empty, no agent.env override — the preflight must throw
+    // so callers fail fast instead of spawning a zombie subprocess that the
+    // SDK rejects with 'Authentication required' after the first prompt.
+    await expect(
+      prepareAgentEnv({ command: "claude-agent-acp", args: [] }),
+    ).rejects.toThrow("CLAUDE_CODE_OAUTH_TOKEN");
+  });
+
+  test("gates on the resolved command BASENAME (alias to /custom/path/claude-agent-acp still gets the token)", async () => {
+    // A user-supplied `acp.agents.my-claude = { command: "/opt/.../claude-agent-acp" }`
+    // is the only realistic path that lands a non-bare basename here. The
+    // helper must still recognize it.
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-FFF");
+
+    const prepared = await prepareAgentEnv({
+      command: "/opt/bin/claude-agent-acp",
+      args: [],
+    });
+
+    expect(prepared.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe("vault-FFF");
+  });
+
+  test("does NOT mutate the caller's agentConfig", async () => {
+    // Callers pass `resolved.agent` which is shared state from the resolver's
+    // config cache. The helper must clone before mutating, otherwise repeated
+    // spawns would race on the same object.
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-GGG");
+    const original = {
+      command: "claude-agent-acp",
+      args: [],
+      env: { OTHER: "keep" },
+    };
+    const beforeEnv = { ...original.env };
+
+    const prepared = await prepareAgentEnv(original);
+
+    expect(prepared).not.toBe(original);
+    expect(prepared.env).not.toBe(original.env);
+    expect(original.env).toEqual(beforeEnv);
+    expect(original.env).not.toHaveProperty("CLAUDE_CODE_OAUTH_TOKEN");
+  });
+});
+
+describe("prepareAgentEnv — non-claude commands", () => {
+  test("returns the config unchanged for codex-acp (no required env vars today)", async () => {
+    // codex-acp inherits auth from the underlying `codex` CLI binary
+    // (codex login / CODEX_API_KEY / OPENAI_API_KEY in process.env) — no
+    // ACP-level env injection. Pin that contract so a future change has
+    // to update this test explicitly.
+    const prepared = await prepareAgentEnv({
+      command: "codex-acp",
+      args: [],
+    });
+
+    expect(prepared.env).toEqual({});
+  });
+
+  test("returns the config unchanged for an unrecognized command basename", async () => {
+    secureKeyStore.set("credential/acp/claude_oauth_token", "vault-HHH");
+
+    const prepared = await prepareAgentEnv({
+      command: "some-future-adapter",
+      args: [],
+      env: { FOO: "bar" },
+    });
+
+    // No injection — basename gate skipped.
+    expect(prepared.env).toEqual({ FOO: "bar" });
+  });
+});

package/src/acp/prepare-agent-env.ts

@@ -0,0 +1,78 @@
+/**
+ * Inject required env vars for an ACP agent and preflight that they're set.
+ *
+ * Called by every code path that hands an `AcpAgentConfig` to
+ * `AcpSessionManager.spawn`. There are TWO such paths today — the HTTP
+ * route `/v1/acp/spawn` (`runtime/routes/acp-routes.ts:spawnSession`) and
+ * the skill tool `acp_spawn` (`tools/acp/spawn.ts:executeAcpSpawn`) — and
+ * before this helper existed the env-injection logic lived inline in the
+ * route only. The skill-tool path bypassed it entirely, so spawns landed
+ * with no `CLAUDE_CODE_OAUTH_TOKEN`, the SDK rejected the first prompt
+ * with "Authentication required", and the subprocess died as a zombie
+ * with no completion notification.
+ *
+ * The fix: have this single helper own injection + preflight, and have
+ * every caller route through it before calling `manager.spawn`.
+ */
+
+import { basename } from "node:path";
+
+import { FailedDependencyError } from "../runtime/routes/errors.js";
+import { credentialKey } from "../security/credential-key.js";
+import { getSecureKeyAsync } from "../security/secure-keys.js";
+import type { AcpAgentConfig } from "./types.js";
+
+/**
+ * Returns a NEW config with any required credentials merged into `env`.
+ * Does NOT mutate the input. Throws `FailedDependencyError` if a required
+ * credential is missing from both the user-supplied env override and the
+ * secure store.
+ *
+ * Gating is keyed off the resolved agent COMMAND (basename), not the
+ * user-facing agent id, so a custom `acp.agents.my-claude = { command:
+ * "claude-agent-acp", ... }` alias still gets the env it needs.
+ *
+ * For `claude-agent-acp` the only required env var is
+ * `CLAUDE_CODE_OAUTH_TOKEN`. Two provisioning routes converge on it, with
+ * config.json winning over the vault so explicit user overrides
+ * (per-workspace, rotated, etc.) are never silently clobbered:
+ *   1. `acp.agents.<id>.env.CLAUDE_CODE_OAUTH_TOKEN` in `config.json` —
+ *      the user-supplied env override on the resolved agent config.
+ *   2. Secure store via CLI: `assistant credentials set --service acp \
+ *        --field claude_oauth_token <token>` — written to the canonical
+ *      `credential/{service}/{field}` key built by `credentialKey()`,
+ *      used as fallback when (1) is unset.
+ * After resolution, this asserts the token is present (from either route)
+ * before spawning. The "fail-fast" throw is symmetric with the existing
+ * `binary_not_found` preflight in `resolveAcpAgent` and strictly better
+ * than a `warn` + zombie subprocess 10 seconds later.
+ */
+export async function prepareAgentEnv(
+  agentConfig: AcpAgentConfig,
+): Promise<AcpAgentConfig> {
+  // Clone caller's config + env so we never mutate the resolver's cached
+  // agent reference. The local `env` binding sidesteps TS narrowing
+  // limitations on the optional `AcpAgentConfig.env` field.
+  const env: Record<string, string> = { ...(agentConfig.env ?? {}) };
+  const commandBasename = basename(agentConfig.command);
+
+  if (commandBasename === "claude-agent-acp") {
+    if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
+      const claudeToken = await getSecureKeyAsync(
+        credentialKey("acp", "claude_oauth_token"),
+      );
+      if (claudeToken) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = claudeToken;
+      }
+    }
+    if (!env.CLAUDE_CODE_OAUTH_TOKEN) {
+      throw new FailedDependencyError(
+        "claude-agent-acp requires CLAUDE_CODE_OAUTH_TOKEN. " +
+          "Run: assistant credentials set --service acp --field claude_oauth_token <token> " +
+          "(or set it under acp.agents.<id>.env in config.json).",
+      );
+    }
+  }
+
+  return { ...agentConfig, env };
+}

package/src/acp/session-manager.ts

@@ -306,7 +306,7 @@ export class AcpSessionManager {
    */
   private teardownSession(acpSessionId: string, entry: SessionEntry): void {
     for (const requestId of entry.clientHandler.pendingRequestIds) {
-      const interaction = pendingInteractions.resolve(requestId);
+      const interaction = pendingInteractions.resolve(requestId, "cancelled");
       if (interaction?.directResolve) {
         interaction.directResolve("deny");
       }

package/src/agent/attachments.ts

@@ -38,6 +38,7 @@ export function attachmentsToContentBlocks(
         filename: attachment.filename,
       },
       extracted_text: attachment.extractedText,
+      ...(attachment.id ? { _attachmentId: attachment.id } : {}),
     } as ContentBlock;
   });
 }