@gleapai/kai-bridge 0.11.0 → 0.12.1

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "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/runner/acp-runner.mjs

@@ -41,7 +41,7 @@ import {
   traceLog,
 } from "./lib/contract.mjs";
 import { deriveEngineSlug, getHarness, isNativeAnthropic, pickSessionConfigOptions, pickSessionMode, resolveHarnessId } from "./lib/acp/harnesses.mjs";
-import { createAcpMapper, permissionPolicy } from "./lib/acp/mapper.mjs";
+import { createAcpMapper, createReplayRecorder, permissionPolicy } from "./lib/acp/mapper.mjs";
 import { describeProviderError, extractProviderError } from "./lib/acp/providerError.mjs";
 import { aggregateUsageRows, lastRootContextSnapshot } from "./lib/acp/transcripts.mjs";
 import { needsWireProxy, startWireProxy } from "./lib/wire-proxy.mjs";
@@ -60,6 +60,7 @@ const {
   maxBudgetUsd: MAX_BUDGET_USD,
   task: TASK,
   feedback: FEEDBACK,
+  rehydratedTask: REHYDRATED_TASK,
   questionAnswers: QUESTION_ANSWERS,
   attachments: ATTACHMENTS,
   customSystemPrompt: CUSTOM_SYSTEM_PROMPT,
@@ -76,7 +77,7 @@ const HARNESS_ID = resolveHarnessId(ARGS.argv.harness, MODEL);
 const HARNESS = getHarness(HARNESS_ID);
 const IS_ARTIFACT_WRITER = isArtifactWriterAgent(AGENT);
 
-if (!TASK) {
+if (!TASK && !REHYDRATED_TASK) {
   emitSync({ type: "error", message: "runner: missing --task-b64 argument" });
   process.exit(1);
 }
@@ -244,10 +245,17 @@ async function downloadAttachments() {
   return saved;
 }
 
-function buildPrompt(savedAttachments = []) {
+function buildPrompt(savedAttachments = [], { resumed = false } = {}) {
   const sections = [];
   const answers = renderAnswersBlock();
-  if (FEEDBACK) {
+  if (REHYDRATED_TASK && !resumed) {
+    // A fresh session has no memory of the earlier turns, and the
+    // feedback alone reached a blank agent — including when the host
+    // asked for a resume that did not happen (no transcript on disk,
+    // session/resume failed). The host's rehydrated task already carries
+    // the task, plan, summary, recent turns, feedback and answers.
+    sections.push(REHYDRATED_TASK);
+  } else if (FEEDBACK) {
     sections.push(FEEDBACK);
     if (answers) sections.push(answers);
   } else if (answers) {
@@ -535,6 +543,8 @@ async function main() {
   let conn;
   let acpSessionId = null;
   let cancelRequested = null;
+  /** Set while a `session/load` replays the chat (createReplayRecorder). */
+  let replay = null;
 
   const mcpServerIds = {};
   for (const server of MCP_SERVERS || []) {
@@ -595,6 +605,8 @@ async function main() {
         return { outcome: { outcome: "selected", optionId } };
       },
       async sessionUpdate(params) {
+        // The replay of a `session/load` is the chat's history, not this turn.
+        if (replay) return replay.record(params.update);
         mapper.handleUpdate(params.update);
       },
       // AskUserQuestion arrives as a form elicitation (claude-agent-acp only
@@ -635,27 +647,60 @@ async function main() {
   }
 
   const mcpServers = HARNESS.sessionMcpServers(ctx, buildAcpMcpServers());
-  // Resume only when the harness can actually find the prior session on
-  // disk — the FIRST turn of a session ships a session id too, and a
+  // Continue the prior session only when the harness can actually find it
+  // on disk — the FIRST turn of a session ships a session id too, and a
   // resume against nothing fails after seconds of adapter retries.
-  const canResume =
-    !!SESSION_ID &&
-    !!init.agentCapabilities?.sessionCapabilities?.resume &&
-    (HARNESS.hasResumableSession ? HARNESS.hasResumableSession(ctx) : true);
+  // `session/resume` picks the session up silently; an agent that can only
+  // reload one (Cursor: `loadSession`, no `sessionCapabilities.resume`)
+  // gets `session/load`, which replays the chat before it answers.
+  const agentCaps = init.agentCapabilities ?? {};
+  const continueVia = !SESSION_ID ? null : agentCaps.sessionCapabilities?.resume ? "resume" : agentCaps.loadSession === true ? "load" : null;
+  const canContinue = !!continueVia && (HARNESS.hasResumableSession ? HARNESS.hasResumableSession(ctx) : true);
   // What the session's earlier turns already cost (Claude: the total the
   // transcript saved — a resumed query's cost figure continues from it).
   // Read before the resume appends this turn's record.
-  const priorTurnsCostUsd = canResume ? Number(HARNESS.priorTurnsCostUsd?.(ctx)) || 0 : 0;
+  const priorTurnsCostUsd = canContinue ? Number(HARNESS.priorTurnsCostUsd?.(ctx)) || 0 : 0;
   let sessionResponse;
-  let resumed = false;
-  if (canResume) {
+  /** The call that continued the harness session; null = a new session. */
+  let continuedVia = null;
+  /** What that `session/load` replayed (createReplayRecorder). */
+  let loaded = null;
+  if (canContinue && continueVia === "resume") {
     try {
       sessionResponse = await conn.resumeSession({ sessionId: SESSION_ID, cwd: WORK_DIR, mcpServers, _meta: HARNESS.sessionMeta(ctx) });
-      resumed = !!sessionResponse;
+      if (sessionResponse) continuedVia = "resume";
     } catch (err) {
       traceLog("resume.failed", { error: String(err?.message ?? err) });
     }
-  }
+  } else if (canContinue) {
+    const recorder = createReplayRecorder();
+    replay = recorder;
+    try {
+      sessionResponse =
+        (await conn.loadSession({
+          sessionId: SESSION_ID,
+          cwd: WORK_DIR,
+          mcpServers,
+          ...(ctx.additionalDirectories.length > 0 ? { additionalDirectories: ctx.additionalDirectories } : {}),
+          _meta: HARNESS.sessionMeta(ctx),
+        })) ?? {};
+      continuedVia = "load";
+      loaded = recorder;
+    } catch (err) {
+      traceLog("load.failed", { error: String(err?.message ?? err), replayed: recorder.updates });
+    }
+    // Belt and braces: the replay precedes the answer on the wire, and SDK
+    // 1.5 finishes its handlers before resuming us, but every notification
+    // runs its own async handler chain — one macrotask lets any still in
+    // flight land in the recorder before this turn's updates reach the mapper.
+    await new Promise((resolve) => setImmediate(resolve));
+    replay = null;
+    if (loaded) traceLog("load.replayed", { updates: loaded.updates, userMessages: loaded.userMessages.length });
+  }
+  // The agent has the earlier turns: a resumed session, or a loaded chat
+  // that replayed at least one of them. Cursor answers the load even when
+  // it cannot read the conversation back; such a chat has nothing to go on.
+  const resumed = continuedVia === "resume" || (continuedVia === "load" && loaded.userMessages.length > 0);
   if (!sessionResponse) {
     // The fallback must be a CLEAN start: `_meta` built with the resume id
     // still in it makes claude-agent-acp re-run the query against the
@@ -667,13 +712,16 @@ async function main() {
       _meta: HARNESS.sessionMeta({ ...ctx, resumeSessionId: null }),
     });
   }
-  // codex-acp's `session/load` response is an empty object per the ACP
-  // spec (the id is the one we asked for) — reading `.sessionId` off it
-  // left every later call with `sessionId: undefined` → "Invalid params"
-  // and the whole resumed turn failed.
-  acpSessionId = sessionResponse.sessionId ?? (resumed ? SESSION_ID : null);
+  // A continued session answers without an id — `session/load` per the ACP
+  // spec, codex-acp's resume too; it is the one we asked for. Reading
+  // `.sessionId` off it left every later call with `sessionId: undefined`
+  // → "Invalid params" and the whole resumed turn failed.
+  acpSessionId = sessionResponse.sessionId ?? (continuedVia ? SESSION_ID : null);
   ctx.sessionId = acpSessionId;
-  traceLog("session", { sessionId: acpSessionId, resumed });
+  // What the harness's promptPrefix keys on (below).
+  ctx.resumed = resumed;
+  ctx.priorUserMessages = loaded ? loaded.userMessages : null;
+  traceLog("session", { sessionId: acpSessionId, resumed, ...(continuedVia ? { via: continuedVia } : {}) });
   startControlChannel({
     isInFlight: () => inFlight,
     steeringSupported,
@@ -714,10 +762,13 @@ async function main() {
   // rules — shell redirections can still write).
   const REVERTS_REPO = IS_ARTIFACT_WRITER;
   const baselines = REVERTS_REPO ? captureRepoBaselines(WORK_DIR) : null;
-  // Harnesses without a system-prompt channel (Cursor) get the persona as
-  // a prefix of the first prompt.
+  // Harnesses without a system-prompt channel (Cursor) carry the persona in
+  // the prompt: in every new session — keyed on whether the session was
+  // actually continued (ctx.resumed), not on whether that was asked for —
+  // and in a continued one that does not hold it yet.
   const promptPrefix = HARNESS.promptPrefix?.(ctx) || "";
-  const prompt = (promptPrefix ? `${promptPrefix}\n\n---\n\n` : "") + buildPrompt(savedAttachments);
+  if (REHYDRATED_TASK && !resumed && SESSION_ID) traceLog("resume.rehydrated", { sessionId: SESSION_ID });
+  const prompt = (promptPrefix ? `${promptPrefix}\n\n---\n\n` : "") + buildPrompt(savedAttachments, { resumed });
   let stopReason = "end_turn";
   let promptError = null;
   try {

package/runner/lib/acp/harnesses.mjs

@@ -404,7 +404,9 @@ HARNESSES.cursor = {
    * it runs on the user's Cursor login (or CURSOR_API_KEY); Gleap has no
    * Cursor credentials, so the cloud never selects it. ACP v1 with
    * loadSession + MCP over http/sse on session/new (probed 2026-08-23,
-   * build 2026.08.11). Binary is `cursor-agent` (legacy alias `agent`,
+   * build 2026.08.11). No `sessionCapabilities.resume` (builds 2026.08.11
+   * and 2026.09.18 advertise only `list`), so follow-ups continue the chat
+   * through `session/load`. Binary is `cursor-agent` (legacy alias `agent`,
    * which collides with other vendors' CLIs — resolve by explicit path).
    */
   requiredEnv: (ctx) => (ctx.byoLogin ? null : "CURSOR_API_KEY"),
@@ -419,10 +421,20 @@ HARNESSES.cursor = {
   // Mode ids come from the session/new response; first match wins.
   sessionModePreference: (ctx) => (ctx.isPlanMode || ctx.isArtifactWriter ? ["plan", "ask", "read-only"] : ["agent", "default"]),
   /**
-   * No system-prompt channel over ACP and no per-profile config dir:
-   * the persona travels as a prefix of the first prompt instead.
+   * No system-prompt channel over ACP and no per-profile config dir: the
+   * persona travels as a prefix of the prompt instead. Every new chat gets
+   * it. A continued chat (`ctx.resumed`) already holds it from an earlier
+   * prompt, unless its replayed user messages (`ctx.priorUserMessages`,
+   * from `session/load`) lack these exact instructions: they changed since
+   * (a plan turn's guards give way to the build's git hand-off rule, edited
+   * project instructions) or never went in. Then it rides again.
    */
-  promptPrefix: (ctx) => (ctx.resumeSessionId ? "" : ctx.appendSystemPrompt || ""),
+  promptPrefix: (ctx) => {
+    const instructions = ctx.appendSystemPrompt || "";
+    if (!ctx.resumed) return instructions;
+    const prior = ctx.priorUserMessages;
+    return Array.isArray(prior) && !prior.some((m) => m.includes(instructions)) ? instructions : "";
+  },
   /** No transcript with a per-request split — context comes from usage_update; BYO bills nothing. */
   collectTurnUsage: () => ({ path: null, rows: [], contextWindow: null }),
   canonicalModel: (ctx, raw) => {

package/runner/lib/acp/mapper.mjs

@@ -661,3 +661,41 @@ export function createAcpMapper({ emit, isPlanMode = false, onTurnShouldEnd, onC
     },
   };
 }
+
+/**
+ * Holds what a `session/load` replays. An agent that can only reload a
+ * session (Cursor: `loadSession`, no `sessionCapabilities.resume`) streams
+ * the whole chat as `session/update`s before it answers — earlier turns'
+ * prompts, thoughts, text, tool calls, todos. None of it belongs to this
+ * turn: mapped, it would re-emit old rows and answers, and an old question
+ * or plan hand-off would end the turn. The runner records instead of
+ * mapping while the load is in flight. The chat's user messages are kept:
+ * they show whether a harness that carries its instructions in the prompt
+ * already sent them (Cursor's `promptPrefix`), and a load that replays
+ * none brought back no conversation to continue.
+ */
+export function createReplayRecorder() {
+  const userMessages = [];
+  let updates = 0;
+  let inUserMessage = false;
+  return {
+    record(update) {
+      updates += 1;
+      if (update?.sessionUpdate !== "user_message_chunk") {
+        inUserMessage = false;
+        return;
+      }
+      // One message's chunks arrive back to back; any other update ends it.
+      const text = update.content?.type === "text" ? String(update.content.text ?? "") : "";
+      if (inUserMessage) userMessages[userMessages.length - 1] += text;
+      else userMessages.push(text);
+      inUserMessage = true;
+    },
+    get updates() {
+      return updates;
+    },
+    get userMessages() {
+      return userMessages;
+    },
+  };
+}

package/runner/lib/contract.mjs

@@ -20,7 +20,7 @@
 // Zero npm dependencies — Node stdlib only.
 
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, statSync, writeSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync, writeSync } from "node:fs";
 import { basename, join } from "node:path";
 
 // ── Argv parsing (no minimist; keep zero deps inside the sandbox) ─────
@@ -46,6 +46,16 @@ export function decodeB64(value) {
   return Buffer.from(String(value), "base64").toString("utf8");
 }
 
+/** A text file the host wrote for this run; "" when absent or unreadable. */
+export function readTextFile(path) {
+  if (path == null || path === true) return "";
+  try {
+    return readFileSync(String(path), "utf8");
+  } catch {
+    return "";
+  }
+}
+
 export function decodeB64Json(value, fallback) {
   if (value == null || value === true) return fallback;
   try {
@@ -486,6 +496,13 @@ export function parseRunnerArgs(rawArgs) {
     maxSteps,
     task: decodeB64(argv["task-b64"]),
     feedback: decodeB64(argv["feedback-b64"]),
+    // --rehydrated-task-file <path>: the host's self-contained prompt for
+    // a FRESH session (original task, plan, continuation summary, recent
+    // turns, latest message and answers in one) — sent instead of
+    // task / feedback / answers whenever the session did not resume. A
+    // file, not argv: it outgrows argv limits (32 KB for a whole Windows
+    // command line, 128 KB per Linux argument). See buildPrompt.
+    rehydratedTask: readTextFile(argv["rehydrated-task-file"]),
     questionAnswers,
     attachments,
     customSystemPrompt: decodeB64(argv["system-prompt-b64"]),

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, mergedBranches}], 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
@@ -33,7 +35,7 @@ const PREWARM_TIMEOUT_MS = 15 * 60_000;
 import { runTurn } from "./executor.mjs";
 import { createManagedProfile, describeProfiles, managedConfigDir, ambientConfigDir, openLoginTerminal, probeUsageLimits } from "./profiles.mjs";
 import { defaultRoots, groupByRepo, preferredCloneRoot, scanRoots, toDeviceRepoReport } from "./repos.mjs";
-import { describeBranchChanges, discardChanges, collectChanges, commitAndPush, copyPrimaryEnvFiles, currentBranch, currentHead, materializeBinding, sessionSlug, worktreePath, ensureCommitExcludes } from "./workspace.mjs";
+import { describeBranchChanges, discardChanges, collectChanges, commitAndPush, copyPrimaryEnvFiles, currentBranch, currentHead, hasPriorWork, materializeBinding, sessionSlug, worktreePath, ensureCommitExcludes } from "./workspace.mjs";
 import { ServiceRunner, detectDevConfig, ensurePreviewBrowser, launchOptionsFor, loadPlaywright, preferredStablePort, previewMcpServer, readDevConfig } from "./preview.mjs";
 import { PreviewError, previewErrorPayload, toPreviewErrorPayload } from "./preview-errors.mjs";
 import { buildCloneCommand, collectCompanions, prefersSsh, resolveCompanionRemote } from "./companions.mjs";
@@ -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,22 +1710,26 @@ 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";
       const ws = await this.withGitAuth(r.key, (gitEnv) => materializeBinding({
         kaiHome: this.kaiHome,
         repo: { name: group.name, primaryPath: group.primary.path, defaultBranch: group.primary.defaultBranch },
-        binding: { mode, base: r.base, carryUncommitted: r.carryUncommitted },
+        binding: { mode, base: r.base, carryUncommitted: r.carryUncommitted, mergedBranches: r.mergedBranches },
         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 });
+      if (ws.restarted) this.log("info", "worktree.restarted", { turnId: turn.turnId, repo: r.key, from: ws.restarted.from, to: ws.branch });
+      if (ws.restartSkipped) this.log("warn", "worktree.restart.skipped", { turnId: turn.turnId, repo: r.key, branch: ws.branch, error: ws.restartSkipped });
       if (ws.fetch && (ws.fetch.stale || ws.fetch.attempts > 1)) this.log("warn", "workspace.fetch.contended", { repo: r.key, ...ws.fetch });
       // Remember the choice per repo (the UI asks once, then sticks).
       this.config.repoModes = { ...(this.config.repoModes || {}), [r.key]: mode };
@@ -1736,11 +1785,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 +1812,47 @@ 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;
+      // A merged worktree that kept its branch (see materializeBinding):
+      // this turn's push lands on the merged branch again, so say why.
+      for (const b of bound.filter((w) => w.restartSkipped)) {
+        batcher.push({
+          type: "text",
+          message: `The pull request for ${b.key} merged, but uncommitted changes in ${b.cwd} conflict with the latest ${b.base}, so this turn continues on ${b.branch} and a new pull request may repeat the merged commits. Discard those changes to start from ${b.base} on the next turn.`,
+        });
+      }
       // 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,12 +1866,25 @@ 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;
+      // A follow-up that cannot resume its harness session is rehydrated
+      // (executor.mjs), and its prompt says whether earlier turns' work is
+      // already in the checkout — only a resumed worktree can hold any. A
+      // restarted one starts from the base branch: its prompt names it
+      // instead (its changes ship in a new pull request).
+      const priorWork = await Promise.all(bound.filter((b) => b.mode === "worktree" && b.resumed && !b.restarted).map((b) => hasPriorWork(b.cwd, b.base)));
+      if (stoppedBeforeRun()) return;
       const res = await runTurn({
-        turn: { ...turn, task: `${turn.task}${repoNote}${previewNote}`, mcpServers },
+        turn: { ...turn, mcpServers },
+        // Kept out of the task itself: a rehydrated prompt retells the
+        // task as "Original task", and these describe the workspace now.
+        workspaceNote: `${repoNote}${previewNote}`,
+        hasPriorBranch: priorWork.some(Boolean),
+        restartedRepos: bound.filter((b) => b.restarted).map((b) => b.key),
         profile,
         workDir,
         kaiHome: this.kaiHome,
         signal: ctrl.signal,
+        onRehydrate: ({ reason }) => this.log("info", "turn.rehydrated", { turnId, sessionId: turn.sessionId, reason }),
         onSpawn: (handle) => {
           entry.control = handle.control;
           if (Number.isInteger(handle.pid)) this.rememberInflight(turnId, { pid: handle.pid });
@@ -1861,12 +1976,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() {