@gleapai/kai-bridge 0.11.0 → 0.12.0

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@gleapai/kai-bridge",
-      "version": "0.11.0",
+      "version": "0.12.0",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Kai Code Bridge runs Kai Code on your computer or server with your own coding subscriptions and local previews.",
   "type": "module",
   "license": "MIT",

package/src/api.mjs

@@ -4,6 +4,7 @@
 //   POST   /gleapcode/bridge/pair/poll             → { status, device?, token? } (pollToken)
 //   PUT    /gleapcode/bridge/devices/me/hello      { name, platform, version, profiles, repos, roots }
 //   POST   /gleapcode/bridge/devices/me/heartbeat  { running: [turnIds] }
+//   POST   /gleapcode/bridge/turns/:id/ack         { via }   → 410 when the turn already ended
 //   POST   /gleapcode/bridge/turns/:id/events      { events: [contract lines] }
 //   POST   /gleapcode/bridge/turns/:id/result      { result, changes, status }
 //   POST   /gleapcode/bridge/devices/me/public-hosts { sessionId, services } → { domain, hosts, tunnel, displaced }
@@ -96,6 +97,15 @@ export class BridgeApi {
   heartbeat(payload) {
     return this.request("POST", "/gleapcode/bridge/devices/me/heartbeat", payload);
   }
+  /**
+   * "This machine has the turn" — sent for every delivery of a
+   * `bridge.turn.start` (push, the Server's re-send, the pending poll); the
+   * Server stops re-sending once one lands. Short timeout: the turn does not
+   * wait on a slow Server. 410 = the turn ended before it got here.
+   */
+  turnAck(turnId, payload) {
+    return this.request("POST", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/ack`, payload, { timeoutMs: 5_000 });
+  }
   turnEvents(turnId, events) {
     return this.request("POST", `/gleapcode/bridge/turns/${encodeURIComponent(turnId)}/events`, { events });
   }

package/src/daemon.mjs

@@ -5,7 +5,9 @@ import { cloneRepository, locateRepository } from './repository-setup.mjs';
 //
 // Commands arrive on `private-bridge-<deviceId>` (Sockudo / Pusher
 // protocol, the same channel family the dashboard uses):
-//   bridge.turn.start   { commandId, turnId, sessionId, profileId, repos:[{key, mode, base, carryUncommitted}], ...AgentRunOpts }
+//   bridge.turn.start   { turnId, sessionId, profileId, repos:[{key, mode, base, carryUncommitted}], resend?, ...AgentRunOpts }
+//                        — acknowledged with POST /turns/:id/ack; the Server re-sends an
+//                        unacknowledged start (`resend: n`), so a turn id seen before is ignored
 //   bridge.turn.cancel  { turnId }
 //   bridge.turn.steer   { turnId, steer: { id, text } }   — inject into the running turn;
 //                        answered with a {type:"steer", id, outcome} turn event
@@ -57,6 +59,8 @@ const REALTIME_RETRY_MS = 15_000;
 const HEARTBEAT_MS = 30_000;
 /** Safety net under the realtime channel: ask the server for work it thinks we run (see pullPendingWork). */
 const PENDING_POLL_MS = 60_000;
+/** Turn ids remembered after they ran, so a late duplicate delivery never runs twice (see startTurn). */
+const HANDLED_TURNS_MAX = 200;
 const USAGE_REFRESH_MS = 10 * 60_000;
 // Harness model catalogues change on releases, not by the minute.
 const MODELS_REFRESH_MS = 6 * 60 * 60_000;
@@ -563,6 +567,42 @@ export class BridgeDaemon {
     this.writeInflight(this.readInflight().filter((e) => e.turnId !== turnId));
   }
 
+  get handledTurnsPath() {
+    return join(this.kaiHome, "state", "handled-turns.json");
+  }
+
+  /**
+   * Turn ids this machine already ran (newest last, capped). Kept on disk:
+   * a turn whose result was lost is still "running" on the Server, and the
+   * pending poll after a restart must not run it a second time.
+   */
+  handledTurns() {
+    if (!this.handled) {
+      let ids = [];
+      try {
+        const raw = JSON.parse(readFileSync(this.handledTurnsPath, "utf8"));
+        if (Array.isArray(raw)) ids = raw.filter((id) => typeof id === "string");
+      } catch {
+        /* none yet */
+      }
+      this.handled = new Set(ids.slice(-HANDLED_TURNS_MAX));
+    }
+    return this.handled;
+  }
+
+  rememberHandledTurn(turnId) {
+    const handled = this.handledTurns();
+    handled.delete(turnId);
+    handled.add(turnId);
+    while (handled.size > HANDLED_TURNS_MAX) handled.delete(handled.values().next().value);
+    try {
+      mkdirSync(join(this.kaiHome, "state"), { recursive: true });
+      writeFileSync(this.handledTurnsPath, JSON.stringify([...handled]));
+    } catch {
+      /* best effort */
+    }
+  }
+
   /** Turns this machine was running when it was killed — report them dead. */
   async reportInterruptedTurns() {
     const entries = this.readInflight();
@@ -571,6 +611,8 @@ export class BridgeDaemon {
     for (const entry of entries) {
       const { turnId } = entry;
       this.log("warn", "turn.interrupted", { turnId, agent: entry.agent });
+      // Reported failed below; a re-send or a poll must not start it over.
+      this.rememberHandledTurn(turnId);
       await this.api
         .turnResult(turnId, {
           status: "failed",
@@ -867,8 +909,11 @@ export class BridgeDaemon {
       }
       for (const turn of pending?.turns || []) {
         if (this.running.has(turn.turnId) || cancelled.has(String(turn.turnId))) continue;
+        // Ran here already and its result never landed: the Server's reaper
+        // settles it — running the work again is never the fix.
+        if (this.handledTurns().has(turn.turnId)) continue;
         this.log("info", "turn.recovered", { turnId: turn.turnId, via });
-        void this.startTurn(turn).catch((err) => this.log("error", "turn.recover.failed", { error: err.message }));
+        void this.startTurn(turn, { via }).catch((err) => this.log("error", "turn.recover.failed", { error: err.message }));
       }
     } catch (err) {
       // Older server without the endpoint, or the server is restarting: the
@@ -931,7 +976,7 @@ export class BridgeDaemon {
             .catch((err) => this.log("warn", "update.turn.refused.failed", { turnId: data.turnId, error: err?.message }));
           return;
         }
-        return this.startTurn(data);
+        return this.startTurn(data, { via: data?.resend ? "resend" : "push" });
       case "bridge.turn.cancel":
         this.running.get(data.turnId)?.ctrl.abort();
         return;
@@ -1665,9 +1710,10 @@ export class BridgeDaemon {
   }
 
   /** Map the Server's repo bindings onto local checkouts; throw a readable error when one is missing. */
-  async bindRepos(turn) {
+  async bindRepos(turn, { onPrepare, signal } = {}) {
     const bound = [];
     for (const r of turn.repos || []) {
+      if (signal?.aborted) break; // stopped mid-prep: the caller reports the cancel
       const group = this.repoGroups.find((g) => g.key === r.key);
       if (!group) throw new Error(`Repository ${r.key} is not checked out on this device.`);
       const mode = r.mode || this.config.repoModes?.[r.key] || "worktree";
@@ -1678,6 +1724,7 @@ export class BridgeDaemon {
         sessionId: turn.sessionId,
         title: turn.title,
         gitEnv,
+        onPrepare,
       }));
       bound.push({ key: r.key, ...ws });
       if (ws.deps) this.log("info", "deps.seed", { repo: r.key, ...ws.deps });
@@ -1736,11 +1783,25 @@ export class BridgeDaemon {
     return adopted;
   }
 
-  async startTurn(turn) {
+  /**
+   * `via` = how the turn reached us: push, resend (the Server re-sent an
+   * unacknowledged start), poll or reconnect (pullPendingWork).
+   */
+  async startTurn(turn, { via = "push" } = {}) {
     const { turnId } = turn;
-    if (this.running.has(turnId)) return;
+    // One turn, several deliveries by design: the Server re-sends a start
+    // until it is acknowledged, and the poll / reconnect pull replays what
+    // the Server still expects. Only the first delivery runs. Every one is
+    // acknowledged — a duplicate usually means the first ack was missed.
+    if (this.running.has(turnId) || this.handledTurns().has(turnId)) {
+      this.log("info", "turn.duplicate", { turnId, via, running: this.running.has(turnId) });
+      await this.ackTurn(turnId, via);
+      return;
+    }
     const ctrl = new AbortController();
     const entry = { ctrl, control: null, sessionId: turn.sessionId };
+    // Claimed before the first await, so a second delivery arriving while
+    // the ack is in flight is the duplicate above.
     this.running.set(turnId, entry);
     const releaseAwake = keepAwake();
     let outcome = null;
@@ -1749,8 +1810,39 @@ export class BridgeDaemon {
     this.rememberInflight(turnId, { sessionId: turn.sessionId, agent: turn.agent ?? null, harness: turn.harness ?? null, profileId: turn.profileId ?? null, startedAt: new Date().toISOString(), ...session });
     const batcher = createEventBatcher({ api: this.api, turnId, onError: (err) => this.log("warn", "events.post.failed", { error: err.message }) });
     try {
+      // Receipt first: the Server stops re-sending the start.
+      if ((await this.ackTurn(turnId, via)) === "ended") {
+        // Stopped or reaped before it reached this machine — nobody is
+        // waiting for it, and its result would be refused anyway.
+        this.log("info", "turn.ended_before_start", { turnId, via });
+        return;
+      }
       const profile = resolveProfiles(this.config, this.kaiHome).find((p) => p.id === turn.profileId) ?? { id: "gleap-key", kind: "gleap-key", harness: turn.harness };
-      const bound = await this.bindRepos(turn);
+      // Prep no longer blocks the daemon, so a Stop (or session close) can
+      // land before the runner exists — and runTurn's abort listener would
+      // never hear a signal that fired before it was added. Never start the
+      // agent for a turn that was stopped on the way.
+      const stoppedBeforeRun = () => {
+        if (!ctrl.signal.aborted) return false;
+        this.log("info", "turn.cancelled_before_run", { turnId });
+        outcome = { status: "cancelled", changes: [], profileId: profile.id };
+        return true;
+      };
+      if (stoppedBeforeRun()) return;
+      // A fresh worktree costs a fetch, a checkout and a node_modules clone
+      // — up to minutes for a big repo — while the dashboard already calls
+      // the session running. Say what is happening before it starts (once
+      // per turn; resumed worktrees and local checkouts skip it).
+      let preparing = null;
+      const onPrepare = () => {
+        preparing ??= (async () => {
+          batcher.push({ type: "tool_status", message: `Preparing workspace on ${this.config.device?.name || "this machine"}…` });
+          await batcher.flush();
+        })();
+        return preparing;
+      };
+      const bound = await this.bindRepos(turn, { onPrepare, signal: ctrl.signal });
+      if (stoppedBeforeRun()) return;
       // Multi-repo: the runner's cwd is the first repo; the others are
       // reachable as siblings under the same worktree root or by their
       // local paths — the prompt lists them.
@@ -1764,6 +1856,7 @@ export class BridgeDaemon {
       const live = await this.describeLivePreview(turn, bound, batcher);
       const previewNote = live.note;
       const mcpServers = live.hasLivePreview ? [...(turn.mcpServers || []), previewMcpServer(RUNNER_DIR)] : turn.mcpServers;
+      if (stoppedBeforeRun()) return;
       const res = await runTurn({
         turn: { ...turn, task: `${turn.task}${repoNote}${previewNote}`, mcpServers },
         profile,
@@ -1861,12 +1954,30 @@ export class BridgeDaemon {
           .catch((err) => this.log("error", "result.lost", { turnId, error: err.message }));
       }
       this.forgetInflight(turnId);
+      this.rememberHandledTurn(turnId);
       releaseAwake();
       this.running.delete(turnId);
       if ((this.updatePending || this.restartPending) && this.running.size === 0) void this.checkForUpdate();
     }
   }
 
+  /**
+   * Tell the Server this machine has the turn. Resolves "acked", "ended"
+   * (410: the turn is over — it must not run), or "unknown" (an older Server
+   * without the route, a network hiccup): the turn then runs as it always
+   * did. Never throws.
+   */
+  async ackTurn(turnId, via) {
+    try {
+      await this.api.turnAck(turnId, { via });
+      return "acked";
+    } catch (err) {
+      if (err?.status === 410) return "ended";
+      this.log(err?.status === 404 ? "debug" : "warn", "turn.ack.failed", { turnId, via, error: err?.message });
+      return "unknown";
+    }
+  }
+
   // ── preview browser ────────────────────────────────────────────────
   /** Overridable seam (tests, embedded hosts): a browser the warm-up and the Playwright MCP can launch. */
   ensurePreviewBrowser() {

package/src/deps.mjs

@@ -11,7 +11,7 @@
 // yet) we leave the directory absent and the install path takes over with
 // the lockfile-driven, cache-first command instead of a bare `npm install`.
 
-import { execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync, statSync } from "node:fs";
 import { platform } from "node:os";
@@ -84,24 +84,45 @@ export function canSeedNodeModules({ primaryPath, cwd }) {
   return { ok: true, reason: "lockfile_match", pm: b.pm };
 }
 
+/**
+ * `cmd args` as a promise, output discarded (stderr's head kept for the
+ * reason). Asynchronous on purpose: cloning a big `node_modules` takes 30 s
+ * to 2.5 min (bridge.log: 144 s for the Gleap dashboard, 105 s for the
+ * Server), and a synchronous copy froze the daemon for all of it.
+ */
+function runQuiet(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 2000) stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with ${code ?? signal}${stderr.trim() ? `: ${stderr.trim().slice(0, 500)}` : ""}`));
+    });
+  });
+}
+
 /**
  * Copy the primary checkout's `node_modules` into a fresh worktree when
- * the lockfiles match. Returns `{ seeded, reason, ms }`; never throws — a
+ * the lockfiles match. Resolves `{ seeded, reason, ms }`; never rejects — a
  * failed or partial copy is removed so the install path still runs.
  *
  * macOS `cp -c` clones via clonefile(2) and falls back to a plain copy on
  * filesystems without it; `-R` without `-L` keeps symlinks as symlinks
  * (`.bin` shims, pnpm's store links — all relative, so they stay valid).
  */
-export function seedNodeModules({ primaryPath, cwd, os = platform(), exec = execFileSync }) {
+export async function seedNodeModules({ primaryPath, cwd, os = platform(), exec = runQuiet }) {
   const started = Date.now();
   const check = canSeedNodeModules({ primaryPath, cwd });
   if (!check.ok) return { seeded: false, reason: check.reason, ms: 0 };
   const src = join(primaryPath, "node_modules");
   const dst = join(cwd, "node_modules");
   try {
-    if (os === "darwin") exec("cp", ["-c", "-R", src, dst], { stdio: "ignore" });
-    else if (os === "linux") exec("cp", ["-R", "--reflink=auto", src, dst], { stdio: "ignore" });
+    if (os === "darwin") await exec("cp", ["-c", "-R", src, dst]);
+    else if (os === "linux") await exec("cp", ["-R", "--reflink=auto", src, dst]);
     else return { seeded: false, reason: "unsupported_platform", ms: 0 };
     return { seeded: true, reason: check.reason, ms: Date.now() - started };
   } catch (err) {

package/src/workspace.mjs

@@ -12,19 +12,64 @@
 // another a worktree). Git ops ported from the retired desktop runtime's
 // git-checkout-ops.mjs in spirit: plain `git` CLI, no libraries.
 
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { seedNodeModules } from "./deps.mjs";
 
+const execFileAsync = promisify(execFile);
+
 function git(cwd, args, opts = {}) {
   return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...opts }).trim();
 }
 
+/**
+ * `git` that leaves the daemon's event loop alone. Preparing a fresh
+ * worktree takes minutes on a big repo (fetch, checkout, the node_modules
+ * clone); run with execFileSync it froze the whole daemon for that long —
+ * no heartbeat (the device could read "away" after 90 s), no realtime pongs, and
+ * the next turn's start and the user's Stop sat in the queue until it was
+ * done (bridge.log 2026-09-11 and 09-18: a start logged the millisecond a
+ * 60-second node_modules clone for another turn finished). stdin is closed
+ * right away, like execFileSync's "ignore": nothing may wait on a prompt.
+ */
+async function gitAsync(cwd, args, opts = {}) {
+  const pending = execFileAsync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, ...opts });
+  pending.child.stdin?.end();
+  const { stdout } = await pending;
+  return String(stdout).trim();
+}
+
 /** Network ops only: `gitEnv` is the git-auth.mjs fallback, applied to that one command. */
 const withGitEnv = (gitEnv, opts = {}) => (gitEnv ? { ...opts, env: { ...process.env, ...gitEnv } } : opts);
 
+/**
+ * Nobody can answer a prompt from a background daemon: a credential or
+ * passphrase prompt fails fast instead of hanging the fetch (git-auth.mjs
+ * then offers the Server's credentials) — the same hardening the clone path
+ * has. A user's own GIT_SSH_COMMAND wins.
+ */
+const nonInteractiveGitEnv = (gitEnv) => ({
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_ASKPASS: "echo",
+  SSH_ASKPASS: "echo",
+  GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || "ssh -o BatchMode=yes",
+  ...(gitEnv || {}),
+});
+
+/**
+ * The prep fetch had no limit: a black-holed network (captive portal,
+ * dropped VPN) left the session "running" with nothing running. A single
+ * branch of even a large repo arrives well within this.
+ */
+export const FETCH_TIMEOUT_MS = 120_000;
+
+/** The child was killed because it ran past its `timeout` (async and sync forms). */
+const isTimeout = (err) => err?.code === "ETIMEDOUT" || (err?.killed === true && err?.signal === "SIGTERM");
+
 /**
  * A workspace could not be prepared for a reason that has nothing to do
  * with the task — the Server surfaces `code` as a one-click retry instead
@@ -64,38 +109,43 @@ export function isRefLockContention(message) {
   );
 }
 
-const sleepSync = (ms) => {
-  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-};
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 /**
  * `git fetch origin <base>` in `primaryPath`, tolerant of ref-lock
- * contention. Returns `{ attempts, stale }` — `stale: true` means every
+ * contention. Resolves `{ attempts, stale }` — `stale: true` means every
  * attempt lost the race and the existing `origin/<base>` (which the
- * competitor just updated) is used instead. Any other fetch failure, or
- * contention with no usable `origin/<base>`, throws a WorkspaceError
- * whose `code` the Server turns into a retry offer.
+ * competitor just updated) is used instead. Any other fetch failure, a
+ * fetch that runs past `timeoutMs`, or contention with no usable
+ * `origin/<base>` rejects with a WorkspaceError whose `code` the Server
+ * turns into a retry offer.
  */
-export function fetchBase(primaryPath, base, { exec = git, attempts = 4, backoffMs = 400, sleep = sleepSync, repo = primaryPath, gitEnv = null } = {}) {
+export async function fetchBase(primaryPath, base, { exec = gitAsync, attempts = 4, backoffMs = 400, sleep = pause, repo = primaryPath, gitEnv = null, timeoutMs = FETCH_TIMEOUT_MS } = {}) {
   let lastError = null;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      exec(primaryPath, ["fetch", "origin", base, "--quiet"], withGitEnv(gitEnv));
+      await exec(primaryPath, ["fetch", "origin", base, "--quiet"], { timeout: timeoutMs, env: nonInteractiveGitEnv(gitEnv) });
       return { attempts: attempt, stale: false };
     } catch (err) {
+      if (isTimeout(err)) {
+        throw new WorkspaceError(
+          `git fetch origin ${base} in ${repo} did not finish within ${Math.round(timeoutMs / 1000)} s — check this machine's network and Git access, then retry the task.`,
+          { code: "workspace_fetch_failed", repo, cause: err },
+        );
+      }
       const text = `${err?.stderr || ""}\n${err?.message || ""}`;
       if (!isRefLockContention(text)) {
         throw new WorkspaceError(err?.message || String(err), { code: "workspace_fetch_failed", repo, cause: err });
       }
       lastError = err;
-      if (attempt < attempts) sleep(backoffMs * attempt);
+      if (attempt < attempts) await sleep(backoffMs * attempt);
     }
   }
   // Every attempt lost: whoever kept winning has already moved
   // origin/<base> forward, so it is at least as fresh as our fetch
   // would have made it.
   try {
-    exec(primaryPath, ["rev-parse", "--verify", "--quiet", `origin/${base}^{commit}`]);
+    await exec(primaryPath, ["rev-parse", "--verify", "--quiet", `origin/${base}^{commit}`]);
     return { attempts, stale: true };
   } catch {
     throw new WorkspaceError(
@@ -147,13 +197,16 @@ export function copyPrimaryEnvFiles(primaryPath, cwd) {
 }
 
 /**
- * Materialise one repo binding. Returns `{ cwd, mode, branch, base }`.
+ * Materialise one repo binding. Resolves `{ cwd, mode, branch, base }`.
  * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted? }`.
+ * `onPrepare({ repo, base })` is awaited once a fresh worktree has to be
+ * built — the slow path (fetch, checkout, node_modules) — before any of it
+ * starts; resumed worktrees and local checkouts never call it.
  */
-export function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null }) {
+export async function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null, onPrepare = null }) {
   const mode = binding?.mode === "local" ? "local" : "worktree";
   if (mode === "local") {
-    const branch = git(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branch = await gitAsync(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
     return { cwd: repo.primaryPath, mode, branch, base: branch };
   }
   const base = binding?.base || repo.defaultBranch || "main";
@@ -164,26 +217,27 @@ export function materializeBinding({ kaiHome, repo, binding, sessionId, title, b
     // Resume: the worktree from the previous turn is the session state.
     return { cwd: dir, mode, branch, base, resumed: true };
   }
+  await onPrepare?.({ repo: repo.name, base });
   mkdirSync(dirname(dir), { recursive: true });
-  const fetched = fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
-  git(repo.primaryPath, ["worktree", "add", "-b", branch, dir, `origin/${base}`]);
+  const fetched = await fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
+  await gitAsync(repo.primaryPath, ["worktree", "add", "-b", branch, dir, `origin/${base}`]);
   // A fresh worktree has no node_modules; clone the primary checkout's
   // when the lockfiles match so the agent's tests and the preview boot
   // don't each start with a 2-minute install (see deps.mjs).
-  const deps = seedNodeModules({ primaryPath: repo.primaryPath, cwd: dir });
+  const deps = await seedNodeModules({ primaryPath: repo.primaryPath, cwd: dir });
   if (binding?.carryUncommitted) {
     // Tracked changes as a patch; untracked (non-ignored) files copied.
-    const patch = git(repo.primaryPath, ["diff", "HEAD"], { maxBuffer: 64 * 1024 * 1024 });
+    const patch = await gitAsync(repo.primaryPath, ["diff", "HEAD"]);
     if (patch) {
       const patchPath = join(dir, ".kai-carry.patch");
       writeFileSync(patchPath, patch + "\n");
       try {
-        git(dir, ["apply", "--3way", patchPath]);
+        await gitAsync(dir, ["apply", "--3way", patchPath]);
       } finally {
         rmSync(patchPath, { force: true });
       }
     }
-    const untracked = git(repo.primaryPath, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+    const untracked = (await gitAsync(repo.primaryPath, ["ls-files", "--others", "--exclude-standard"])).split("\n").filter(Boolean);
     for (const rel of untracked) {
       try {
         mkdirSync(dirname(join(dir, rel)), { recursive: true });