@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/tools/host-filesystem/transfer.test.ts

@@ -335,9 +335,8 @@ describe("host_file_transfer cross-client guards", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "The Vellum desktop app is needed to access files on your computer",
+      "no client with host_file capability is connected",
     );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
     expect(toSandboxCalls.length).toBe(0);
   });
 

package/src/tools/host-filesystem/transfer.ts

@@ -6,7 +6,7 @@ import { supportsHostProxy } from "../../channels/types.js";
 import { HostTransferProxy } from "../../daemon/host-transfer-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
-import { formatDesktopAppRequired } from "../capability-offer.js";
+import { desktopClientName } from "../client-os.js";
 import { declareDaemonActivityField } from "../schema-transforms.js";
 import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
 import type {
@@ -126,7 +126,7 @@ export const hostFileTransferTool = {
       !HostTransferProxy.instance.isAvailable()
     ) {
       return {
-        content: formatDesktopAppRequired("files"),
+        content: `Error: no client with host_file capability is connected. Connect a ${desktopClientName(context)} client to use host_file from a non-desktop interface.`,
         isError: true,
       };
     }

package/src/tools/host-filesystem/write.test.ts

@@ -67,9 +67,8 @@ describe("host_file_write cross-client guards", () => {
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "The Vellum desktop app is needed to access files on your computer",
+      "no client with host_file capability is connected",
     );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 
   test("returns 'specified client disconnected' error when targetClientId set but proxy unavailable on web", async () => {

package/src/tools/host-filesystem/write.ts

@@ -4,7 +4,7 @@ import { supportsHostProxy } from "../../channels/types.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
-import { formatDesktopAppRequired } from "../capability-offer.js";
+import { desktopClientName } from "../client-os.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import { formatWriteSummary } from "../shared/filesystem/format-diff.js";
 import { hostPolicy } from "../shared/filesystem/path-policy.js";
@@ -90,7 +90,7 @@ export const hostFileWriteTool = {
       !HostFileProxy.instance.isAvailable()
     ) {
       return {
-        content: formatDesktopAppRequired("files"),
+        content: `Error: no client with host_file capability is connected. Connect a ${desktopClientName(context)} client to use host_file from a non-desktop interface.`,
         isError: true,
       };
     }

package/src/tools/host-terminal/host-shell.test.ts

@@ -170,22 +170,6 @@ afterEach(() => {
   mockProxyAvailable = false;
 });
 
-describe("host_bash unavailable desktop-app recovery", () => {
-  test("offers the desktop app download when a web turn has no host connection", async () => {
-    const result = await hostShellTool.execute(
-      { command: "pwd" },
-      makeContext({ transportInterface: "web" }),
-    );
-
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to run commands on your computer",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-    expect(result.content).toContain("Open it, then retry.");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Proxy path — background: true
 // ---------------------------------------------------------------------------

package/src/tools/host-terminal/host-shell.ts

@@ -18,7 +18,10 @@ import { getConfig } from "../../config/loader.js";
 import { HostBashProxy } from "../../daemon/host-bash-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
-import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../../runtime/assistant-event-hub.js";
 import { conversationRevealNonce } from "../../runtime/reveal-nonce.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
 import {
@@ -36,7 +39,7 @@ import {
   registerBackgroundTool,
   removeBackgroundTool,
 } from "../background-tool-registry.js";
-import { formatDesktopAppRequired } from "../capability-offer.js";
+import { desktopClientName } from "../client-os.js";
 import {
   attachBoundedStdio,
   MAX_OUTPUT_LENGTH,
@@ -139,7 +142,7 @@ export const hostShellInputSchema = z.looseObject({
   target_client_id: z
     .string()
     .describe(
-      "Optional ID of the specific client to execute this command on. Without it, the most recently active eligible client is used. Obtain IDs from `assistant clients list --capability host_bash`.",
+      "ID of the specific client to execute this command on. Required when multiple clients support host_bash; omit when only one client is connected. Obtain IDs from `assistant clients list --capability host_bash`.",
     )
     .optional()
     .catch(undefined),
@@ -200,7 +203,20 @@ export const hostShellTool = {
     const config = getConfig();
     const { shellDefaultTimeoutSec, shellMaxTimeoutSec } = config.timeouts;
 
+    // Guard: non-host-proxy interfaces need an explicit target when multiple
+    // capable clients are connected to avoid ambiguous untargeted broadcasts.
     const transportInterface = context.transportInterface;
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_bash").length > 1
+    ) {
+      return {
+        content: `Error: multiple clients support host_bash. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_bash\` to see client IDs and labels.`,
+        isError: true,
+      };
+    }
 
     // Guard: non-host-proxy interfaces with no capable clients connected.
     if (
@@ -210,7 +226,7 @@ export const hostShellTool = {
       !HostBashProxy.instance.isAvailable()
     ) {
       return {
-        content: formatDesktopAppRequired("shell"),
+        content: `Error: no client with host_bash capability is connected. Connect a ${desktopClientName(context)} client to use host_bash from a non-desktop interface.`,
         isError: true,
       };
     }

package/src/tools/policy-context.ts

@@ -1,5 +1,5 @@
 import { getConfig } from "../config/loader.js";
-import { isSkillImprovementActive } from "../config/memory-v3-gate.js";
+import { isV3TierActive } from "../config/memory-v3-gate.js";
 import type { ExecutionContext } from "../permissions/approval-policy.js";
 import type { ChannelPermissionCoordinates } from "../permissions/channel-permission-query.js";
 import type { PolicyContext } from "../permissions/types.js";
@@ -63,11 +63,12 @@ export function buildPolicyContext(
     requestOrigin: context?.requestOrigin,
     ...channelCoordinatesFromToolContext(context),
     requesterContactId: context?.requesterContactId,
-    // Precompute the retrospective skill-improvement gate here so the
-    // permission checker, a leaf module that must not read config, can deny
-    // the memory-retrospective skill-authoring grant whenever the feature is
-    // inactive just by reading this boolean.
-    procToSkillsActive: isSkillImprovementActive(getConfig()),
+    // Precompute the proc-to-skills gate — the v3 tier being active, i.e.
+    // memory on AND v3 live — here so the permission checker, a leaf module
+    // that must not read config, can deny the memory-retrospective
+    // skill-authoring grant whenever the feature is inactive just by reading
+    // this boolean.
+    procToSkillsActive: isV3TierActive(getConfig()),
   };
 
   const ownerKind = getToolOwner(tool.name)?.kind;

package/src/tools/subagent/spawn.ts

@@ -484,9 +484,9 @@ function spawnCancelledResult(label: string): ToolExecutionResult {
  * repeat-spawn guard folds, so a consult has to record it the same way every
  * other spawn does or the guard could never match one consult against another.
  *
- * The context pack is best effort: each section independently falls back to
- * null on failure, so a missing workspace or empty catalog costs only that
- * section, never the consult.
+ * The context pack is best effort: the parent conversation is looked up only
+ * for its warm skill catalog, so an unresolvable one (e.g. evicted) costs the
+ * skills section of the pack and nothing else.
  *
  * The budget is the advisor's alone. It is the only spawn the agent may issue
  * unprompted and the only one that runs on the premium profile, so it is the
@@ -502,18 +502,21 @@ async function buildAdvisorFields(
   maxRuntimeMs: number;
   maxToolCalls: number;
 }> {
+  const parentConversation = findConversation(context.conversationId);
   // Situational awareness for the advisor: the parent's live tool set, the
   // full skill catalog, and its workspace. Assembled off the per-turn
   // ToolContext snapshot (trust, channel) so the personal-memory sections are
   // gated exactly like the runtime injectors. A null pack just means the
-  // consult runs on the brief alone. Skills come from a fresh
-  // `loadSkillCatalog()` inside the context pack, not a conversation snapshot.
+  // consult runs on the brief alone.
   const situationalContext = await buildAdvisorContext({
     conversationId: context.conversationId,
     workingDir: context.workingDir,
     allowedToolNames: context.allowedToolNames,
     trustClass: context.trustClass,
     enabledPluginSet: context.enabledPluginSet,
+    // The parent's warm per-turn catalog keeps the synchronous on-disk catalog
+    // scan out of the spawn path.
+    skillCatalog: parentConversation?.skillProjectionCache?.catalog,
   });
   return {
     requestText: advisorRequestText(objective, situationalContext),

package/src/tools/watch/watch-retro-report.ts

@@ -14,6 +14,14 @@ import type {
 /**
  * How a watch retrospective hands its report to the daemon.
  *
+ * **The card cannot come from `ui_show`.** A retrospective runs as a
+ * `clientless` wake, which pins the turn non-interactive, and
+ * `conversation-tool-setup` gates the whole `ui_surface` tool family on a
+ * client being present (`return channelCapabilities?.supportsDynamicUi ??
+ * !hasNoClient`). So `ui_show` is not merely denied in this turn, it is absent
+ * from the tool set, and a retrospective told to call it can only report that
+ * it cannot. This tool is an ordinary one and passes that gate untouched.
+ *
  * **It records; it does not render.** The executor validates the payload and
  * returns, and nothing here writes to the conversation. What makes the card is
  * `watch-retro.ts` reading this call back out of the turn's own history once

package/src/util/__tests__/language-subtag.test.ts

@@ -1,10 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import {
-  baseLanguageSubtag,
-  fixedPhraseLanguage,
-  localizedOrDefault,
-} from "../language-subtag.js";
+import { baseLanguageSubtag, localizedOrDefault } from "../language-subtag.js";
 
 describe("baseLanguageSubtag", () => {
   test("lowercases a bare tag", () => {
@@ -56,21 +52,3 @@ describe("localizedOrDefault", () => {
     expect(localizedOrDefault(table, "__proto__", "fallback")).toBe("fallback");
   });
 });
-
-describe("fixedPhraseLanguage", () => {
-  const table = { en: "one", es: "uno" };
-
-  test("pins English when the speaker's language has no table entry", () => {
-    expect(fixedPhraseLanguage(table, "ko")).toBe("en");
-    expect(fixedPhraseLanguage(table, "ar-EG")).toBe("en");
-  });
-
-  test("rides the speaker's language when the table covers it", () => {
-    expect(fixedPhraseLanguage(table, "es")).toBeUndefined();
-    expect(fixedPhraseLanguage(table, "es-419")).toBeUndefined();
-  });
-
-  test("carries no hint when the language is unknown", () => {
-    expect(fixedPhraseLanguage(table, undefined)).toBeUndefined();
-  });
-});

package/src/util/fs-watcher-error.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared `'error'`-event handler for `fs.watch()` FSWatchers.
+ *
+ * An `FSWatcher` is an EventEmitter. When the underlying inotify/FSEvents
+ * backend fails *after* the watch was established — e.g. ENOSPC when the
+ * kernel's `fs.inotify.max_user_watches` limit is exhausted while walking a
+ * recursive watch into a large subtree (a plugin's `node_modules`), or ENXIO
+ * when a Unix socket file appears in a watched directory — the failure is
+ * delivered asynchronously as an `'error'` event rather than a synchronous
+ * throw from `watch()`. An emitter with no `'error'` listener rethrows, which
+ * surfaces as an `uncaughtException` and takes the whole daemon down (→
+ * CrashLoopBackOff).
+ *
+ * Attaching this handler degrades the failure to "this watcher stops
+ * delivering events", in line with the daemon startup philosophy: a subsystem
+ * failure must never crash the process.
+ */
+
+import type { FSWatcher } from "node:fs";
+
+import type { Logger } from "pino";
+
+/**
+ * Attach a resilient `'error'` listener so async FSWatcher failures are logged
+ * instead of crashing the process. Pass the owning module's logger and the
+ * watched directory for diagnostic context.
+ */
+export function attachFsWatcherErrorHandler(
+  watcher: FSWatcher,
+  log: Logger,
+  dir: string,
+): void {
+  watcher.on("error", (err) => {
+    log.warn({ err, dir }, "FSWatcher error (non-fatal, continuing)");
+  });
+}

package/src/util/language-subtag.ts

@@ -41,19 +41,3 @@ export function localizedOrDefault<T>(
     ? (table[baseLanguageSubtag(language)!] as T)
     : fallback;
 }
-
-/**
- * The TTS language hint for a fixed phrase picked from a localized table:
- * "en" when the speaker has a language the table does not cover (the
- * picker fell back to English text, which must not be synthesized under
- * an ar/ko/ta hint), undefined otherwise (the phrase rides the speaker's
- * language, or carries no hint at all when the language is unknown).
- */
-export function fixedPhraseLanguage(
-  table: Readonly<Record<string, unknown>>,
-  language: string | undefined,
-): string | undefined {
-  return language !== undefined && !hasLocalizedEntry(table, language)
-    ? "en"
-    : undefined;
-}

package/src/util/platform.ts

@@ -470,14 +470,6 @@ export function getWorkspaceConfigPath(): string {
   return join(getWorkspaceDir(), "config.json");
 }
 
-/** Filename for the user-owned Agent Plugins MCP document. */
-export const WORKSPACE_MCP_FILENAME = "mcp.json";
-
-/** Returns $VELLUM_WORKSPACE_DIR/mcp.json */
-export function getWorkspaceMcpConfigPath(): string {
-  return join(getWorkspaceDir(), WORKSPACE_MCP_FILENAME);
-}
-
 /** Returns $VELLUM_WORKSPACE_DIR/skills */
 export function getWorkspaceSkillsDir(): string {
   return join(getWorkspaceDir(), "skills");

package/src/workspace/git-service.ts

@@ -17,10 +17,6 @@ import { getLogger } from "../util/logger.js";
 import { Mutex } from "../util/mutex.js";
 import { addToPathEnv, getExtraToolPathDirs } from "../util/platform.js";
 import { PromiseGuard } from "../util/promise-guard.js";
-import {
-  collectDirtyPathsFromPorcelain,
-  parsePorcelainZ,
-} from "./git-porcelain.js";
 
 const execFileAsync = promisify(execFile);
 const log = getLogger("workspace-git");
@@ -230,6 +226,59 @@ done
 exit 0
 `;
 
+/**
+ * Parse NUL-terminated `git status --porcelain -z` output into status/path
+ * pairs. NUL termination is required so paths with special characters
+ * (non-ASCII, quotes, newlines) arrive verbatim instead of C-style quoted.
+ * A rename/copy record is followed by a bare origin-path entry, which is
+ * skipped.
+ */
+function parsePorcelainZ(
+  stdout: string,
+): Array<{ status: string; path: string }> {
+  const entries = stdout.split("\0");
+  const parsed: Array<{ status: string; path: string }> = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i] ?? "";
+    if (entry.length < 4) {
+      continue;
+    }
+    const status = entry.substring(0, 2);
+    parsed.push({ status, path: entry.substring(3) });
+    if (status[0] === "R" || status[0] === "C") {
+      i++;
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Every path git status knows about, including rename/copy origins.
+ * Origins are skipped by {@link parsePorcelainZ} (they have no status
+ * prefix) but still need to be staged so a deletion is not left behind
+ * when a rename is split across add batches.
+ */
+function collectDirtyPathsFromPorcelain(stdout: string): string[] {
+  const entries = stdout.split("\0");
+  const paths: string[] = [];
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i] ?? "";
+    if (entry.length < 4) {
+      continue;
+    }
+    const status = entry.substring(0, 2);
+    paths.push(entry.substring(3));
+    if (status[0] === "R" || status[0] === "C") {
+      i++;
+      const origin = entries[i];
+      if (origin && origin.length > 0) {
+        paths.push(origin);
+      }
+    }
+  }
+  return paths;
+}
+
 /** Properties added by Node's child_process errors. */
 interface ExecError extends Error {
   killed?: boolean;
@@ -384,7 +433,7 @@ export class WorkspaceGitService {
    *
    * This method is always called inside the mutex, so no git operation from
    * our code can be concurrently holding the lock. However, an external git
-   * git process (user running `git add`, IDE tooling, etc.) could legitimately
+   * process (user running `git add`, IDE tooling, etc.) could legitimately
    * hold the lock. We use `lsof` to check — if any process has the file
    * open, we leave it alone. If no process holds it, it's stale (crashed
    * process) and safe to remove.

package/src/workspace/migrations/registry.ts

@@ -151,9 +151,6 @@ import { sttFluxProviderToModelFamilyMigration } from "./150-stt-flux-provider-t
 import { repairRenamedFireworksDeepseekProModelIdMigration } from "./151-repair-renamed-fireworks-deepseek-pro-model-id.js";
 import { repairRetiredFireworksMinimaxM2p7ModelIdMigration } from "./152-repair-retired-fireworks-minimax-m2p7-model-id.js";
 import { stripMcpPolicyFieldsMigration } from "./153-strip-mcp-policy-fields.js";
-import { repairRetiredCodexGpt54ModelIdsMigration } from "./154-repair-retired-codex-gpt-5-4-model-ids.js";
-import { moveFrontModelConfigToVoiceMigration } from "./155-move-front-model-config-to-voice.js";
-import { extractWorkspaceMcpJsonMigration } from "./156-extract-workspace-mcp-json.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -320,7 +317,4 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   repairRenamedFireworksDeepseekProModelIdMigration,
   repairRetiredFireworksMinimaxM2p7ModelIdMigration,
   stripMcpPolicyFieldsMigration,
-  repairRetiredCodexGpt54ModelIdsMigration,
-  moveFrontModelConfigToVoiceMigration,
-  extractWorkspaceMcpJsonMigration,
 ];

package/scripts/smoke-desktop-window-theme.ts

@@ -1,186 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { writeDesktopWindowTheme } from "../src/desktop/desktop-window-theme.js";
-
-if (process.platform !== "linux") {
-  throw new Error(
-    "Run in a disposable Linux environment with Xvfb, Openbox, xterm, xdotool, xwininfo and xmllint installed",
-  );
-}
-
-const directory = await mkdtemp(join(tmpdir(), "window-theme-smoke-"));
-const env = { ...process.env, DISPLAY: ":97" };
-const children: ReturnType<typeof Bun.spawn>[] = [];
-const start = (cmd: string[]) => {
-  const child = Bun.spawn(cmd, {
-    env,
-    stdout: "ignore",
-    stderr: "inherit",
-    windowsHide: true,
-  });
-  children.push(child);
-  return child;
-};
-const run = (...cmd: string[]) => {
-  const result = Bun.spawnSync(cmd, {
-    env,
-
-    windowsHide: true,
-  });
-  assert.equal(result.exitCode, 0, result.stderr.toString());
-  return result.stdout.toString();
-};
-const waitFor = async (predicate: () => boolean) => {
-  for (let attempt = 0; attempt < 100; attempt++) {
-    try {
-      if (predicate()) {
-        return;
-      }
-    } catch {}
-    await Bun.sleep(50);
-  }
-  throw new Error("Window theme smoke condition timed out");
-};
-const pointer = async (...args: string[]) => {
-  run("xdotool", ...args);
-  await Bun.sleep(200);
-};
-const geometry = () => {
-  const info = run("xwininfo", "-name", "Theme smoke");
-  return [
-    "Absolute upper-left X",
-    "Absolute upper-left Y",
-    "Width",
-    "Height",
-  ].map((label) =>
-    Number(new RegExp(`${label}:\\s+(-?\\d+)`).exec(info)?.[1]),
-  ) as [number, number, number, number];
-};
-const state = () => run("xprop", "-name", "Theme smoke", "_NET_WM_STATE");
-const button = async (offset: number) => {
-  const [x, y, width] = geometry();
-  await pointer(
-    "mousemove",
-    String(x + width - offset),
-    String(y - 16),
-    "click",
-    "1",
-  );
-};
-
-try {
-  const home = join(directory, "home");
-  const sourceDir = join(home, ".config", "openbox");
-  await mkdir(sourceDir, { recursive: true });
-  const original = await readFile("/etc/xdg/openbox/rc.xml", "utf8");
-  const mouse = original.match(/<mouse>[^]*?<\/mouse>/)![0];
-  const keyboard = original.match(/<keyboard>[^]*?<\/keyboard>/)![0];
-  const source = original
-    .replace(
-      mouse,
-      `<xi:include href="bindings.xml" xpointer="xpointer(/*/*)"/>`,
-    )
-    .replace(keyboard, "");
-  const sourcePath = join(sourceDir, "rc.xml");
-  await writeFile(sourcePath, source);
-  await writeFile(
-    join(sourceDir, "bindings.xml"),
-    `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
-  );
-  const configDir = join(directory, "managed & theme");
-  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
-  const expanded = run("xmllint", "--xinclude", config);
-  assert(
-    expanded.includes("NextWindow") && expanded.includes("Move"),
-    "Relative includes must retain the actual keyboard and mouse bindings",
-  );
-  assert.equal(await readFile(sourcePath, "utf8"), source);
-  writeDesktopWindowTheme(configDir, home, "#bc7799");
-  writeDesktopWindowTheme(configDir, home, "#53b7aa");
-  assert.equal(await readFile(sourcePath, "utf8"), source);
-  const blocked = join(directory, "blocked");
-  await writeFile(blocked, "not a directory");
-  assert.throws(() => writeDesktopWindowTheme(blocked, home));
-  assert.equal(await readFile(sourcePath, "utf8"), source);
-  const customBase = source.replace(
-    "<openbox_config",
-    '<openbox_config xml:base="./custom/"',
-  );
-  await writeFile(sourcePath, customBase);
-  assert.throws(() => writeDesktopWindowTheme(configDir, home));
-  assert.equal(await readFile(sourcePath, "utf8"), customBase);
-  await writeFile(sourcePath, source);
-
-  start(["Xvfb", ":97", "-screen", "0", "1100x700x24"]);
-  await waitFor(
-    () => run("xdotool", "getdisplaygeometry").trim() === "1100 700",
-  );
-  start(["openbox", "--config-file", config]);
-  await waitFor(() =>
-    run("xprop", "-root", "_OB_THEME").includes("window-theme"),
-  );
-  start([
-    "xterm",
-    "-title",
-    "Theme smoke",
-    "-geometry",
-    "48x12+450+250",
-    "-e",
-    "sleep",
-    "60",
-  ]);
-  await waitFor(
-    () => run("xdotool", "search", "--name", "^Theme smoke$").trim().length > 0,
-  );
-  await Bun.sleep(300);
-  const id = run("xdotool", "search", "--name", "^Theme smoke$").trim();
-  await button(39);
-  assert(
-    state().includes("MAXIMIZED_HORZ") && state().includes("MAXIMIZED_VERT"),
-  );
-  await button(39);
-  assert(!state().includes("MAXIMIZED"));
-  await button(62);
-  assert(state().includes("HIDDEN"));
-  await pointer("windowactivate", id);
-  assert(!state().includes("HIDDEN"));
-  let [x, y, width, height] = geometry();
-  await pointer("mousemove", String(x + 100), String(y - 16), "mousedown", "1");
-  await pointer("mousemove", String(x + 90), String(y - 26));
-  await pointer("mousemove", String(x + 45), String(y - 65));
-  await pointer("mouseup", "1");
-  const [movedX, movedY] = geometry();
-  assert(Math.abs(movedX - x) >= 30 && Math.abs(movedY - y) >= 30);
-  [x, y, width, height] = geometry();
-  await pointer(
-    "mousemove",
-    String(x + width - 2),
-    String(y + height + 2),
-    "mousedown",
-    "1",
-  );
-  await pointer("mousemove", String(x + width + 10), String(y + height + 10));
-  await pointer("mousemove", String(x + width + 60), String(y + height + 40));
-  await pointer("mouseup", "1");
-  const [, , resizedWidth, resizedHeight] = geometry();
-  assert(resizedWidth > width && resizedHeight > height);
-  await pointer("key", "alt+F4");
-  await waitFor(
-    () =>
-      !run("xprop", "-root", "_NET_CLIENT_LIST").includes(
-        `0x${Number(id).toString(16)}`,
-      ),
-  );
-  console.log(
-    "PASS: relative includes, preserved source, repeated theme updates, maximize/restore, minimize/activation, dragging, resizing, and keyboard close",
-  );
-} finally {
-  for (const child of children.reverse()) {
-    child.kill();
-  }
-  await Promise.all(children.map((child) => child.exited));
-  await rm(directory, { recursive: true, force: true });
-}

package/src/__tests__/git-porcelain.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  collectDirtyPathsFromPorcelain,
-  parsePorcelainZ,
-} from "../workspace/git-porcelain.js";
-
-describe("parsePorcelainZ", () => {
-  test("parses ordinary modified and untracked records", () => {
-    expect(parsePorcelainZ("M  tracked.txt\0?? new.txt\0")).toEqual([
-      { status: "M ", path: "tracked.txt" },
-      { status: "??", path: "new.txt" },
-    ]);
-  });
-
-  test("captures rename origin on the same record", () => {
-    expect(parsePorcelainZ("R  dest.txt\0src.txt\0")).toEqual([
-      { status: "R ", path: "dest.txt", origin: "src.txt" },
-    ]);
-  });
-
-  test("captures copy origin on the same record", () => {
-    expect(parsePorcelainZ("C  dest.txt\0src.txt\0")).toEqual([
-      { status: "C ", path: "dest.txt", origin: "src.txt" },
-    ]);
-  });
-
-  test("skips short leftover NUL entries", () => {
-    expect(parsePorcelainZ("M  a.txt\0\0")).toEqual([
-      { status: "M ", path: "a.txt" },
-    ]);
-  });
-});
-
-describe("collectDirtyPathsFromPorcelain", () => {
-  test("flattens rename origin so both paths are staged", () => {
-    expect(
-      collectDirtyPathsFromPorcelain("R  dest.txt\0src.txt\0?? extra.txt\0"),
-    ).toEqual(["dest.txt", "src.txt", "extra.txt"]);
-  });
-
-  test("dedupes a path that appears as both origin and destination", () => {
-    expect(collectDirtyPathsFromPorcelain("R  same.txt\0same.txt\0")).toEqual([
-      "same.txt",
-    ]);
-  });
-});