@vellumai/assistant 0.8.2 → 0.8.4

package/src/__tests__/server-history-render.test.ts

@@ -84,6 +84,82 @@ describe("renderHistoryContent", () => {
     );
   });
 
+  test("emits attachment:N entries in contentOrder for interleaved file blocks", () => {
+    const output = renderHistoryContent([
+      { type: "text", text: "first paragraph" },
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "text/markdown",
+          filename: "dream-015.md",
+          data: Buffer.from("a").toString("base64"),
+        },
+        _attachmentId: "att-015",
+      },
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "text/markdown",
+          filename: "dream-016.md",
+          data: Buffer.from("b").toString("base64"),
+        },
+        _attachmentId: "att-016",
+      },
+      { type: "text", text: "trailing paragraph" },
+    ]);
+
+    expect(output.contentOrder).toEqual([
+      "text:0",
+      "attachment:0",
+      "attachment:1",
+      "text:1",
+    ]);
+    expect(output.attachments).toEqual([
+      {
+        attachmentId: "att-015",
+        filename: "dream-015.md",
+        mimeType: "text/markdown",
+        sizeBytes: 1,
+      },
+      {
+        attachmentId: "att-016",
+        filename: "dream-016.md",
+        mimeType: "text/markdown",
+        sizeBytes: 1,
+      },
+    ]);
+    // Trailing-segment summary is preserved for legacy channel-reply
+    // delivery (Slack/Telegram outbound text) and iOS rehydrate.
+    expect(output.textSegments[1]).toContain("[File attachment] dream-015.md");
+  });
+
+  test("omits attachmentId when file block has no _attachmentId", () => {
+    const output = renderHistoryContent([
+      {
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "application/pdf",
+          filename: "legacy.pdf",
+          data: Buffer.from("x").toString("base64"),
+        },
+      },
+    ]);
+
+    // attachment:0 marks the file's inline position; text:0 follows because
+    // the legacy summary append (for Slack/iOS) opens a trailing segment.
+    expect(output.contentOrder).toEqual(["attachment:0", "text:0"]);
+    expect(output.attachments).toEqual([
+      {
+        filename: "legacy.pdf",
+        mimeType: "application/pdf",
+        sizeBytes: 1,
+      },
+    ]);
+  });
+
   test("falls back to string conversion for non-array content", () => {
     expect(renderHistoryContent("raw string").text).toBe("raw string");
     expect(renderHistoryContent(null).text).toBe("");
@@ -320,14 +396,17 @@ describe("renderHistoryContent", () => {
     expect(output.toolCallsBeforeText).toBe(false);
   });
 
-  test("handles orphan tool_result without matching tool_use", () => {
+  test("drops orphan tool_result without matching tool_use", () => {
     const output = renderHistoryContent([
       { type: "tool_result", tool_use_id: "missing", content: "some result" },
     ]);
 
-    expect(output.toolCalls).toEqual([
-      { name: "unknown", input: {}, result: "some result", isError: false },
-    ]);
+    // Orphans are dropped — without the parent tool_use we can't tell the user
+    // what tool ran, so the result is meaningless. See shared.ts comment.
+    expect(output.toolCalls).toEqual([]);
+    expect(output.text).toBe("");
+    expect(output.textSegments).toEqual([]);
+    expect(output.contentOrder).toEqual([]);
   });
 
   test("produces textSegments for text-tool-text interleaving", () => {

package/src/__tests__/steer-tool-repair.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Tests for the tool-result repair logic that runs during queue drain
+ * after a steer-to-message abort interrupts an in-flight tool call.
+ *
+ * Uses the exported drainQueue indirectly by testing the repair helper's
+ * observable effects on conversation.messages. We import the
+ * repairPendingToolUseBlocks behavior through drainQueue's contract.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { Message } from "../providers/types.js";
+
+/**
+ * Minimal reproduction of repairPendingToolUseBlocks logic for direct
+ * unit testing. The real implementation lives in conversation-process.ts.
+ * This mirrors it exactly to avoid needing the full ProcessConversationContext.
+ */
+function repairPendingToolUseBlocks(messages: Message[]): Message[] {
+  if (messages.length === 0) return messages;
+
+  const resolvedToolUseIds = new Set<string>();
+  const pendingToolUseIds: string[] = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.role === "user") {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          resolvedToolUseIds.add(block.tool_use_id);
+        }
+      }
+    } else if (msg.role === "assistant") {
+      for (const block of msg.content) {
+        if (block.type === "tool_use" && !resolvedToolUseIds.has(block.id)) {
+          pendingToolUseIds.push(block.id);
+        }
+      }
+      break;
+    }
+  }
+
+  if (pendingToolUseIds.length === 0) return messages;
+
+  const syntheticContent = pendingToolUseIds.map((toolUseId) => ({
+    type: "tool_result" as const,
+    tool_use_id: toolUseId,
+    content: "Tool execution was interrupted by user steering.",
+    is_error: true,
+  }));
+  messages.push({ role: "user", content: syntheticContent });
+  return messages;
+}
+
+describe("steer tool-result repair", () => {
+  test("no-op when messages are empty", () => {
+    const messages: Message[] = [];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(0);
+  });
+
+  test("no-op when last message is a user message", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(1);
+  });
+
+  test("no-op when last assistant message has no tool_use blocks", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "hi there" }],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(2);
+  });
+
+  test("no-op when tool_use has a matching tool_result", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "let me run a command" },
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "bash",
+            input: { command: "ls" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu_1",
+            content: "file1.txt\nfile2.txt",
+          },
+        ],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    // No synthetic message added
+    expect(messages).toHaveLength(3);
+  });
+
+  test("injects synthetic tool_result for a single pending tool_use", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "let me run a command" },
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "bash",
+            input: { command: "ls" },
+          },
+        ],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(3);
+
+    const synthetic = messages[2];
+    expect(synthetic.role).toBe("user");
+    expect(synthetic.content).toHaveLength(1);
+    expect(synthetic.content[0].type).toBe("tool_result");
+    if (synthetic.content[0].type === "tool_result") {
+      expect(synthetic.content[0].tool_use_id).toBe("tu_1");
+      expect(synthetic.content[0].is_error).toBe(true);
+      expect(synthetic.content[0].content).toContain("interrupted");
+    }
+  });
+
+  test("injects synthetic tool_results for multiple pending tool_use blocks", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "bash",
+            input: { command: "ls" },
+          },
+          {
+            type: "tool_use",
+            id: "tu_2",
+            name: "read_file",
+            input: { path: "/tmp/foo" },
+          },
+        ],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(3);
+
+    const synthetic = messages[2];
+    expect(synthetic.role).toBe("user");
+    expect(synthetic.content).toHaveLength(2);
+
+    const ids = synthetic.content
+      .filter((b) => b.type === "tool_result")
+      .map((b) => (b as { tool_use_id: string }).tool_use_id);
+    expect(ids).toContain("tu_1");
+    expect(ids).toContain("tu_2");
+  });
+
+  test("handles partial resolution — one of two tool_use blocks resolved", () => {
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "bash",
+            input: { command: "ls" },
+          },
+          {
+            type: "tool_use",
+            id: "tu_2",
+            name: "read_file",
+            input: { path: "/tmp/foo" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu_1",
+            content: "file1.txt",
+          },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "now reading the file" },
+          {
+            type: "tool_use",
+            id: "tu_3",
+            name: "write_file",
+            input: { path: "/tmp/bar", content: "test" },
+          },
+        ],
+      },
+    ];
+    repairPendingToolUseBlocks(messages);
+    expect(messages).toHaveLength(5);
+
+    const synthetic = messages[4];
+    expect(synthetic.role).toBe("user");
+    expect(synthetic.content).toHaveLength(1);
+    if (synthetic.content[0].type === "tool_result") {
+      expect(synthetic.content[0].tool_use_id).toBe("tu_3");
+      expect(synthetic.content[0].is_error).toBe(true);
+    }
+  });
+});

package/src/__tests__/system-prompt.test.ts

@@ -78,13 +78,14 @@ const {
 } = await import("../prompts/system-prompt.js");
 
 /**
- * Extract IDENTITY.md / BOOTSTRAP.md content + the user persona from the
- * dynamic block of the system prompt, stripping configuration, skills
- * catalog, and connected services.
+ * Extract BOOTSTRAP.md content + the user persona from the dynamic block
+ * of the system prompt, stripping configuration, skills catalog, and
+ * connected services.
  *
- * SOUL.md no longer flows through this helper — it renders as the
- * `09-soul` workspace-backed section in the static (cached) prefix.
- * Tests that assert on SOUL.md content slice the static block directly.
+ * Neither SOUL.md nor IDENTITY.md flows through this helper — they
+ * render as the `09-soul` and `08-identity` workspace-backed sections in
+ * the static (cached) prefix.  Tests that assert on their content slice
+ * the static block directly.
  */
 function basePrompt(result: string): string {
   // The workspace files are in the dynamic block after the cache boundary.
@@ -154,18 +155,30 @@ describe("buildSystemPrompt", () => {
       "# My Identity\n\nI am Vellum.",
     );
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("# My Identity\n\nI am Vellum.");
+    // IDENTITY.md renders as the `08-identity` workspace-backed section
+    // in the static (cached) prefix before SYSTEM_PROMPT_CACHE_BOUNDARY.
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    expect(result.slice(0, boundaryIdx)).toContain(
+      "# My Identity\n\nI am Vellum.",
+    );
   });
 
   test("composes IDENTITY.md + SOUL.md when both exist", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "# Identity\n\nI am Vellum.");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "# Soul\n\nBe thoughtful.");
     const result = buildSystemPrompt();
-    // SOUL renders as the workspace-backed section in the static prefix;
-    // IDENTITY renders in the dynamic suffix.
+    // Both render in the static (cached) prefix, IDENTITY before SOUL
+    // (sections `08-identity` and `09-soul`).
     const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(result.slice(0, boundaryIdx)).toContain("# Soul\n\nBe thoughtful.");
-    expect(basePrompt(result)).toBe("# Identity\n\nI am Vellum.");
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    expect(staticBlock).toContain("# Identity\n\nI am Vellum.");
+    expect(staticBlock).toContain("# Soul\n\nBe thoughtful.");
+    const identityIdx = staticBlock.indexOf("# Identity\n\nI am Vellum.");
+    const soulIdx = staticBlock.indexOf("# Soul\n\nBe thoughtful.");
+    expect(identityIdx).toBeLessThan(soulIdx);
+    expect(basePrompt(result)).toBe("");
   });
 
   test("ignores empty SOUL.md", () => {
@@ -217,10 +230,9 @@ describe("buildSystemPrompt", () => {
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul content");
 
     const result = buildSystemPrompt();
-    // After SOUL.md became the `09-soul` workspace-backed section, it
-    // renders in the static prefix while IDENTITY stays in the dynamic
-    // suffix — the two are no longer adjacent.  Verify both are present
-    // and the skills catalog is still suppressed.
+    // Both files render in the static prefix via `08-identity` /
+    // `09-soul`.  Verify both are present and the skills catalog is
+    // still suppressed.
     expect(result).toContain("Identity content");
     expect(result).toContain("Soul content");
     expect(result).not.toContain("## Available Skills");
@@ -262,11 +274,10 @@ describe("buildSystemPrompt", () => {
     writeFileSync(join(TEST_DIR, "IDENTITY.md"), "Identity");
     writeFileSync(join(TEST_DIR, "SOUL.md"), "Soul");
     const result = buildSystemPrompt();
-    // SOUL.md now renders in the static (cached) prefix via the 09-soul
-    // section, so it doesn't flow through basePrompt.  Assert that
-    // IDENTITY is the only dynamic content and that SOUL is still in the
-    // full prompt.
-    expect(basePrompt(result)).toBe("Identity");
+    // Both IDENTITY and SOUL render in the static (cached) prefix; the
+    // dynamic block sliced by basePrompt is empty here.
+    expect(basePrompt(result)).toBe("");
+    expect(result).toContain("Identity");
     expect(result).toContain("Soul");
   });
 
@@ -280,7 +291,8 @@ describe("buildSystemPrompt", () => {
     );
     const result = buildSystemPrompt();
     expect(result).not.toContain("stale user content");
-    expect(basePrompt(result)).toBe("Identity");
+    expect(result).toContain("Identity");
+    expect(basePrompt(result)).toBe("");
   });
 
   test("uses options.userPersona instead of USER.md", () => {
@@ -289,11 +301,10 @@ describe("buildSystemPrompt", () => {
     const result = buildSystemPrompt({
       userPersona: "# User persona\n\nName: Alice",
     });
-    // SOUL.md renders in the static (cached) prefix via the 09-soul section
-    // and is no longer part of the dynamic block sliced by basePrompt.
-    expect(basePrompt(result)).toBe(
-      "Identity\n\n# User persona\n\nName: Alice",
-    );
+    // IDENTITY and SOUL both render in the static (cached) prefix; only
+    // the user persona ends up in the dynamic block.
+    expect(basePrompt(result)).toBe("# User persona\n\nName: Alice");
+    expect(result).toContain("Identity");
     expect(result).toContain("Soul");
   });
 
@@ -480,7 +491,11 @@ describe("buildSystemPrompt", () => {
       "# Identity\n_ This is a comment\nI am Vellum.\n_ Another comment",
     );
     const result = buildSystemPrompt();
-    expect(basePrompt(result)).toBe("# Identity\nI am Vellum.");
+    // IDENTITY.md renders in the static prefix via the 08-identity section,
+    // so we assert against the full prompt rather than basePrompt.
+    expect(result).toContain("# Identity\nI am Vellum.");
+    expect(result).not.toContain("_ This is a comment");
+    expect(result).not.toContain("_ Another comment");
   });
 
   test("collapses whitespace around stripped comment lines", () => {
@@ -610,7 +625,15 @@ describe("buildSystemPrompt", () => {
       writeFileSync(join(TEST_DIR, "IDENTITY.md"), "I am Vellum.");
       const result = buildSystemPrompt();
       expect(result.startsWith("Custom prefix")).toBe(true);
-      expect(basePrompt(result)).toBe("I am Vellum.");
+      // IDENTITY.md renders via 08-identity in the static prefix after
+      // the 00-prefix slot.
+      const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+      const staticBlock = result.slice(0, boundaryIdx);
+      const prefixIdx = staticBlock.indexOf("Custom prefix");
+      const identityIdx = staticBlock.indexOf("I am Vellum.");
+      expect(prefixIdx).toBeGreaterThan(-1);
+      expect(identityIdx).toBeGreaterThan(prefixIdx);
+      expect(basePrompt(result)).toBe("");
     });
 
     test("parallel tool calls section is sourced from workspace when present", () => {
@@ -675,10 +698,7 @@ describe("buildSystemPrompt", () => {
       // so the bundled body must not leak into the rendered output.  This is
       // the explicit "user silenced this section" path.
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-      writeFileSync(
-        PARALLEL_FILE,
-        "---\nenabled: false\n---\nIgnored body.\n",
-      );
+      writeFileSync(PARALLEL_FILE, "---\nenabled: false\n---\nIgnored body.\n");
       const result = buildSystemPrompt();
       expect(result).not.toContain("<use_parallel_tool_calls>");
       expect(result).not.toContain("Batch independent tool calls");
@@ -713,7 +733,10 @@ describe("buildSystemPrompt", () => {
     });
 
     describe("containerized section (slot 02)", () => {
-      const CONTAINERIZED_FILE = join(SYSTEM_PROMPTS_DIR, "02-containerized.md");
+      const CONTAINERIZED_FILE = join(
+        SYSTEM_PROMPTS_DIR,
+        "02-containerized.md",
+      );
 
       // The runtime gate is `isContainerized` on the render context, sourced
       // from `getIsContainerized()` which reads `process.env.IS_CONTAINERIZED`.
@@ -1093,10 +1116,7 @@ describe("buildSystemPrompt", () => {
     });
 
     describe("external-content section (slot 07)", () => {
-      const EXTERNAL_FILE = join(
-        SYSTEM_PROMPTS_DIR,
-        "07-external-content.md",
-      );
+      const EXTERNAL_FILE = join(SYSTEM_PROMPTS_DIR, "07-external-content.md");
 
       test("workspace external-content file is rendered into the static block", () => {
         mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
@@ -1139,69 +1159,6 @@ describe("buildSystemPrompt", () => {
       });
     });
 
-    describe("background-conversation section (slot 08)", () => {
-      const BACKGROUND_FILE = join(
-        SYSTEM_PROMPTS_DIR,
-        "08-background-conversation.md",
-      );
-
-      test("bundled default renders when isBackgroundConversation is true", () => {
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: true });
-        expect(result).toContain("## Background Conversation");
-        expect(result).toContain("non-interactive background job");
-        expect(result).toContain("`notifications` skill");
-      });
-
-      test("bundled default is gated out when isBackgroundConversation is false", () => {
-        // Mustache `{{#isBackgroundConversation}}...{{/isBackgroundConversation}}`
-        // wraps the entire heading + body so the slot interpolates to empty
-        // in foreground conversations and the renderer drops it.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: false });
-        expect(result).not.toContain("## Background Conversation");
-      });
-
-      test("bundled default is gated out when isBackgroundConversation is omitted", () => {
-        // `ctx.isBackgroundConversation` is normalized to `false` when the
-        // caller omits the flag, so the gated section drops out cleanly.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt();
-        expect(result).not.toContain("## Background Conversation");
-      });
-
-      test("workspace override is also gated by isBackgroundConversation", () => {
-        // Workspace overrides flow through the same mustache interpolation,
-        // so authors can rely on the same `{{#isBackgroundConversation}}`
-        // gate in their custom body.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        writeFileSync(
-          BACKGROUND_FILE,
-          "{{#isBackgroundConversation}}## Background Conversation\n\nWorkspace override marker COMET_3K.\n{{/isBackgroundConversation}}\n",
-        );
-
-        const offResult = buildSystemPrompt({ isBackgroundConversation: false });
-        expect(offResult).not.toContain("## Background Conversation");
-        expect(offResult).not.toContain("Workspace override marker COMET_3K.");
-
-        const onResult = buildSystemPrompt({ isBackgroundConversation: true });
-        expect(onResult).toContain("## Background Conversation");
-        expect(onResult).toContain("Workspace override marker COMET_3K.");
-      });
-
-      test("renders after the external-content section when both render", () => {
-        // Numeric prefix `08-` > `07-` so the background-conversation
-        // section trails the external-content section in the static block.
-        mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
-        const result = buildSystemPrompt({ isBackgroundConversation: true });
-        const externalIdx = result.indexOf("## External Content");
-        const backgroundIdx = result.indexOf("## Background Conversation");
-        expect(externalIdx).toBeGreaterThan(-1);
-        expect(backgroundIdx).toBeGreaterThan(-1);
-        expect(externalIdx).toBeLessThan(backgroundIdx);
-      });
-    });
-
     test("unresolved {{variable}} is left as a literal in the body", () => {
       mkdirSync(SYSTEM_PROMPTS_DIR, { recursive: true });
       writeFileSync(
@@ -1211,7 +1168,6 @@ describe("buildSystemPrompt", () => {
       const result = buildSystemPrompt();
       expect(result).toContain("Has {{somethingMissing}} in body.");
     });
-
   });
 });
 

package/src/__tests__/terminal-tools.test.ts

@@ -67,6 +67,7 @@ mock.module("../tools/network/script-proxy/index.js", () => ({
 import {
   ALWAYS_INJECTED_ENV_VARS,
   buildSanitizedEnv,
+  KATA_INJECTED_ENV_VARS,
   KATA_SAFE_ENV_VARS,
   SAFE_ENV_VARS,
 } from "../tools/terminal/safe-env.js";
@@ -145,7 +146,7 @@ describe("buildSanitizedEnv", () => {
     process.env.VELLUM_SANDBOX_RUNTIME = "gvisor";
     process.env.PATH = "/usr/bin";
     process.env.VELLUM_APT_DATA_ROOT = "/data/system";
-    process.env.LD_LIBRARY_PATH = "/data/system/usr/lib";
+    process.env.LD_LIBRARY_PATH = "/host/lib";
 
     let env = buildSanitizedEnv();
     expect(env.VELLUM_APT_DATA_ROOT).toBeUndefined();
@@ -161,6 +162,7 @@ describe("buildSanitizedEnv", () => {
     expect(env.LD_LIBRARY_PATH.split(":")).toContain(
       "/data/system/usr/local/lib",
     );
+    expect(env.LD_LIBRARY_PATH.split(":")).not.toContain("/host/lib");
   });
 
   test("defaults LANG and LC_ALL to UTF-8 when unset", () => {
@@ -181,12 +183,20 @@ describe("buildSanitizedEnv", () => {
     delete process.env.GATEWAY_PORT;
   });
 
+  test("Kata entrypoint initializes apt root without inheriting apt loader paths", () => {
+    const entrypoint = readFileSync("docker-entrypoint.sh", "utf8");
+
+    expect(entrypoint).toContain("/app/assistant/docker-init-apt-root.sh");
+    expect(entrypoint).not.toContain(". /app/assistant/docker-kata-apt-env.sh");
+  });
+
   test("result is a plain object with no prototype-inherited secrets", () => {
     const env = buildSanitizedEnv();
     const keys = Object.keys(env);
     const safeKeys: string[] = [
       ...SAFE_ENV_VARS,
       ...KATA_SAFE_ENV_VARS,
+      ...KATA_INJECTED_ENV_VARS,
       ...ALWAYS_INJECTED_ENV_VARS,
     ];
     for (const key of keys) {