test: close selected coverage gaps

src/client/src/api/federatedRouteContract.test.ts

@@ -67,6 +67,7 @@ describe("federated route contract", () => {
       ignoreParseFailure(sessionsApi.cycleThinkingLevel(session, machineId)),
       ignoreParseFailure(sessionsApi.commands(session, machineId)),
       ignoreParseFailure(sessionsApi.prompt(session, "hello", "followUp", machineId)),
+      ignoreParseFailure(sessionsApi.saveAttachments(session, [{ kind: "image", mimeType: "image/png", data: "QUJD", name: "shot.png" }], machineId, "uploads")),
       ignoreParseFailure(sessionsApi.shell(session, "ls", machineId)),
       ignoreParseFailure(sessionsApi.runCommand(session, "/help", machineId)),
       ignoreParseFailure(sessionsApi.respondToCommand(session, "req 1", "yes", machineId)),

src/client/src/components/SettingsDialog.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { TemplateResult } from "lit";
 import { PI_WEB_CAPABILITIES } from "../../../shared/capabilities";
-import { configApi, pluginsApi, type Machine, type MachineRuntime, type PiWebConfigResponse, type PiWebConfigValues, type PiWebPluginInfo, type PiWebPluginsResponse } from "../api";
+import { configApi, piPackagesApi, pluginsApi, type Machine, type MachineRuntime, type PiPackageInfo, type PiPackageMutationResponse, type PiWebConfigResponse, type PiWebConfigValues, type PiWebPluginInfo, type PiWebPluginsResponse } from "../api";
 import { SettingsDialog } from "./SettingsDialog";
 
 afterEach(() => {
@@ -319,6 +319,76 @@ describe("settings-dialog general settings machine targeting", () => {
   });
 });
 
+describe("settings-dialog Pi package orchestration", () => {
+  it("loads package data from the selected machine and ignores stale target responses", async () => {
+    const remotePackages = { packages: [packageInfo("npm:@acme/tools")] };
+    const staleLoad = deferred<typeof remotePackages>();
+    const packagesSpy = vi.spyOn(piPackagesApi, "packages").mockReturnValue(staleLoad.promise);
+    const dialog = new SettingsDialog();
+    dialog.machine = remoteMachine;
+    dialog.machineRuntime = runtimeWithPackageManagement;
+
+    const loadPromise = callDialogPromise(dialog, "loadPackagesForTarget");
+    expect(packagesSpy.mock.calls).toEqual([["remote-a"]]);
+    expect(getDialogProperty(dialog, "packageLoading")).toBe(true);
+
+    dialog.machine = secondRemoteMachine;
+    callDialogUpdated(dialog, new Map([["machine", remoteMachine]]));
+    staleLoad.resolve(remotePackages);
+    await loadPromise;
+
+    expect(getDialogProperty(dialog, "packagesResponse")).toBeUndefined();
+    expect(getDialogProperty(dialog, "packageError")).toBe("");
+    expect(getDialogProperty(dialog, "packageMessage")).toBe("");
+    expect(getDialogProperty(dialog, "packageLoading")).toBe(false);
+  });
+
+  it("runs remote package mutations against the selected machine without refreshing gateway plugins", async () => {
+    const installedPackages = [packageInfo("npm:@acme/new-tools")];
+    const install = deferred<PiPackageMutationResponse>();
+    const installSpy = vi.spyOn(piPackagesApi, "install").mockReturnValue(install.promise);
+    const pluginsSpy = vi.spyOn(pluginsApi, "plugins").mockResolvedValue(pluginsResponse([pluginInfo("gateway", true)]));
+    const dialog = new SettingsDialog();
+    dialog.machine = remoteMachine;
+    dialog.machineRuntime = runtimeWithPackageManagement;
+
+    const installPromise = callDialogPromise(dialog, "installPiPackage", "npm:@acme/new-tools");
+
+    expect(installSpy.mock.calls).toEqual([["npm:@acme/new-tools", "remote-a"]]);
+    expect(getDialogProperty(dialog, "saving")).toBe(true);
+    expect(getDialogProperty(dialog, "packageOperation")).toEqual({ kind: "install", source: "npm:@acme/new-tools" });
+
+    install.resolve(packageMutationResponse("install", installedPackages, "npm:@acme/new-tools"));
+    await installPromise;
+
+    expect(pluginsSpy).not.toHaveBeenCalled();
+    expect(getDialogProperty(dialog, "packagesResponse")).toEqual({ packages: installedPackages });
+    expect(getDialogProperty(dialog, "packageMessage")).toContain("Pi package installed on Lab Mac");
+    expect(getDialogProperty(dialog, "packageMessage")).toContain("each idle PI WEB session on Lab Mac");
+    expect(getDialogProperty(dialog, "packageError")).toBe("");
+    expect(getDialogProperty(dialog, "packageOperation")).toBeUndefined();
+    expect(getDialogProperty(dialog, "saving")).toBe(false);
+  });
+
+  it("refreshes gateway plugins after a local package mutation", async () => {
+    const updatedPackages = [packageInfo("npm:@acme/tools")];
+    const refreshedPlugins = pluginsResponse([pluginInfo("browser-helper", true)]);
+    const updateSpy = vi.spyOn(piPackagesApi, "update").mockResolvedValue(packageMutationResponse("update", updatedPackages));
+    const pluginsSpy = vi.spyOn(pluginsApi, "plugins").mockResolvedValue(refreshedPlugins);
+    const dialog = new SettingsDialog();
+
+    await callDialogPromise(dialog, "updatePiPackage");
+
+    expect(updateSpy.mock.calls).toEqual([[undefined, "local"]]);
+    expect(pluginsSpy.mock.calls).toEqual([[]]);
+    expect(getDialogProperty(dialog, "packagesResponse")).toEqual({ packages: updatedPackages });
+    expect(getDialogProperty(dialog, "pluginsResponse")).toBe(refreshedPlugins);
+    expect(getDialogProperty(dialog, "packageMessage")).toContain("Reload the browser page separately for PI WEB browser plugin changes");
+    expect(getDialogProperty(dialog, "packageError")).toBe("");
+    expect(getDialogProperty(dialog, "saving")).toBe(false);
+  });
+});
+
 describe("settings-dialog plugin settings machine targeting", () => {
   it("loads plugin config and plugin list from the selected machine", async () => {
     const config = configResponse({ plugins: { info: { enabled: true } } });
@@ -502,13 +572,15 @@ const secondRemoteMachine: Machine = {
   updatedAt: "2026-07-01T00:00:00.000Z",
 };
 
-const runtimeWithoutSelectedMachineSettings: MachineRuntime = {
+const runtimeWithPackageManagement: MachineRuntime = {
   machineId: "remote-a",
   ok: true,
   checkedAt: "2026-07-01T00:00:00.000Z",
   capabilities: [PI_WEB_CAPABILITIES.piPackagesManage],
 };
 
+const runtimeWithoutSelectedMachineSettings: MachineRuntime = runtimeWithPackageManagement;
+
 function getDialogProperty(dialog: SettingsDialog, property: string): unknown {
   return Reflect.get(dialog, property);
 }
@@ -600,6 +672,14 @@ function pluginInfo(id: string, enabled: boolean): PiWebPluginInfo {
   };
 }
 
+function packageInfo(source: string): PiPackageInfo {
+  return { source, scope: "user", filtered: false, installedPath: `/pi/packages/${source}` };
+}
+
+function packageMutationResponse(action: PiPackageMutationResponse["action"], packages: PiPackageInfo[], source?: string): PiPackageMutationResponse {
+  return source === undefined ? { action, packages } : { action, source, packages };
+}
+
 interface Deferred<T> {
   promise: Promise<T>;
   resolve: (value: T) => void;

src/client/src/components/WorkspaceFilesPanel.test.ts

@@ -1,6 +1,43 @@
-import { describe, expect, it, vi } from "vitest";
+import type { TemplateResult } from "lit";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { initialAppState } from "../appState";
+import type { WorkspacePanelContext } from "../plugins/types";
 import type { WorkspaceUploadBatchState } from "../workspaceUploadState";
-import { startDirectWorkspaceUpload, uploadBatchProgressValue, uploadBatchStatusLabel, workspaceUploadBatchesForScope, workspaceUploadReviewDefaults, workspaceUploadReviewError } from "./WorkspaceFilesPanel";
+import { WorkspaceFilesPanel, startDirectWorkspaceUpload, uploadBatchProgressValue, uploadBatchStatusLabel, workspaceUploadBatchesForScope, workspaceUploadReviewDefaults, workspaceUploadReviewError } from "./WorkspaceFilesPanel";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("workspace-files-panel upload review", () => {
+  it("opens review from the hidden file input and submits selected files with defaults", () => {
+    vi.stubGlobal("HTMLInputElement", FakeHTMLInputElement);
+    const files = [new File(["a"], "a.txt"), new File(["b"], "b.txt")];
+    const onStartWorkspaceUpload = vi.fn<WorkspacePanelContext["onStartWorkspaceUpload"]>(() => ({ batchId: "batch-1", done: Promise.resolve() }));
+    const panel = new WorkspaceFilesPanel();
+    panel.context = workspacePanelContext({ workspaceUploadDefaultFolder: "project/uploads", onStartWorkspaceUpload });
+
+    const inputChange = findTemplateEventHandler<Event>(panel.render(), `id="workspace-upload-input"`);
+    const input = new FakeHTMLInputElement(files);
+    inputChange(new EventWithCurrentTarget("change", input));
+
+    expect(input.value).toBe("");
+    expect(onStartWorkspaceUpload).not.toHaveBeenCalled();
+
+    const submit = findTemplateEventHandler<SubmitEvent>(panel.render(), "<form @submit=");
+    const submitEvent = new FakeSubmitEvent("submit", { cancelable: true });
+    submit(submitEvent);
+
+    expect(submitEvent.defaultPrevented).toBe(true);
+    expect(onStartWorkspaceUpload).toHaveBeenCalledWith(files, {
+      destinationFolder: "project/uploads",
+      createDirs: true,
+      overwrite: false,
+      selectUploadedFile: true,
+    });
+    expect(findOptionalTemplateEventHandler<SubmitEvent>(panel.render(), "<form @submit=")).toBeUndefined();
+  });
+});
 
 describe("workspaceUploadBatchesForScope", () => {
   it("filters upload batches to the selected project, workspace, and machine", () => {
@@ -80,6 +117,152 @@ describe("workspaceUploadReviewError", () => {
   });
 });
 
+type TemplateEventHandler<E extends Event> = (event: E) => void;
+
+function findTemplateEventHandler<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> {
+  const handler = findOptionalTemplateEventHandler<E>(template, marker);
+  if (handler === undefined) throw new Error(`Expected template event handler after ${marker}`);
+  return handler;
+}
+
+function findOptionalTemplateEventHandler<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> | undefined {
+  return findInTemplate(template);
+
+  function findInTemplate(current: TemplateResult): TemplateEventHandler<E> | undefined {
+    const strings = templateStrings(current);
+    const values = templateValues(current);
+    for (let index = 0; index < values.length; index += 1) {
+      const staticChunk = strings[index];
+      const value = values[index];
+      if (staticChunk !== undefined && staticChunk.includes(marker) && isTemplateEventHandler<E>(value)) return value;
+      const nestedHandler = findInValue(value);
+      if (nestedHandler !== undefined) return nestedHandler;
+    }
+    return undefined;
+  }
+
+  function findInValue(value: unknown): TemplateEventHandler<E> | undefined {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const nestedHandler = findInValue(item);
+        if (nestedHandler !== undefined) return nestedHandler;
+      }
+      return undefined;
+    }
+    if (isTemplateResult(value)) return findInTemplate(value);
+    return undefined;
+  }
+}
+
+function templateStrings(template: TemplateResult): readonly string[] {
+  const strings = Reflect.get(template, "strings");
+  if (!isStringArray(strings)) throw new Error("TemplateResult strings were unavailable");
+  return strings;
+}
+
+function templateValues(template: TemplateResult): readonly unknown[] {
+  const values = Reflect.get(template, "values");
+  if (!Array.isArray(values)) throw new Error("TemplateResult values were unavailable");
+  return values.map((value: unknown) => value);
+}
+
+function isTemplateResult(value: unknown): value is TemplateResult {
+  return typeof value === "object" && value !== null && isStringArray(Reflect.get(value, "strings")) && Array.isArray(Reflect.get(value, "values"));
+}
+
+function isTemplateEventHandler<E extends Event>(value: unknown): value is TemplateEventHandler<E> {
+  return typeof value === "function";
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item: unknown) => typeof item === "string");
+}
+
+class FakeFileList implements FileList {
+  readonly length: number;
+  [index: number]: File;
+
+  constructor(private readonly files: readonly File[]) {
+    this.length = files.length;
+    files.forEach((file, index) => {
+      this[index] = file;
+    });
+  }
+
+  item(index: number): File | null {
+    return this.files[index] ?? null;
+  }
+
+  [Symbol.iterator](): ArrayIterator<File> {
+    return this.files[Symbol.iterator]();
+  }
+}
+
+class FakeHTMLInputElement extends EventTarget {
+  readonly files: FileList;
+  value = "selected-files";
+
+  constructor(files: readonly File[]) {
+    super();
+    this.files = new FakeFileList(files);
+  }
+}
+
+class EventWithCurrentTarget extends Event {
+  constructor(type: string, private readonly eventCurrentTarget: EventTarget) {
+    super(type);
+  }
+
+  override get currentTarget(): EventTarget {
+    return this.eventCurrentTarget;
+  }
+}
+
+class FakeSubmitEvent extends Event implements SubmitEvent {
+  readonly submitter: HTMLElement | null = null;
+}
+
+function workspacePanelContext(patch: Partial<Pick<WorkspacePanelContext, "onStartWorkspaceUpload" | "workspaceUploadDefaultFolder">> = {}): WorkspacePanelContext {
+  const workspace = { id: "workspace-1", projectId: "project-1", path: "/tmp/project", label: "main", isMain: true, isGitRepo: true, isGitWorktree: false };
+  return {
+    machine: { id: "local", name: "Local", kind: "local" },
+    workspace,
+    state: { ...initialAppState(), workspaceUploadBatches: {} },
+    files: {
+      readFile: vi.fn<WorkspacePanelContext["files"]["readFile"]>(() => Promise.reject(new Error("not implemented"))),
+      writeFile: vi.fn<WorkspacePanelContext["files"]["writeFile"]>(() => Promise.reject(new Error("not implemented"))),
+      deleteFile: vi.fn<WorkspacePanelContext["files"]["deleteFile"]>(() => Promise.reject(new Error("not implemented"))),
+      moveFile: vi.fn<WorkspacePanelContext["files"]["moveFile"]>(() => Promise.reject(new Error("not implemented"))),
+    },
+    prompt: { insertText: vi.fn<WorkspacePanelContext["prompt"]["insertText"]>(), getText: vi.fn<WorkspacePanelContext["prompt"]["getText"]>(() => ""), getSelection: vi.fn<WorkspacePanelContext["prompt"]["getSelection"]>(() => null) },
+    terminal: { open: vi.fn<WorkspacePanelContext["terminal"]["open"]>(), runCommand: vi.fn<WorkspacePanelContext["terminal"]["runCommand"]>(() => Promise.reject(new Error("not implemented"))) },
+    host: { requestRender: vi.fn<WorkspacePanelContext["host"]["requestRender"]>() },
+    fileTree: [],
+    expandedDirs: {},
+    selectedFilePath: undefined,
+    selectedFileContent: undefined,
+    fileTreeStale: false,
+    gitStatus: undefined,
+    selectedDiffPath: undefined,
+    selectedDiff: undefined,
+    selectedStagedDiff: undefined,
+    gitStale: false,
+    activeTerminalCount: 0,
+    selectedTerminalId: undefined,
+    terminalAutoStart: false,
+    workspaceUploadDefaultFolder: patch.workspaceUploadDefaultFolder ?? ".pi-web/uploads",
+    onRefreshFiles: vi.fn<WorkspacePanelContext["onRefreshFiles"]>(),
+    onExpandDir: vi.fn<WorkspacePanelContext["onExpandDir"]>(),
+    onSelectFile: vi.fn<WorkspacePanelContext["onSelectFile"]>(),
+    onStartWorkspaceUpload: patch.onStartWorkspaceUpload ?? vi.fn<WorkspacePanelContext["onStartWorkspaceUpload"]>(() => undefined),
+    onCancelWorkspaceUpload: vi.fn<WorkspacePanelContext["onCancelWorkspaceUpload"]>(),
+    onClearWorkspaceUpload: vi.fn<WorkspacePanelContext["onClearWorkspaceUpload"]>(),
+    onRefreshGit: vi.fn<WorkspacePanelContext["onRefreshGit"]>(),
+    onSelectDiff: vi.fn<WorkspacePanelContext["onSelectDiff"]>(),
+    onSelectTerminal: vi.fn<WorkspacePanelContext["onSelectTerminal"]>(),
+  };
+}
+
 function uploadBatch(patch: Partial<WorkspaceUploadBatchState> = {}): WorkspaceUploadBatchState {
   return {
     id: patch.id ?? "batch-1",

src/client/src/components/settings/SettingsShortcutsPanel.test.ts

@@ -1,9 +1,14 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { TemplateResult } from "lit";
+import type { AppAction } from "../../actions";
 import type { PiWebConfigResponse, PiWebConfigValues } from "../../api";
 import { SettingsShortcutsPanel } from "./SettingsShortcutsPanel";
 import type { SettingsNotice } from "./SettingsPanelFrame";
 
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
 describe("settings-shortcuts-panel layout", () => {
   it("renders header, ordered notices, and shortcut settings through the shared frame", () => {
     const panel = new SettingsShortcutsPanel();
@@ -40,6 +45,34 @@ describe("settings-shortcuts-panel layout", () => {
   });
 });
 
+describe("settings-shortcuts-panel shortcut row actions", () => {
+  it("saves edited shortcuts, disables them with None, and resets overrides", () => {
+    vi.stubGlobal("HTMLInputElement", FakeHTMLInputElement);
+    const onSave = vi.fn<SaveHandler>();
+    const savePanel = panelWithShortcuts({ shortcuts: { "core:other": "mod+o" } }, onSave);
+
+    findTemplateEventHandler<Event>(savePanel.render(), "@input=")(
+      new EventWithTarget("input", new FakeHTMLInputElement(" control + shift + p ")),
+    );
+
+    expectTextOrder(flattenTemplateContent(savePanel.render()), ["Open palette", "Ctrl+Shift+P", "Custom · Unsaved"]);
+
+    findTemplateEventHandler<Event>(savePanel.render(), ">Save</button>")(new Event("click"));
+
+    const nonePanel = panelWithShortcuts({ shortcuts: { "core:open-palette": "mod+shift+p", "core:other": "mod+o" } }, onSave);
+    findTemplateEventHandler<Event>(nonePanel.render(), ">None</button>")(new Event("click"));
+
+    const resetPanel = panelWithShortcuts({ shortcuts: { "core:open-palette": null, "core:other": "mod+o" } }, onSave);
+    findTemplateEventHandler<Event>(resetPanel.render(), ">Reset</button>")(new Event("click"));
+
+    expect(onSave.mock.calls).toEqual([
+      [{ shortcuts: { "core:other": "mod+o", "core:open-palette": "mod+shift+p" } }],
+      [{ shortcuts: { "core:open-palette": null, "core:other": "mod+o" } }],
+      [{ shortcuts: { "core:other": "mod+o" } }],
+    ]);
+  });
+});
+
 function frameNotices(template: TemplateResult): readonly SettingsNotice[] {
   const notices = collectTemplateValues(template).find(isSettingsNoticeArray);
   if (notices === undefined) throw new Error("Expected settings-panel-frame notices to be rendered");
@@ -139,6 +172,86 @@ function isStringArray(value: unknown): value is string[] {
   return Array.isArray(value) && value.every((item: unknown) => typeof item === "string");
 }
 
+type SaveHandler = (config: PiWebConfigValues) => void | Promise<void>;
+type TemplateEventHandler<E extends Event> = (event: E) => void;
+
+function panelWithShortcuts(config: PiWebConfigValues, onSave: SaveHandler): SettingsShortcutsPanel {
+  const panel = new SettingsShortcutsPanel();
+  panel.actions = [shortcutAction()];
+  panel.configResponse = configResponse(config);
+  panel.onSave = onSave;
+  return panel;
+}
+
+function shortcutAction(): AppAction {
+  return {
+    id: "core:open-palette",
+    title: "Open palette",
+    description: "Open the command palette.",
+    shortcut: "mod+k",
+    group: "Navigation",
+    run: vi.fn(),
+  };
+}
+
+function findTemplateEventHandler<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> {
+  const handler = findOptionalTemplateEventHandler<E>(template, marker);
+  if (handler === undefined) throw new Error(`Expected template event handler near ${marker}`);
+  return handler;
+}
+
+function findOptionalTemplateEventHandler<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> | undefined {
+  return findInTemplate(template);
+
+  function findInTemplate(current: TemplateResult): TemplateEventHandler<E> | undefined {
+    const strings = templateStrings(current);
+    const values = templateValues(current);
+    for (let index = 0; index < values.length; index += 1) {
+      const value = values[index];
+      if (isTemplateEventHandler<E>(value) && templateEventHandlerMatches(strings, index, marker)) return value;
+      const nestedHandler = findInValue(value);
+      if (nestedHandler !== undefined) return nestedHandler;
+    }
+    return undefined;
+  }
+
+  function findInValue(value: unknown): TemplateEventHandler<E> | undefined {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const nestedHandler = findInValue(item);
+        if (nestedHandler !== undefined) return nestedHandler;
+      }
+      return undefined;
+    }
+    if (isTemplateResult(value)) return findInTemplate(value);
+    return undefined;
+  }
+}
+
+function templateEventHandlerMatches(strings: readonly string[], valueIndex: number, marker: string): boolean {
+  return (strings[valueIndex] ?? "").includes(marker) || (strings[valueIndex + 1] ?? "").includes(marker);
+}
+
+function isTemplateEventHandler<E extends Event>(value: unknown): value is TemplateEventHandler<E> {
+  return typeof value === "function";
+}
+
+class FakeHTMLInputElement extends EventTarget {
+  constructor(readonly value: string) {
+    super();
+  }
+}
+
+class EventWithTarget extends Event {
+  constructor(type: string, private readonly eventTarget: EventTarget) {
+    super(type);
+  }
+
+  override get target(): EventTarget {
+    return this.eventTarget;
+  }
+}
+
 function configResponse(config: PiWebConfigValues): PiWebConfigResponse {
   return {
     path: "/tmp/pi-web/config.json",

src/client/src/controllers/authController.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { api as defaultApi, type AuthProviderOption, type OAuthFlowState } from "../api";
+import { api as defaultApi, type AuthProviderOption, type OAuthFlowState, type SessionInfo, type SessionStatus } from "../api";
 import { initialAppState, type AppState } from "../appState";
 import { AuthController, parseAuthSlashCommand } from "./authController";
 
@@ -42,20 +42,226 @@ describe("AuthController", () => {
 
     expect(getState().authDialog).toMatchObject({ step: "oauth", inputValue: "https://callback", responding: true });
   });
+
+  it("resets OAuth prompt input and submit state when the request id changes", async () => {
+    const flow = oauthFlow({ prompt: { requestId: "request-1", message: "Paste callback", kind: "manual" } });
+    const { controller, getState } = createController(
+      { authDialog: { step: "oauth", flow, inputValue: "https://callback", responding: true } },
+      {
+        respondOAuthFlow: () => Promise.resolve(oauthFlow({
+          select: { requestId: "request-2", message: "Choose an account", options: [{ value: "acct-1", label: "Account 1" }] },
+          progress: ["Need account selection"],
+        })),
+      },
+    );
+
+    await controller.respondOAuth();
+
+    expect(getState().authDialog).toMatchObject({
+      step: "oauth",
+      flow: { select: { requestId: "request-2" } },
+      inputValue: "",
+      responding: false,
+    });
+  });
+
+  it("closes the OAuth dialog and refreshes selected session status when the flow completes", async () => {
+    const flow = oauthFlow({ prompt: { requestId: "request-1", message: "Paste callback", kind: "manual" } });
+    const session = sessionInfo("session-1");
+    const refreshedStatus = sessionStatus(session.id);
+    const respondCalls: { flowId: string; requestId: string; value: string; machineId: string | undefined }[] = [];
+    const statusCalls: { session: Parameters<typeof defaultApi.status>[0]; machineId: string | undefined }[] = [];
+    const appliedStatuses: SessionStatus[] = [];
+    const { controller, getState } = createController(
+      { selectedSession: session, authDialog: { step: "oauth", flow, inputValue: "https://callback" } },
+      {
+        respondOAuthFlow: (flowId, requestId, value, machineId) => {
+          respondCalls.push({ flowId, requestId, value, machineId });
+          return Promise.resolve(oauthFlow({ status: "complete" }));
+        },
+        status: (sessionArg, machineId) => {
+          statusCalls.push({ session: sessionArg, machineId });
+          return Promise.resolve(refreshedStatus);
+        },
+      },
+      (status) => { appliedStatuses.push(status); },
+    );
+
+    await controller.respondOAuth();
+    await flushMicrotasks();
+
+    expect(respondCalls).toEqual([{ flowId: "flow-1", requestId: "request-1", value: "https://callback", machineId: "local" }]);
+    expect(getState().authDialog).toBeUndefined();
+    expect(statusCalls).toEqual([{ session, machineId: "local" }]);
+    expect(appliedStatuses).toEqual([refreshedStatus]);
+  });
+
+  it("leaves the OAuth dialog ready to retry if responding fails", async () => {
+    const flow = oauthFlow({ prompt: { requestId: "request-1", message: "Paste callback", kind: "manual" } });
+    const { controller, getState } = createController(
+      { authDialog: { step: "oauth", flow, inputValue: "https://callback", responding: true } },
+      { respondOAuthFlow: () => Promise.reject(new Error("Invalid callback")) },
+    );
+
+    await controller.respondOAuth();
+
+    expect(getState().authDialog).toMatchObject({
+      step: "oauth",
+      flow,
+      inputValue: "https://callback",
+      responding: false,
+      error: "Error: Invalid callback",
+    });
+  });
+
+  it("cancels the active OAuth flow and closes the dialog even when cancellation fails", async () => {
+    const flow = oauthFlow({ prompt: { requestId: "request-1", message: "Paste callback", kind: "manual" } });
+    const cancelCalls: { flowId: string; machineId: string | undefined }[] = [];
+    const { controller, getState } = createController(
+      { authDialog: { step: "oauth", flow } },
+      {
+        cancelOAuthFlow: (flowId, machineId) => {
+          cancelCalls.push({ flowId, machineId });
+          return Promise.reject(new Error("Cancel unavailable"));
+        },
+      },
+    );
+
+    await controller.cancelOAuth();
+
+    expect(cancelCalls).toEqual([{ flowId: "flow-1", machineId: "local" }]);
+    expect(getState().authDialog).toBeUndefined();
+  });
+
+  it("validates API key input before saving and clears the validation error when edited", async () => {
+    const saveCalls: { providerId: string; key: string; machineId: string | undefined }[] = [];
+    const provider = authProvider("openai", "api_key");
+    const { controller, getState } = createController(
+      { authDialog: { step: "apiKey", provider, value: "   " } },
+      {
+        saveApiKey: (providerId, key, machineId) => {
+          saveCalls.push({ providerId, key, machineId });
+          return Promise.resolve({ accepted: true });
+        },
+      },
+    );
+
+    await controller.saveApiKey();
+
+    expect(saveCalls).toEqual([]);
+    expect(getState().authDialog).toMatchObject({ step: "apiKey", error: "API key is required" });
+
+    controller.updateApiKey("sk-live");
+
+    expect(getState().authDialog).toMatchObject({ step: "apiKey", value: "sk-live" });
+    expect(getState().authDialog).not.toHaveProperty("error");
+  });
+
+  it("saves a trimmed API key on the selected machine and refreshes selected session status", async () => {
+    const saveCalls: { providerId: string; key: string; machineId: string | undefined }[] = [];
+    const statusCalls: { session: Parameters<typeof defaultApi.status>[0]; machineId: string | undefined }[] = [];
+    const appliedStatuses: SessionStatus[] = [];
+    const provider = authProvider("openai", "api_key");
+    const session = sessionInfo("session-1");
+    const refreshedStatus = sessionStatus(session.id);
+    const { controller, getState } = createController(
+      {
+        selectedMachine: remoteMachine("remote-1"),
+        selectedSession: session,
+        authDialog: { step: "apiKey", provider, value: "  sk-live  " },
+      },
+      {
+        saveApiKey: (providerId, key, machineId) => {
+          saveCalls.push({ providerId, key, machineId });
+          return Promise.resolve({ accepted: true });
+        },
+        status: (sessionArg, machineId) => {
+          statusCalls.push({ session: sessionArg, machineId });
+          return Promise.resolve(refreshedStatus);
+        },
+      },
+      (status) => { appliedStatuses.push(status); },
+    );
+
+    await controller.saveApiKey();
+    await flushMicrotasks();
+
+    expect(saveCalls).toEqual([{ providerId: "openai", key: "sk-live", machineId: "remote-1" }]);
+    expect(getState().authDialog).toBeUndefined();
+    expect(statusCalls).toEqual([{ session, machineId: "remote-1" }]);
+    expect(appliedStatuses).toEqual([refreshedStatus]);
+  });
+
+  it("keeps the API key dialog open with an error if saving fails", async () => {
+    const provider = authProvider("openai", "api_key");
+    const { controller, getState } = createController(
+      { authDialog: { step: "apiKey", provider, value: "sk-live" } },
+      { saveApiKey: () => Promise.reject(new Error("Denied")) },
+    );
+
+    await controller.saveApiKey();
+
+    expect(getState().authDialog).toMatchObject({ step: "apiKey", value: "sk-live", saving: false, error: "Error: Denied" });
+  });
 });
 
-function createController(statePatch: Partial<AppState>, apiPatch: Partial<typeof defaultApi> = {}) {
+function createController(
+  statePatch: Partial<AppState>,
+  apiPatch: Partial<typeof defaultApi> = {},
+  applyStatus: (status: SessionStatus) => void = () => undefined,
+) {
   let state: AppState = { ...initialAppState(), ...statePatch };
   const api = { ...defaultApi, ...apiPatch };
   const controller = new AuthController(
     () => state,
     (patch) => { state = { ...state, ...patch }; },
-    () => undefined,
+    applyStatus,
     { api },
   );
   return { controller, getState: () => state };
 }
 
+async function flushMicrotasks(): Promise<void> {
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+function remoteMachine(id: string): NonNullable<AppState["selectedMachine"]> {
+  return {
+    id,
+    name: "Remote",
+    kind: "remote",
+    baseUrl: "https://remote.example",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+  };
+}
+
+function sessionInfo(id: string): SessionInfo {
+  return {
+    id,
+    cwd: "/repo",
+    path: `/tmp/${id}.jsonl`,
+    created: "2026-01-01T00:00:00.000Z",
+    modified: "2026-01-01T00:00:00.000Z",
+    messageCount: 0,
+    firstMessage: "",
+  };
+}
+
+function sessionStatus(sessionId: string): SessionStatus {
+  return {
+    sessionId,
+    isStreaming: false,
+    isCompacting: false,
+    isBashRunning: false,
+    pendingMessageCount: 0,
+    queuedMessages: [],
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    cost: 0,
+  };
+}
+
 function authProvider(id: string, authType: "oauth" | "api_key"): AuthProviderOption {
   return { id, authType, name: `${id} ${authType}`, status: { configured: false } };
 }

src/client/src/controllers/fileExplorerController.test.ts

@@ -158,6 +158,22 @@ describe("FileExplorerController workspace uploads", () => {
     });
   });
 
+  it("clears an in-flight upload by cancelling the request and removing the batch", async () => {
+    const upload = controllableUpload({ rejectOnCancel: true });
+    const harness = createHarness({ uploadWorkspaceFiles: upload.fn });
+    const run = harness.controller.startWorkspaceUpload([new File(["aa"], "a.txt")], { destinationFolder: "uploads" });
+
+    expect(run?.batchId).toBe("batch-1");
+    expect(harness.state.workspaceUploadBatches["batch-1"]?.status).toBe("uploading");
+
+    harness.controller.clearWorkspaceUpload(run?.batchId ?? "missing");
+    await run?.done;
+
+    expect(upload.cancel).toHaveBeenCalledTimes(1);
+    expect(harness.state.workspaceUploadBatches).toEqual({});
+    expect(harness.state.error).toBe("");
+  });
+
   it("keeps per-file errors accurate and refreshes after partial batch success", async () => {
     const upload = controllableUpload();
     const harness = createHarness({ uploadWorkspaceFiles: upload.fn, now: sequenceNow("start", "fail") });

src/client/src/promptAttachmentCapture.test.ts

@@ -1,4 +1,6 @@
-import { describe, expect, it } from "vitest";
+import type { TemplateResult } from "lit";
+import { describe, expect, it, vi } from "vitest";
+import { PromptEditor } from "./components/PromptEditor";
 import { capturePromptAttachments, DEFAULT_FILE_MIME_TYPE, effectivePromptAttachmentDelivery, READ_FAILURE_MESSAGE, type CapturableFile } from "./promptAttachmentCapture";
 
 function file(name: string, type: string, size = 10): CapturableFile {
@@ -79,3 +81,148 @@ describe("effectivePromptAttachmentDelivery", () => {
     ])).toBe("folder");
   });
 });
+
+describe("PromptEditor attachment chips", () => {
+  it("removes a pending attachment chip before sending the remaining attachments", () => {
+    const editor = new PromptEditor();
+    const onSend = vi.fn<NonNullable<PromptEditor["onSend"]>>();
+    editor.onSend = onSend;
+    setPromptEditorPrivate(editor, "draft", "please review");
+    setPromptEditorPrivate(editor, "attachments", [
+      { id: "attachment-1", kind: "file", name: "report.pdf", mimeType: "application/pdf", data: "UkVQT1JU", size: 6 },
+      { id: "attachment-2", kind: "image", name: "shot.png", mimeType: "image/png", data: "UE5H", size: 3 },
+    ]);
+
+    const removeReport = findTemplateEventHandlerAfterValue<Event>(editor.render(), "Remove report.pdf", "@click=");
+    removeReport(new Event("click"));
+
+    expect(templateContainsValue(editor.render(), "Remove report.pdf")).toBe(false);
+    expect(templateContainsValue(editor.render(), "Remove shot.png")).toBe(true);
+
+    const send = findTemplateEventHandlerAfterMarker<Event>(editor.render(), "send-button");
+    send(new Event("click"));
+
+    expect(onSend).toHaveBeenCalledTimes(1);
+    expect(onSend).toHaveBeenCalledWith("please review", undefined, [
+      { kind: "image", mimeType: "image/png", data: "UE5H", name: "shot.png" },
+    ], "inline");
+  });
+});
+
+type TemplateEventHandler<E extends Event> = (event: E) => void;
+
+function setPromptEditorPrivate(editor: PromptEditor, property: string, value: unknown): void {
+  if (!Reflect.set(editor, property, value)) throw new Error(`Failed to set PromptEditor ${property}`);
+}
+
+function findTemplateEventHandlerAfterMarker<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> {
+  const handler = findOptionalTemplateEventHandlerAfterMarker<E>(template, marker);
+  if (handler === undefined) throw new Error(`Expected template event handler after marker ${marker}`);
+  return handler;
+}
+
+function findOptionalTemplateEventHandlerAfterMarker<E extends Event>(template: TemplateResult, marker: string): TemplateEventHandler<E> | undefined {
+  const strings = templateStrings(template);
+  const values = templateValues(template);
+  for (let index = 0; index < values.length; index += 1) {
+    const staticChunk = strings[index];
+    if (staticChunk?.includes(marker) === true) {
+      const handler = nextTemplateEventHandler<E>(values, index);
+      if (handler !== undefined) return handler;
+    }
+    const nestedHandler = findOptionalTemplateEventHandlerAfterMarkerInValue<E>(values[index], marker);
+    if (nestedHandler !== undefined) return nestedHandler;
+  }
+  return undefined;
+}
+
+function findOptionalTemplateEventHandlerAfterMarkerInValue<E extends Event>(value: unknown, marker: string): TemplateEventHandler<E> | undefined {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nestedHandler = findOptionalTemplateEventHandlerAfterMarkerInValue<E>(item, marker);
+      if (nestedHandler !== undefined) return nestedHandler;
+    }
+    return undefined;
+  }
+  if (isTemplateResult(value)) return findOptionalTemplateEventHandlerAfterMarker<E>(value, marker);
+  return undefined;
+}
+
+function findTemplateEventHandlerAfterValue<E extends Event>(template: TemplateResult, expectedValue: unknown, marker: string): TemplateEventHandler<E> {
+  const handler = findOptionalTemplateEventHandlerAfterValue<E>(template, expectedValue, marker);
+  if (handler === undefined) throw new Error(`Expected template event handler after value ${String(expectedValue)}`);
+  return handler;
+}
+
+function findOptionalTemplateEventHandlerAfterValue<E extends Event>(template: TemplateResult, expectedValue: unknown, marker: string): TemplateEventHandler<E> | undefined {
+  const strings = templateStrings(template);
+  const values = templateValues(template);
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (value === expectedValue) {
+      for (let handlerIndex = index + 1; handlerIndex < values.length; handlerIndex += 1) {
+        const staticChunk = strings[handlerIndex];
+        const maybeHandler = values[handlerIndex];
+        if (staticChunk?.includes(marker) === true && isTemplateEventHandler<E>(maybeHandler)) return maybeHandler;
+      }
+    }
+    const nestedHandler = findOptionalTemplateEventHandlerAfterValueInValue<E>(value, expectedValue, marker);
+    if (nestedHandler !== undefined) return nestedHandler;
+  }
+  return undefined;
+}
+
+function findOptionalTemplateEventHandlerAfterValueInValue<E extends Event>(value: unknown, expectedValue: unknown, marker: string): TemplateEventHandler<E> | undefined {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const nestedHandler = findOptionalTemplateEventHandlerAfterValueInValue<E>(item, expectedValue, marker);
+      if (nestedHandler !== undefined) return nestedHandler;
+    }
+    return undefined;
+  }
+  if (isTemplateResult(value)) return findOptionalTemplateEventHandlerAfterValue<E>(value, expectedValue, marker);
+  return undefined;
+}
+
+function nextTemplateEventHandler<E extends Event>(values: readonly unknown[], startIndex: number): TemplateEventHandler<E> | undefined {
+  for (let index = startIndex; index < values.length; index += 1) {
+    const value = values[index];
+    if (isTemplateEventHandler<E>(value)) return value;
+  }
+  return undefined;
+}
+
+function templateContainsValue(template: TemplateResult, expectedValue: unknown): boolean {
+  return templateValues(template).some((value) => templateValueContains(value, expectedValue));
+}
+
+function templateValueContains(value: unknown, expectedValue: unknown): boolean {
+  if (value === expectedValue) return true;
+  if (Array.isArray(value)) return value.some((item) => templateValueContains(item, expectedValue));
+  if (isTemplateResult(value)) return templateContainsValue(value, expectedValue);
+  return false;
+}
+
+function templateStrings(template: TemplateResult): readonly string[] {
+  const strings = Reflect.get(template, "strings");
+  if (!isStringArray(strings)) throw new Error("TemplateResult strings were unavailable");
+  return strings;
+}
+
+function templateValues(template: TemplateResult): readonly unknown[] {
+  const values = Reflect.get(template, "values");
+  if (!Array.isArray(values)) throw new Error("TemplateResult values were unavailable");
+  return values.map((value: unknown) => value);
+}
+
+function isTemplateResult(value: unknown): value is TemplateResult {
+  return typeof value === "object" && value !== null && isStringArray(Reflect.get(value, "strings")) && Array.isArray(Reflect.get(value, "values"));
+}
+
+function isTemplateEventHandler<E extends Event>(value: unknown): value is TemplateEventHandler<E> {
+  return typeof value === "function";
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item: unknown) => typeof item === "string");
+}

src/client/src/runtime/terminalRuntime.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import type { RunTerminalCommandInput, TerminalCommandRun, Workspace } from "../api";
+import type { RunTerminalCommandInput, TerminalCommandRun, TerminalCommandRunFilter, Workspace } from "../api";
 import { createTerminalCommandRunsRuntime } from "./terminalRuntime";
 
 const workspace: Workspace = {
@@ -52,6 +52,32 @@ describe("terminal runtime", () => {
     await expect(handle.completed).resolves.toEqual(succeededRun);
   });
 
+  it("passes through command-run lookup helpers and open requests", async () => {
+    const filter: TerminalCommandRunFilter = {
+      projectId: "p1",
+      workspaceId: "w1",
+      statuses: ["running"],
+      metadata: { "pi.operation": "test" },
+    };
+    const runs = [runningRun, succeededRun];
+    const openTerminal = vi.fn();
+    const api = {
+      runTerminalCommand: vi.fn(),
+      listCommandRuns: vi.fn(() => Promise.resolve(runs)),
+      getCommandRun: vi.fn(() => Promise.resolve(succeededRun)),
+    };
+    const runtime = createTerminalCommandRunsRuntime("core", { api, openTerminal });
+
+    await expect(runtime.listCommandRuns(filter)).resolves.toEqual(runs);
+    await expect(runtime.getCommandRun("run1")).resolves.toEqual(succeededRun);
+    runtime.open({ terminalId: "t2" });
+
+    expect(api.listCommandRuns).toHaveBeenCalledWith(filter);
+    expect(api.getCommandRun).toHaveBeenCalledWith("run1");
+    expect(openTerminal).toHaveBeenCalledWith(undefined, { terminalId: "t2" });
+    expect(api.runTerminalCommand).not.toHaveBeenCalled();
+  });
+
   it("polls command-run records until completion", async () => {
     vi.useFakeTimers();
     const api = {
@@ -73,4 +99,37 @@ describe("terminal runtime", () => {
     await expect(handle.completed).resolves.toEqual(succeededRun);
     expect(api.getCommandRun).toHaveBeenCalledWith("run1");
   });
+
+  it("rejects completion polling failures and clears the scheduled timer", async () => {
+    const pollError = new Error("poll failed");
+    const timerId = globalThis.setTimeout(() => undefined, 0);
+    globalThis.clearTimeout(timerId);
+    const scheduledPolls: (() => void)[] = [];
+    const clearTimeout = vi.fn();
+    const api = {
+      runTerminalCommand: vi.fn(() => Promise.resolve(runningRun)),
+      listCommandRuns: vi.fn(),
+      getCommandRun: vi.fn(() => Promise.reject(pollError)),
+    };
+    const runtime = createTerminalCommandRunsRuntime("core", {
+      api,
+      openTerminal: vi.fn(),
+      pollIntervalMs: 25,
+      setTimeout: (handler) => {
+        scheduledPolls.push(handler);
+        return timerId;
+      },
+      clearTimeout,
+    });
+
+    const handle = await runtime.runCommand({ workspace, title: "Build", command: "npm run build" });
+    const poll = scheduledPolls[0];
+    expect(poll).toBeDefined();
+    poll?.();
+
+    await expect(handle.completed).rejects.toBe(pollError);
+    expect(api.getCommandRun).toHaveBeenCalledWith("run1");
+    expect(scheduledPolls).toHaveLength(1);
+    expect(clearTimeout).toHaveBeenCalledWith(timerId);
+  });
 });