test: close selected coverage gaps

src/server/machines/machineService.test.ts

@@ -2,6 +2,9 @@ import { chmod, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PiWebRuntimeResponse } from "../../shared/apiTypes.js";
+import { PI_WEB_CAPABILITIES } from "../../shared/capabilities.js";
+import type { MachineClient } from "./machineClient.js";
 import { MachineService } from "./machineService.js";
 import { MachineStore, machineStorePath } from "./machineStore.js";
 
@@ -97,6 +100,90 @@ describe("MachineService", () => {
     });
   });
 
+  it("fetches and caches remote runtime through the configured client", async () => {
+    const body = remoteRuntimeBody();
+    const requestJson = vi.fn<MachineClient["requestJson"]>(() => Promise.resolve({ statusCode: 200, headers: {}, body }));
+    const factoryMachines: unknown[] = [];
+    const remoteService = new MachineService(new MachineStore(storePath), {
+      remoteClientFactory: (machine) => {
+        factoryMachines.push(machine);
+        return fakeRemoteClient({ requestJson });
+      },
+      now: () => new Date("2026-05-25T00:00:00.000Z"),
+      runtimeCacheTtlMs: 10_000,
+    });
+    const machine = await remoteService.add({
+      name: " Remote ",
+      baseUrl: "https://remote.example.test/",
+      token: "secret",
+      headers: { "X-Pi-Web-Test": "yes" },
+    });
+
+    const first = await remoteService.runtime(machine.id);
+    const second = await remoteService.runtime(machine.id);
+
+    expect(first).toEqual({
+      machineId: machine.id,
+      ok: true,
+      checkedAt: "2026-05-25T00:00:00.000Z",
+      packageName: body.packageName,
+      generatedAt: body.generatedAt,
+      components: body.components,
+      capabilities: body.capabilities,
+    });
+    expect(second).toEqual(first);
+    expect(requestJson).toHaveBeenCalledTimes(1);
+    expect(requestJson).toHaveBeenCalledWith("GET", "/api/pi-web/runtime", undefined, { timeoutMs: 3000 });
+    expect(factoryMachines).toEqual([
+      expect.objectContaining({
+        id: machine.id,
+        name: "Remote",
+        baseUrl: "https://remote.example.test",
+        token: "secret",
+        headers: { "X-Pi-Web-Test": "yes" },
+      }),
+    ]);
+  });
+
+  it("caches remote runtime errors and clears them after remote updates", async () => {
+    let now = new Date("2026-05-25T00:00:00.000Z");
+    const body = remoteRuntimeBody();
+    const requestJson = vi.fn<MachineClient["requestJson"]>()
+      .mockRejectedValueOnce(new Error("network down"))
+      .mockResolvedValueOnce({ statusCode: 200, headers: {}, body });
+    const remoteService = new MachineService(new MachineStore(storePath), {
+      remoteClientFactory: () => fakeRemoteClient({ requestJson }),
+      now: () => now,
+      runtimeCacheTtlMs: 10_000,
+    });
+    const machine = await remoteService.add({ name: "Remote", baseUrl: "https://remote.example.test" });
+
+    const errorRuntime = await remoteService.runtime(machine.id);
+    now = new Date("2026-05-25T00:00:01.000Z");
+    const cachedErrorRuntime = await remoteService.runtime(machine.id);
+    await remoteService.update(machine.id, { name: "Remote Updated" });
+    now = new Date("2026-05-25T00:00:02.000Z");
+    const refreshedRuntime = await remoteService.runtime(machine.id);
+
+    expect(errorRuntime).toEqual({
+      machineId: machine.id,
+      ok: false,
+      checkedAt: "2026-05-25T00:00:00.000Z",
+      error: "network down",
+    });
+    expect(cachedErrorRuntime).toEqual(errorRuntime);
+    expect(refreshedRuntime).toEqual({
+      machineId: machine.id,
+      ok: true,
+      checkedAt: "2026-05-25T00:00:02.000Z",
+      packageName: body.packageName,
+      generatedAt: body.generatedAt,
+      components: body.components,
+      capabilities: body.capabilities,
+    });
+    expect(requestJson).toHaveBeenCalledTimes(2);
+  });
+
   it("does not allow local machine mutation", async () => {
     await expect(service.update("local", { name: "Other" })).rejects.toThrow("Local machine cannot be changed");
     await expect(service.remove("local")).rejects.toThrow("Local machine cannot be deleted");
@@ -112,3 +199,36 @@ async function expectOwnerOnlyMachineStore(path: string): Promise<void> {
   if (process.platform === "win32") return;
   expect((await stat(path)).mode & 0o777).toBe(0o600);
 }
+
+function remoteRuntimeBody(): PiWebRuntimeResponse {
+  return {
+    packageName: "@jmfederico/pi-web",
+    generatedAt: "2026-05-25T00:00:00.000Z",
+    components: {
+      web: {
+        component: "web",
+        label: "Remote Web",
+        runtimeVersion: "1.0.0",
+        available: true,
+        capabilities: [PI_WEB_CAPABILITIES.sessionsDeleteArchived, PI_WEB_CAPABILITIES.piPackagesManage],
+      },
+      sessiond: {
+        component: "sessiond",
+        label: "Remote Session daemon",
+        runtimeVersion: "1.0.0",
+        available: true,
+        capabilities: [PI_WEB_CAPABILITIES.sessionsDeleteArchived],
+      },
+    },
+    capabilities: [PI_WEB_CAPABILITIES.sessionsDeleteArchived, PI_WEB_CAPABILITIES.piPackagesManage],
+  };
+}
+
+function fakeRemoteClient(overrides: Partial<MachineClient>): MachineClient {
+  return {
+    request: () => { throw new Error("HTTP request not configured for test"); },
+    requestJson: () => { throw new Error("JSON request not configured for test"); },
+    connectWebSocket: () => { throw new Error("WebSocket not configured for test"); },
+    ...overrides,
+  };
+}

src/server/piWebStatusCache.test.ts

@@ -31,6 +31,49 @@ describe("createPiWebStatusCache", () => {
     expect(load).toHaveBeenCalledTimes(2);
   });
 
+  it("explicitly refreshes and replaces a fresh cached status", async () => {
+    let now = 1_000;
+    const load = vi.fn()
+      .mockResolvedValueOnce(status("first"))
+      .mockResolvedValueOnce(status("second"));
+    const cache = createPiWebStatusCache(load, { ttlMs: 100, now: () => now });
+
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "first" });
+    now = 1_050;
+
+    await expect(cache.refresh()).resolves.toMatchObject({ generatedAt: "second" });
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "second" });
+    expect(load).toHaveBeenCalledTimes(2);
+  });
+
+  it("retains stale status and reports background refresh errors", async () => {
+    let now = 1_000;
+    const refreshError = new Error("refresh failed");
+    const errorReported = createDeferred<unknown>();
+    const onError = vi.fn((error: unknown) => {
+      errorReported.resolve(error);
+    });
+    const load = vi.fn()
+      .mockResolvedValueOnce(status("first"))
+      .mockRejectedValueOnce(refreshError)
+      .mockResolvedValueOnce(status("second"));
+    const cache = createPiWebStatusCache(load, { ttlMs: 100, now: () => now, onError });
+
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "first" });
+    now = 1_101;
+
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "first" });
+    await expect(errorReported.promise).resolves.toBe(refreshError);
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(load).toHaveBeenCalledTimes(2);
+
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "first" });
+    await waitForMicrotasks();
+
+    await expect(cache.get()).resolves.toMatchObject({ generatedAt: "second" });
+    expect(load).toHaveBeenCalledTimes(3);
+  });
+
   it("deduplicates concurrent cold loads", async () => {
     const deferred = createDeferred<PiWebStatusResponse>();
     const load = vi.fn(() => deferred.promise);

src/server/sessiond/sessionProxyRoutes.test.ts

@@ -36,6 +36,40 @@ describe("machine-scoped session proxy routes", () => {
     expect(daemon.requests).toEqual([{ method: "POST", path: "/auth/api-key", body: { providerId: "p", key: "k" } }]);
   });
 
+  it("forwards sessiond health and runtime aliases to daemon endpoints", async () => {
+    const healthResponse = await app.inject({ method: "GET", url: "/api/machines/local/sessiond/health" });
+    const runtimeResponse = await app.inject({ method: "GET", url: "/api/machines/local/sessiond/runtime" });
+
+    expect(healthResponse.statusCode).toBe(200);
+    expect(healthResponse.json()).toEqual({ ok: true });
+    expect(runtimeResponse.statusCode).toBe(200);
+    expect(runtimeResponse.json()).toEqual({ ok: true });
+    expect(daemon.requests).toEqual([
+      { method: "GET", path: "/health", body: undefined },
+      { method: "GET", path: "/runtime", body: undefined },
+    ]);
+  });
+
+  it("forwards empty upstream responses without parsing a body", async () => {
+    daemon.respondWith({ statusCode: 204, headers: {}, body: "" });
+
+    const response = await app.inject({ method: "DELETE", url: "/api/machines/local/sessions/session-1" });
+
+    expect(response.statusCode).toBe(204);
+    expect(response.body).toBe("");
+    expect(daemon.requests).toEqual([{ method: "DELETE", path: "/sessions/session-1", body: undefined }]);
+  });
+
+  it("returns a 502 response when the daemon request fails", async () => {
+    daemon.failWith(new Error("connection refused"));
+
+    const response = await app.inject({ method: "GET", url: "/api/machines/local/sessions" });
+
+    expect(response.statusCode).toBe(502);
+    expect(response.json()).toEqual({ error: "Session daemon unavailable: connection refused" });
+    expect(daemon.requests).toEqual([{ method: "GET", path: "/sessions", body: undefined }]);
+  });
+
   it("preserves cwd query context when forwarding session event websockets", async () => {
     await app.listen({ host: "127.0.0.1", port: 0 });
     const socket = new WebSocket(`${serverUrl(app)}/api/machines/local/sessions/session-1/events?cwd=${encodeURIComponent("/repo")}`);
@@ -49,9 +83,16 @@ describe("machine-scoped session proxy routes", () => {
   });
 });
 
+interface FakeSessionDaemonResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+  body: string;
+}
+
 class FakeSessionDaemon {
   readonly requests: { method: string; path: string; body: unknown }[] = [];
   readonly websocketPaths: string[] = [];
+  private readonly queuedResponses: (FakeSessionDaemonResponse | Error)[] = [];
   private readonly sockets = new Set<WebSocket>();
 
   private constructor(private readonly upstream: WebSocketServer) {
@@ -67,9 +108,19 @@ class FakeSessionDaemon {
     return new FakeSessionDaemon(upstream);
   }
 
-  request(method: string, path: string, body?: unknown): Promise<{ statusCode: number; headers: Record<string, string>; body: string }> {
+  respondWith(response: FakeSessionDaemonResponse): void {
+    this.queuedResponses.push(response);
+  }
+
+  failWith(error: Error): void {
+    this.queuedResponses.push(error);
+  }
+
+  request(method: string, path: string, body?: unknown): Promise<FakeSessionDaemonResponse> {
     this.requests.push({ method, path, body });
-    return Promise.resolve({ statusCode: 200, headers: { "content-type": "application/json" }, body: JSON.stringify({ ok: true }) });
+    const queuedResponse = this.queuedResponses.shift();
+    if (queuedResponse instanceof Error) return Promise.reject(queuedResponse);
+    return Promise.resolve(queuedResponse ?? { statusCode: 200, headers: { "content-type": "application/json" }, body: JSON.stringify({ ok: true }) });
   }
 
   connectWebSocket(path: string): WebSocket {

src/server/sessions/attachmentService.test.ts

@@ -1,13 +1,21 @@
 import { mkdir, mkdtemp, readFile, readdir, rm, symlink } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { DEFAULT_ATTACHMENT_FOLDER, saveAttachmentsToWorkspace } from "./attachmentService.js";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { formatDimensionNote, resizeImage, type ResizedImage } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_ATTACHMENT_FOLDER, attachmentsToInlineImages, saveAttachmentsToWorkspace } from "./attachmentService.js";
+
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  formatDimensionNote: vi.fn(),
+  resizeImage: vi.fn(),
+}));
 
 let workspace: string;
 let externalDirectories: string[] = [];
 
 beforeEach(async () => {
+  vi.mocked(formatDimensionNote).mockReset();
+  vi.mocked(resizeImage).mockReset();
   workspace = await mkdtemp(join(tmpdir(), "pi-web-attachments-"));
   externalDirectories = [];
 });
@@ -22,6 +30,63 @@ afterEach(async () => {
 const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
 const pngBase64 = pngBytes.toString("base64");
 
+function resizedImage(overrides: Partial<ResizedImage> = {}): ResizedImage {
+  return {
+    data: "resized-data",
+    mimeType: "image/png",
+    originalWidth: 2400,
+    originalHeight: 1200,
+    width: 1200,
+    height: 600,
+    wasResized: true,
+    ...overrides,
+  };
+}
+
+describe("attachmentsToInlineImages", () => {
+  it("resizes images, drops unresizable images, and preserves dimension notes", async () => {
+    const firstInput = Buffer.from("first image");
+    const droppedInput = Buffer.from("too large");
+    const thirdInput = Buffer.from("third image");
+    const firstResized = resizedImage({ data: "first-resized", mimeType: "image/webp" });
+    const thirdResized = resizedImage({
+      data: "third-resized",
+      mimeType: "image/jpeg",
+      originalWidth: 640,
+      originalHeight: 480,
+      width: 640,
+      height: 480,
+      wasResized: false,
+    });
+
+    vi.mocked(resizeImage)
+      .mockResolvedValueOnce(firstResized)
+      .mockResolvedValueOnce(null)
+      .mockResolvedValueOnce(thirdResized);
+    vi.mocked(formatDimensionNote)
+      .mockReturnValueOnce("[Image dimensions changed.]")
+      .mockReturnValueOnce(undefined);
+
+    await expect(attachmentsToInlineImages([
+      { kind: "image", mimeType: "image/png", data: firstInput.toString("base64"), name: "first.png" },
+      { kind: "image", mimeType: "image/png", data: droppedInput.toString("base64"), name: "huge.png" },
+      { kind: "image", mimeType: "image/jpeg", data: thirdInput.toString("base64"), name: "photo.jpg" },
+    ])).resolves.toEqual([
+      {
+        image: { type: "image", data: "first-resized", mimeType: "image/webp" },
+        dimensionNote: "[Image dimensions changed.]",
+      },
+      { image: { type: "image", data: "third-resized", mimeType: "image/jpeg" } },
+    ]);
+
+    expect(resizeImage).toHaveBeenNthCalledWith(1, firstInput, "image/png");
+    expect(resizeImage).toHaveBeenNthCalledWith(2, droppedInput, "image/png");
+    expect(resizeImage).toHaveBeenNthCalledWith(3, thirdInput, "image/jpeg");
+    expect(formatDimensionNote).toHaveBeenNthCalledWith(1, firstResized);
+    expect(formatDimensionNote).toHaveBeenNthCalledWith(2, thirdResized);
+  });
+});
+
 describe("saveAttachmentsToWorkspace", () => {
   it("writes attachments into the default folder and returns relative paths", async () => {
     const fixedNow = () => new Date("2026-06-13T12:05:01.123Z");

src/server/sessions/authService.test.ts

@@ -1,6 +1,8 @@
 import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
+import type { OAuthFlowState } from "../../shared/apiTypes.js";
 import { AuthService, type AuthChange } from "./authService.js";
+import { OAuthLoginFlowService } from "./oauthLoginFlowService.js";
 
 describe("AuthService", () => {
   it("saves API keys and emits a global auth change", () => {
@@ -30,6 +32,39 @@ describe("AuthService", () => {
     expect(changes).toEqual([]);
     auth.dispose();
   });
+
+  it("refreshes auth state after OAuth login completes", () => {
+    const authStorage = AuthStorage.inMemory();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    const authFlows = new CapturingOAuthLoginFlowService();
+    const auth = new AuthService({ modelRegistry, authFlows });
+    const changes: AuthChange[] = [];
+    auth.subscribe((change) => { changes.push(change); });
+    const reload = vi.spyOn(authStorage, "reload");
+    const refresh = vi.spyOn(modelRegistry, "refresh");
+    const provider = authStorage.getOAuthProviders().find((option) => option.id === "anthropic");
+    if (provider === undefined) throw new Error("Expected built-in OAuth provider");
+
+    expect(auth.startOAuthLogin(provider.id)).toMatchObject({ providerId: provider.id, providerName: provider.name, status: "running" });
+
+    const startOptions = authFlows.startCalls.at(0);
+    if (startOptions === undefined) throw new Error("Expected OAuth flow to start");
+    expect(startOptions.providerId).toBe(provider.id);
+    expect(startOptions.providerName).toBe(provider.name);
+    expect(startOptions.authStorage).toBe(authStorage);
+    expect(changes).toEqual([]);
+
+    reload.mockClear();
+    refresh.mockClear();
+    if (startOptions.onComplete === undefined) throw new Error("Expected OAuth completion callback");
+    startOptions.onComplete();
+
+    expect(reload).toHaveBeenCalledOnce();
+    expect(refresh).toHaveBeenCalledOnce();
+    expect(changes).toEqual([{}]);
+    auth.dispose();
+    expect(authFlows.disposed).toBe(true);
+  });
 });
 
 function createAuthService(data: Parameters<typeof AuthStorage.inMemory>[0] = {}) {
@@ -40,3 +75,17 @@ function createAuthService(data: Parameters<typeof AuthStorage.inMemory>[0] = {}
   auth.subscribe((change) => { changes.push(change); });
   return { auth, authStorage, changes };
 }
+
+class CapturingOAuthLoginFlowService extends OAuthLoginFlowService {
+  readonly startCalls: Parameters<OAuthLoginFlowService["start"]>[0][] = [];
+  disposed = false;
+
+  override start(options: Parameters<OAuthLoginFlowService["start"]>[0]): OAuthFlowState {
+    this.startCalls.push(options);
+    return { flowId: "flow-1", providerId: options.providerId, providerName: options.providerName, status: "running", progress: [] };
+  }
+
+  override dispose(): void {
+    this.disposed = true;
+  }
+}

src/server/sessions/oauthLoginFlowService.test.ts

@@ -12,6 +12,7 @@ afterEach(() => {
 describe("OAuthLoginFlowService", () => {
   it("round-trips prompt responses and completes the flow", async () => {
     let promptValue: string | undefined;
+    const onComplete = vi.fn();
     const service = new OAuthLoginFlowService();
     const state = service.start({
       providerId: "test-provider",
@@ -22,6 +23,7 @@ describe("OAuthLoginFlowService", () => {
         promptValue = await callbacks.onPrompt({ message: "Paste code", placeholder: "code" });
         callbacks.onProgress?.(`Got ${promptValue}`);
       }),
+      onComplete,
     });
 
     const prompt = state.prompt;
@@ -35,6 +37,7 @@ describe("OAuthLoginFlowService", () => {
 
     expect(promptValue).toBe("abc123");
     expect(service.get(state.flowId)).toMatchObject({ status: "complete", progress: ["Waiting for code", "Got abc123", "Login complete"] });
+    expect(onComplete).toHaveBeenCalledOnce();
     service.dispose();
   });
 
@@ -113,6 +116,30 @@ describe("OAuthLoginFlowService", () => {
     service.dispose();
   });
 
+  it("rejects pending prompts when disposed", async () => {
+    const promptRejected = deferred<Error>();
+    const service = new OAuthLoginFlowService();
+    const state = service.start({
+      providerId: "test-provider",
+      providerName: "Test Provider",
+      authStorage: fakeAuthStorage(async (_providerId, callbacks) => {
+        try {
+          await callbacks.onPrompt({ message: "Paste code" });
+        } catch (error) {
+          promptRejected.resolve(toError(error));
+          throw error;
+        }
+      }),
+    });
+
+    expect(state.prompt).toBeDefined();
+
+    service.dispose();
+
+    await expect(promptRejected.promise).resolves.toMatchObject({ message: "Login cancelled" });
+    expect(() => { service.get(state.flowId); }).toThrow("OAuth login flow not found");
+  });
+
   it("rejects stale or duplicate responses", () => {
     const service = new OAuthLoginFlowService();
     const state = service.start({

src/server/terminals/terminalRoutes.test.ts

@@ -43,7 +43,7 @@ describe("terminal routes", () => {
     expect(terminals.events).toEqual([`close-cwd:${requestCwd}`]);
   });
 
-  it("routes command-run create, filter, cancel, and terminal continue requests", async () => {
+  it("routes command-run create, get, filter, cancel, and terminal continue requests", async () => {
     const createResponse = await app.inject({
       method: "POST",
       url: "/terminal-command-runs",
@@ -51,7 +51,16 @@ describe("terminal routes", () => {
     });
 
     expect(createResponse.statusCode).toBe(200);
-    expect(createResponse.json<TerminalCommandRun>()).toMatchObject({ id: "run1", terminalId: "t-run", status: "running" });
+    const createdRun = createResponse.json<TerminalCommandRun>();
+    expect(createdRun).toMatchObject({ id: "run1", terminalId: "t-run", status: "running" });
+
+    const getResponse = await app.inject({ method: "GET", url: "/terminal-command-runs/run1" });
+    expect(getResponse.statusCode).toBe(200);
+    expect(getResponse.json<TerminalCommandRun>()).toEqual(createdRun);
+
+    const missingGetResponse = await app.inject({ method: "GET", url: "/terminal-command-runs/missing" });
+    expect(missingGetResponse.statusCode).toBe(404);
+    expect(missingGetResponse.json()).toEqual({ error: "Terminal command run not found" });
 
     const listResponse = await app.inject({ method: "GET", url: `/terminal-command-runs?projectId=p1&statuses=running&metadata=${encodeURIComponent(JSON.stringify({ "pi.operation": "test" }))}` });
 
@@ -67,6 +76,22 @@ describe("terminal routes", () => {
     expect(continueResponse.statusCode).toBe(200);
     expect(terminals.events).toContain("continue:t-run");
   });
+
+  it("rejects invalid command-run filter and metadata queries", async () => {
+    const invalidStatusResponse = await app.inject({ method: "GET", url: "/terminal-command-runs?statuses=running,stuck" });
+    expect(invalidStatusResponse.statusCode).toBe(400);
+    expect(invalidStatusResponse.json()).toEqual({ error: "Invalid command run status: stuck" });
+
+    const arrayMetadataResponse = await app.inject({ method: "GET", url: `/terminal-command-runs?metadata=${encodeURIComponent(JSON.stringify(["not", "an", "object"]))}` });
+    expect(arrayMetadataResponse.statusCode).toBe(400);
+    expect(arrayMetadataResponse.json()).toEqual({ error: "metadata filter must be an object" });
+
+    const nonStringMetadataResponse = await app.inject({ method: "GET", url: `/terminal-command-runs?metadata=${encodeURIComponent(JSON.stringify({ "pi.operation": 42 }))}` });
+    expect(nonStringMetadataResponse.statusCode).toBe(400);
+    expect(nonStringMetadataResponse.json()).toEqual({ error: "metadata filter value must be a string: pi.operation" });
+
+    expect(terminals.filters).toEqual([]);
+  });
 });
 
 class FakeTerminals implements TerminalRouteService {

src/server/workspaces/fileContentService.test.ts

@@ -380,4 +380,16 @@ describe("moveWorkspaceFile", () => {
     expect(source.content).toBe("data");
     await expect(readFile(join(outsideDir, "evil.txt"), "utf8")).rejects.toMatchObject({ code: "ENOENT" });
   });
+
+  it("prevents moving a source symlink that escapes the workspace", async () => {
+    const root = await tempWorkspace();
+    const outsideDir = await mkdtemp(join(tmpdir(), "pi-web-move-source-outside-"));
+    roots.push(outsideDir);
+    await writeFile(join(outsideDir, "secret.txt"), "secret");
+    await symlink(join(outsideDir, "secret.txt"), join(root, "source-link.txt"));
+
+    await expect(moveWorkspaceFile(root, "source-link.txt", "moved.txt")).rejects.toThrow("Path escapes workspace");
+    await expect(readWorkspaceFile(root, "moved.txt")).rejects.toThrow("Path does not exist");
+    await expect(readFile(join(outsideDir, "secret.txt"), "utf8")).resolves.toBe("secret");
+  });
 });