@vellumai/assistant 0.11.6-dev.202608271738.c4a1b33 → 0.11.6-dev.202608271936.fef1c19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.6-dev.202608271738.c4a1b33",
+  "version": "0.11.6-dev.202608271936.fef1c19",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/cli/lib/install-from-github.ts

@@ -36,7 +36,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join, resolve, sep } from "node:path";
+import { delimiter, dirname, join, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 
 import {
@@ -46,7 +46,12 @@ import {
   stripPreservedUserState,
 } from "../../plugins/plugin-tree-walk.js";
 import { ensureBun } from "../../util/bun-runtime.js";
-import { getWorkspacePluginsDir } from "../../util/platform.js";
+import {
+  addToPathEnv,
+  getExtraToolPathDirs,
+  getWorkspacePluginsDir,
+  isWindows,
+} from "../../util/platform.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
   type DependencyInstaller,
@@ -1258,19 +1263,18 @@ export const defaultPostinstallRunner: PostinstallRunner = async ({
 };
 
 function pluginPostinstallEnv(bun: string): NodeJS.ProcessEnv {
+  const systemDirs = isWindows()
+    ? [process.env.SystemRoot ?? "C:\\Windows"]
+    : [...getExtraToolPathDirs(), "/usr/bin", "/bin"];
   const env: NodeJS.ProcessEnv = {
-    PATH: [
-      dirname(bun),
-      "/opt/homebrew/bin",
-      "/usr/local/bin",
-      "/usr/bin",
-      "/bin",
-    ]
-      .filter(Boolean)
-      .join(":"),
+    PATH: [dirname(bun), ...systemDirs].join(delimiter),
   };
-  if (process.env.HOME) {
-    env.HOME = process.env.HOME;
+  for (const key of isWindows()
+    ? ["USERPROFILE", "APPDATA", "LOCALAPPDATA", "TEMP", "SystemRoot"]
+    : ["HOME"]) {
+    if (process.env[key]) {
+      env[key] = process.env[key];
+    }
   }
   return env;
 }
@@ -1385,12 +1389,7 @@ function pluginGitEnv(): NodeJS.ProcessEnv {
     }
   }
   env.GIT_TERMINAL_PROMPT = "0";
-  const extraPaths = ["/opt/homebrew/bin", "/usr/local/bin"];
-  const current = (env.PATH ?? "").split(":").filter(Boolean);
-  const missing = extraPaths.filter((p) => !current.includes(p));
-  if (missing.length > 0) {
-    env.PATH = [...current, ...missing].join(":");
-  }
+  addToPathEnv(env, getExtraToolPathDirs(), "back");
   return env;
 }
 

package/src/cli/lib/install-plugin-dependencies.ts

@@ -59,6 +59,7 @@ import { promisify } from "node:util";
 
 import { ensureBun } from "../../util/bun-runtime.js";
 import { getLogger } from "../../util/logger.js";
+import { addToPathEnv } from "../../util/platform.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -331,10 +332,6 @@ export const defaultDependencyInstaller: DependencyInstaller = async ({
  */
 function dependencyInstallEnv(bun: string): NodeJS.ProcessEnv {
   const env: NodeJS.ProcessEnv = { ...process.env };
-  const bunDir = dirname(bun);
-  const current = (env.PATH ?? "").split(":").filter(Boolean);
-  if (!current.includes(bunDir)) {
-    env.PATH = [bunDir, ...current].join(":");
-  }
+  addToPathEnv(env, [dirname(bun)]);
   return env;
 }

package/src/config/feature-flag-registry.json

@@ -412,6 +412,14 @@
       "label": "monday.com Integration",
       "description": "Gates the seeded monday.com OAuth provider. When off, the provider is hidden from GET /v1/oauth/providers, its get-by-id route, and the connect/update routes, so it cannot be listed or connected from the CLI, gateway, or web integrations list. The row is still seeded into oauth_providers on startup; only its visibility changes.",
       "defaultEnabled": false
+    },
+    {
+      "id": "chatgpt-device-code-login",
+      "scope": "client",
+      "key": "chatgpt-device-code-login",
+      "label": "ChatGPT Device Code Login",
+      "description": "Gates the device-code sign-in as the primary ChatGPT subscription connect flow in the web client. Off: the redirect-and-paste flow is the only flow the connect section shows, with no device code UI and no other-sign-in-options disclosure. On: device code leads, and the redirect-and-paste flow stays reachable behind that disclosure and takes the section over when the assistant has no device-auth route.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/platform/platform-patch-queue.test.ts

@@ -3,6 +3,7 @@ import {
   beforeEach,
   describe,
   expect,
+  jest,
   mock,
   setSystemTime,
   test,
@@ -66,14 +67,30 @@ function makeQueue(
   return queue;
 }
 
+const FROZEN_NOW = new Date("2026-01-01T00:00:00.000Z").getTime();
+
+/**
+ * Flush already-queued microtasks. Fake timers stop the clock but not the
+ * promise chain `enqueue` appends onto, so the PATCH work a timer kicks off
+ * lands here.
+ */
 async function settle(): Promise<void> {
-  for (let i = 0; i < 10; i++) {
-    await new Promise((r) => setTimeout(r, 5));
+  for (let i = 0; i < 20; i += 1) {
+    await Promise.resolve();
   }
 }
 
+/** Advance `Date.now()` and the queue's `setTimeout` handles together. */
+async function elapse(ms: number): Promise<void> {
+  setSystemTime(new Date(Date.now() + ms));
+  jest.advanceTimersByTime(ms);
+  await settle();
+}
+
 describe("createPlatformPatchQueue", () => {
   beforeEach(() => {
+    jest.useFakeTimers();
+    setSystemTime(new Date(FROZEN_NOW));
     patches = [];
     builds = 0;
     respond = () => new Response("{}", { status: 200 });
@@ -85,6 +102,8 @@ describe("createPlatformPatchQueue", () => {
     for (const queue of queues) {
       queue.dispose();
     }
+    jest.useRealTimers();
+    setSystemTime();
   });
 
   test("PATCHes once and dedups an unchanged key", async () => {
@@ -203,21 +222,16 @@ describe("createPlatformPatchQueue", () => {
       saveSyncedKey: (synced) => saved.push(synced),
     });
     const start = Date.now();
-    setSystemTime(new Date(start));
-    try {
-      queue.enqueue("a");
-      await settle();
-      setSystemTime(new Date(start + 999));
-      queue.enqueue("a");
-      await settle();
-      setSystemTime(new Date(start + 1000));
-      queue.enqueue("a");
-      await settle();
-      queue.enqueue("a");
-      await settle();
-    } finally {
-      setSystemTime();
-    }
+    queue.enqueue("a");
+    await settle();
+    setSystemTime(new Date(start + 999));
+    queue.enqueue("a");
+    await settle();
+    setSystemTime(new Date(start + 1000));
+    queue.enqueue("a");
+    await settle();
+    queue.enqueue("a");
+    await settle();
 
     expect(patches).toHaveLength(2);
     expect(saved.map((s) => s.syncedAt)).toEqual([start, start + 1000]);
@@ -243,14 +257,12 @@ describe("createPlatformPatchQueue", () => {
     await settle();
     expect(patches).toHaveLength(1);
 
-    await new Promise((r) => setTimeout(r, 300));
-    await settle();
+    await elapse(300);
     expect(patches).toHaveLength(2);
     expect(builds).toBe(2);
 
     queue.dispose();
-    await new Promise((r) => setTimeout(r, 300));
-    await settle();
+    await elapse(300);
     expect(patches).toHaveLength(2);
   });
 
@@ -266,8 +278,7 @@ describe("createPlatformPatchQueue", () => {
     await settle();
     expect(patches).toHaveLength(0);
 
-    await new Promise((r) => setTimeout(r, 300));
-    await settle();
+    await elapse(300);
     expect(patches).toHaveLength(1);
   });
 
@@ -279,12 +290,10 @@ describe("createPlatformPatchQueue", () => {
     expect(patches).toHaveLength(1);
 
     respond = () => new Response("{}", { status: 200 });
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
     expect(patches).toHaveLength(2);
 
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
     queue.enqueue("a");
     await settle();
     expect(patches).toHaveLength(2);
@@ -301,8 +310,7 @@ describe("createPlatformPatchQueue", () => {
     queue.enqueue("a");
     await settle();
     mockClient = makeClient();
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
 
     expect(patches).toHaveLength(1);
   });
@@ -312,14 +320,11 @@ describe("createPlatformPatchQueue", () => {
     respond = () => new Response("nope", { status: 500 });
     queue.enqueue("a");
     await settle();
-    await new Promise((r) => setTimeout(r, 50));
-    await settle();
-    await new Promise((r) => setTimeout(r, 50));
-    await settle();
+    await elapse(50);
+    await elapse(50);
     expect(patches).toHaveLength(3);
 
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
     expect(patches).toHaveLength(3);
   });
 
@@ -332,12 +337,10 @@ describe("createPlatformPatchQueue", () => {
     await settle();
     expect(patches.map((p) => p.body.value)).toEqual(["a", "b"]);
 
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
     expect(patches.map((p) => p.body.value)).toEqual(["a", "b", "b"]);
 
-    await new Promise((r) => setTimeout(r, 100));
-    await settle();
+    await elapse(100);
     expect(patches).toHaveLength(3);
   });
 
@@ -347,8 +350,7 @@ describe("createPlatformPatchQueue", () => {
     queue.enqueue("a");
     await settle();
     queue.dispose();
-    await new Promise((r) => setTimeout(r, 300));
-    await settle();
+    await elapse(300);
 
     expect(patches).toHaveLength(1);
   });

package/src/runtime/routes/__tests__/app-management-shared-apps.test.ts

@@ -0,0 +1,74 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  _listSharedAppsForTests,
+  _resolveSharedAppDirForTests,
+} from "../app-management-routes.js";
+
+let rootDir: string;
+let canonicalDir: string;
+let legacyDir: string;
+
+function writeSharedApp(dir: string, uuid: string, name: string): void {
+  mkdirSync(join(dir, uuid), { recursive: true });
+  writeFileSync(
+    join(dir, `${uuid}-meta.json`),
+    JSON.stringify({
+      uuid,
+      name,
+      entry: "index.html",
+      trustTier: "verified",
+      installedAt: "2026-01-01T00:00:00.000Z",
+    }),
+  );
+  writeFileSync(
+    join(dir, uuid, "manifest.json"),
+    JSON.stringify({ version: "1.0.0", content_id: `content-${uuid}` }),
+  );
+}
+
+beforeEach(() => {
+  rootDir = mkdtempSync(join(tmpdir(), "shared-app-roots-"));
+  canonicalDir = join(rootDir, "canonical");
+  legacyDir = join(rootDir, "legacy");
+});
+
+afterEach(() => {
+  rmSync(rootDir, { recursive: true, force: true });
+});
+
+describe("shared app roots", () => {
+  test("lists canonical and legacy apps after the canonical directory exists", () => {
+    writeSharedApp(canonicalDir, "app-new", "New App");
+    writeSharedApp(legacyDir, "app-legacy", "Legacy App");
+
+    const apps = _listSharedAppsForTests([canonicalDir, legacyDir]);
+
+    expect(apps.map((app) => app.uuid)).toEqual(["app-new", "app-legacy"]);
+  });
+
+  test("prefers the canonical copy when both roots contain the same app", () => {
+    writeSharedApp(canonicalDir, "app-shared", "Canonical App");
+    writeSharedApp(legacyDir, "app-shared", "Legacy App");
+
+    const apps = _listSharedAppsForTests([canonicalDir, legacyDir]);
+
+    expect(apps).toHaveLength(1);
+    expect(apps[0]?.name).toBe("Canonical App");
+    expect(
+      _resolveSharedAppDirForTests("app-shared", [canonicalDir, legacyDir]),
+    ).toBe(canonicalDir);
+  });
+
+  test("resolves a legacy app when it is absent from the canonical root", () => {
+    mkdirSync(canonicalDir, { recursive: true });
+    writeSharedApp(legacyDir, "app-legacy", "Legacy App");
+
+    expect(
+      _resolveSharedAppDirForTests("app-legacy", [canonicalDir, legacyDir]),
+    ).toBe(legacyDir);
+  });
+});

package/src/runtime/routes/app-management-routes.ts

@@ -54,6 +54,7 @@ import { verifyBundleSignature } from "../../bundler/signature-verifier.js";
 import { compareSemver } from "../../daemon/handlers/shared.js";
 import { computeContentId } from "../../util/content-id.js";
 import { getLogger } from "../../util/logger.js";
+import { getUserAppDataDir } from "../../util/platform.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   getOriginClientId,
@@ -73,14 +74,26 @@ const log = getLogger("app-management-routes");
 // Helpers
 // ---------------------------------------------------------------------------
 
-function getSharedAppsDir(): string {
-  return join(
+function getSharedAppsDirs(): string[] {
+  const canonical = join(
+    getUserAppDataDir(),
+    "vellum-assistant",
+    "shared-apps",
+  );
+  const legacy = join(
     homedir(),
     "Library",
     "Application Support",
     "vellum-assistant",
     "shared-apps",
   );
+  return legacy === canonical ? [canonical] : [canonical, legacy];
+}
+
+function resolveSharedAppDir(appUuid: string, dirs: string[]): string | null {
+  return (
+    dirs.find((dir) => existsSync(join(dir, `${appUuid}-meta.json`))) ?? null
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -218,13 +231,9 @@ function getAppDataResult(
   }
 }
 
-function listSharedApps(): Array<Record<string, unknown>> {
-  const dir = getSharedAppsDir();
-  if (!existsSync(dir)) {
-    return [];
-  }
-
-  const files = readdirSync(dir).filter((f) => f.endsWith("-meta.json"));
+function listSharedApps(
+  dirs = getSharedAppsDirs(),
+): Array<Record<string, unknown>> {
   const apps: Array<{
     uuid: string;
     name: string;
@@ -240,43 +249,54 @@ function listSharedApps(): Array<Record<string, unknown>> {
     contentId?: string;
     forked?: boolean;
   }> = [];
+  const seen = new Set<string>();
 
-  for (const file of files) {
-    try {
-      const raw = readFileSync(join(dir, file), "utf-8");
-      const meta = JSON.parse(raw);
-
-      let version: string | undefined;
-      let contentId: string | undefined;
-      const manifestPath = join(dir, meta.uuid, "manifest.json");
-      if (existsSync(manifestPath)) {
-        try {
-          const manifestRaw = readFileSync(manifestPath, "utf-8");
-          const manifest = JSON.parse(manifestRaw);
-          version = manifest.version;
-          contentId = manifest.content_id;
-        } catch {
-          // ignore malformed manifest
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      continue;
+    }
+    const files = readdirSync(dir).filter((f) => f.endsWith("-meta.json"));
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(dir, file), "utf-8");
+        const meta = JSON.parse(raw);
+        if (seen.has(meta.uuid)) {
+          continue;
         }
-      }
 
-      apps.push({
-        uuid: meta.uuid,
-        name: meta.name,
-        description: meta.description,
-        icon: meta.icon,
-        preview: meta.preview,
-        entry: meta.entry,
-        trustTier: meta.trustTier,
-        signerDisplayName: meta.signerDisplayName,
-        bundleSizeBytes: meta.bundleSizeBytes ?? 0,
-        installedAt: meta.installedAt,
-        version,
-        contentId,
-        forked: meta.forked,
-      });
-    } catch {
-      log.warn({ file }, "Failed to read shared app metadata file");
+        let version: string | undefined;
+        let contentId: string | undefined;
+        const manifestPath = join(dir, meta.uuid, "manifest.json");
+        if (existsSync(manifestPath)) {
+          try {
+            const manifestRaw = readFileSync(manifestPath, "utf-8");
+            const manifest = JSON.parse(manifestRaw);
+            version = manifest.version;
+            contentId = manifest.content_id;
+          } catch {
+            // ignore malformed manifest
+          }
+        }
+
+        apps.push({
+          uuid: meta.uuid,
+          name: meta.name,
+          description: meta.description,
+          icon: meta.icon,
+          preview: meta.preview,
+          entry: meta.entry,
+          trustTier: meta.trustTier,
+          signerDisplayName: meta.signerDisplayName,
+          bundleSizeBytes: meta.bundleSizeBytes ?? 0,
+          installedAt: meta.installedAt,
+          version,
+          contentId,
+          forked: meta.forked,
+        });
+        seen.add(meta.uuid);
+      } catch {
+        log.warn({ file }, "Failed to read shared app metadata file");
+      }
     }
   }
 
@@ -314,6 +334,7 @@ function listSharedApps(): Array<Record<string, unknown>> {
 
 function forkSharedApp(
   appUuid: string,
+  dirs = getSharedAppsDirs(),
 ):
   | { success: true; appId: string; name: string }
   | { success: false; error: string } {
@@ -326,12 +347,11 @@ function forkSharedApp(
     return { success: false, error: "Invalid UUID" };
   }
 
-  const dir = getSharedAppsDir();
-  const metaFile = join(dir, `${appUuid}-meta.json`);
-
-  if (!existsSync(metaFile)) {
+  const dir = resolveSharedAppDir(appUuid, dirs);
+  if (!dir) {
     return { success: false, error: "Shared app not found" };
   }
+  const metaFile = join(dir, `${appUuid}-meta.json`);
 
   const metaRaw = readFileSync(metaFile, "utf-8");
   const meta = JSON.parse(metaRaw);
@@ -392,6 +412,19 @@ function forkSharedApp(
   return { success: true, appId: newApp.id, name: newApp.name };
 }
 
+export function _listSharedAppsForTests(
+  dirs: string[],
+): Array<Record<string, unknown>> {
+  return listSharedApps(dirs);
+}
+
+export function _resolveSharedAppDirForTests(
+  appUuid: string,
+  dirs: string[],
+): string | null {
+  return resolveSharedAppDir(appUuid, dirs);
+}
+
 async function openBundle(filePath: string): Promise<Record<string, unknown>> {
   const fileStat = await stat(filePath);
   const bundleSizeBytes = fileStat.size;

package/src/util/bun-runtime.ts

@@ -22,7 +22,7 @@ import { arch, homedir, platform } from "node:os";
 import { basename, join } from "node:path";
 
 import { getLogger } from "./logger.js";
-import { getBinDir } from "./platform.js";
+import { getBinDir, isWindows } from "./platform.js";
 
 const log = getLogger("bun-runtime");
 
@@ -81,19 +81,31 @@ export function findBun(): string | undefined {
     return process.execPath;
   }
 
+  const exe = isWindows() ? "bun.exe" : "bun";
+
   // 2. Previously downloaded copy
-  const downloaded = join(getBinDir(), "bun");
+  const downloaded = join(getBinDir(), exe);
   if (existsSync(downloaded)) {
     return downloaded;
   }
 
   // 3. Common install locations
   const home = homedir();
-  for (const p of [
-    join(home, ".bun", "bin", "bun"),
-    "/opt/homebrew/bin/bun",
-    "/usr/local/bin/bun",
-  ]) {
+  const candidates = isWindows()
+    ? [
+        join(home, ".bun", "bin", exe),
+        join(
+          process.env.LOCALAPPDATA ?? join(home, "AppData", "Local"),
+          "bun",
+          exe,
+        ),
+      ]
+    : [
+        join(home, ".bun", "bin", exe),
+        "/opt/homebrew/bin/bun",
+        "/usr/local/bin/bun",
+      ];
+  for (const p of candidates) {
     if (existsSync(p)) {
       return p;
     }
@@ -108,13 +120,20 @@ export function findBun(): string | undefined {
   return undefined;
 }
 
+/** Escape a string for a PowerShell single-quoted literal. */
+function psQuote(value: string): string {
+  return value.replace(/'/g, "''");
+}
+
 /**
  * Download a pinned bun release into the given directory.
  * Returns the absolute path to the downloaded binary.
  */
 async function downloadBun(installDir: string): Promise<string> {
-  const os = platform();
-  const cpu = arch() === "arm64" ? "aarch64" : arch();
+  const win = isWindows();
+  const os = win ? "windows" : platform();
+  // Bun ships no Windows ARM64 build; the x64 one runs under emulation.
+  const cpu = win ? "x64" : arch() === "arm64" ? "aarch64" : arch();
   const target = `${os}-${cpu}`;
   const url = `https://github.com/oven-sh/bun/releases/download/bun-v${BUN_VERSION}/bun-${target}.zip`;
 
@@ -135,7 +154,15 @@ async function downloadBun(installDir: string): Promise<string> {
 
   try {
     const proc = Bun.spawn({
-      cmd: ["unzip", "-o", tmpZip, "-d", installDir],
+      cmd: win
+        ? [
+            "powershell.exe",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            `Expand-Archive -LiteralPath '${psQuote(tmpZip)}' -DestinationPath '${psQuote(installDir)}' -Force`,
+          ]
+        : ["unzip", "-o", tmpZip, "-d", installDir],
       stdout: "ignore",
       stderr: "pipe",
     });
@@ -146,8 +173,9 @@ async function downloadBun(installDir: string): Promise<string> {
     }
 
     // Move binary from bun-{target}/bun to installDir/bun
-    const extractedBun = join(installDir, `bun-${target}`, "bun");
-    const finalPath = join(installDir, "bun");
+    const exe = win ? "bun.exe" : "bun";
+    const extractedBun = join(installDir, `bun-${target}`, exe);
+    const finalPath = join(installDir, exe);
     if (existsSync(extractedBun)) {
       // Remove old binary first to avoid "Text file busy" on some systems
       if (existsSync(finalPath)) {
@@ -164,7 +192,9 @@ async function downloadBun(installDir: string): Promise<string> {
       );
     }
 
-    chmodSync(finalPath, 0o755);
+    if (!win) {
+      chmodSync(finalPath, 0o755);
+    }
 
     log.info({ path: finalPath }, "Bun binary downloaded successfully");
     return finalPath;

package/src/util/platform.ts

@@ -1,6 +1,14 @@
 import { chmodSync, existsSync, mkdirSync, realpathSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+import {
+  basename,
+  delimiter,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  sep,
+} from "node:path";
 
 import {
   AVATAR_IMAGE_FILENAME,
@@ -54,6 +62,62 @@ export function isWindows(): boolean {
   return process.platform === "win32";
 }
 
+/**
+ * Per-user application data root: `~/Library/Application Support` on macOS,
+ * `%APPDATA%` on Windows, `$XDG_DATA_HOME` (default `~/.local/share`) elsewhere.
+ */
+export function getUserAppDataDir(): string {
+  if (isMacOS()) {
+    return join(homedir(), "Library", "Application Support");
+  }
+  if (isWindows()) {
+    return process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+  }
+  return process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+
+/**
+ * Extra directories to prepend to PATH so daemon-spawned tools are found
+ * even when launched from a minimal environment (macOS .app bundle). Empty
+ * on Windows, where PATH already carries the installer-managed entries.
+ */
+export function getExtraToolPathDirs(): string[] {
+  if (isWindows()) {
+    return [];
+  }
+  return [
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    join(homedir(), ".local", "bin"),
+  ];
+}
+
+/**
+ * Add missing `dirs` to the PATH entry of `env` in place, using the platform
+ * delimiter. Windows keys the variable as `Path`, so the existing key is
+ * matched case-insensitively rather than assuming `PATH`.
+ */
+export function addToPathEnv(
+  env: Record<string, string | undefined>,
+  dirs: string[],
+  position: "front" | "back" = "front",
+): void {
+  if (dirs.length === 0) {
+    return;
+  }
+  const key =
+    Object.keys(env).find((k) => k.toUpperCase() === "PATH") ?? "PATH";
+  const entries = (env[key] ?? "").split(delimiter).filter(Boolean);
+  const missing = dirs.filter((d) => !entries.includes(d));
+  if (missing.length === 0) {
+    return;
+  }
+  env[key] =
+    position === "front"
+      ? [...missing, ...entries].join(delimiter)
+      : [...entries, ...missing].join(delimiter);
+}
+
 /**
  * Returns the raw platform string from Node.js (e.g. 'darwin', 'linux', 'win32').
  * Prefer this over accessing process.platform directly so all platform

package/src/util/sqlite3-runtime.ts

@@ -21,6 +21,10 @@
  */
 
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { isWindows } from "./platform.js";
 
 let cachedSqlite3Path: string | undefined | null;
 
@@ -37,11 +41,27 @@ export function findSqlite3(): string | undefined {
   // 1. Common install locations. We check these before `Bun.which` so we
   //    pick a deterministic, predictable binary even when PATH is
   //    unusual (e.g. a daemon launched with a stripped env).
-  for (const p of [
-    "/usr/bin/sqlite3",
-    "/usr/local/bin/sqlite3",
-    "/opt/homebrew/bin/sqlite3",
-  ]) {
+  const candidates = isWindows()
+    ? [
+        join(
+          process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"),
+          "Programs",
+          "sqlite",
+          "sqlite3.exe",
+        ),
+        join(
+          process.env.ProgramFiles ?? "C:\\Program Files",
+          "SQLite",
+          "sqlite3.exe",
+        ),
+        "C:\\sqlite\\sqlite3.exe",
+      ]
+    : [
+        "/usr/bin/sqlite3",
+        "/usr/local/bin/sqlite3",
+        "/opt/homebrew/bin/sqlite3",
+      ];
+  for (const p of candidates) {
     if (existsSync(p)) {
       cachedSqlite3Path = p;
       return p;

package/src/workspace/git-service.ts

@@ -15,6 +15,7 @@ import { getConfig } from "../config/loader.js";
 import { isFileUnheld } from "../util/file-use.js";
 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";
 
 const execFileAsync = promisify(execFile);
@@ -41,18 +42,7 @@ function cleanGitEnv(workspaceDir: string): Record<string, string> {
   }
   env.GIT_CEILING_DIRECTORIES = workspaceDir;
 
-  const home = process.env.HOME ?? "";
-  const extraDirs = [
-    "/opt/homebrew/bin",
-    "/usr/local/bin",
-    `${home}/.local/bin`,
-  ];
-  const currentPath = env.PATH ?? "";
-  const pathDirs = currentPath.split(":");
-  const missing = extraDirs.filter((d) => !pathDirs.includes(d));
-  if (missing.length > 0) {
-    env.PATH = [...missing, currentPath].filter(Boolean).join(":");
-  }
+  addToPathEnv(env, getExtraToolPathDirs());
 
   return env;
 }