@gleapai/kai-bridge 0.12.0 → 0.12.1

package/npm-shrinkwrap.json

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

package/package.json

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

@@ -5,7 +5,7 @@ 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   { turnId, sessionId, profileId, repos:[{key, mode, base, carryUncommitted}], resend?, ...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 }
@@ -35,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";
@@ -1720,7 +1720,7 @@ export class BridgeDaemon {
       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,
@@ -1728,6 +1728,8 @@ export class BridgeDaemon {
       }));
       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 };
@@ -1843,6 +1845,14 @@ export class BridgeDaemon {
       };
       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.
@@ -1856,13 +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 });

package/src/executor.mjs

@@ -7,36 +7,72 @@
 // `onEvent` as they stream, plus the final `result`.
 
 import { spawn } from "node:child_process";
-import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { createInterface } from "node:readline";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { getHarness, resolveHarnessId } from "../runner/lib/acp/harnesses.mjs";
+import { isPlanModeAgent, normalizeAgentName } from "../runner/lib/contract.mjs";
 import { ambientConfigDir, managedConfigDir } from "./profiles.mjs";
 import { harnessAcpCommand, harnessBinary } from "./harnesses.mjs";
 import { KAI_HOME } from "./config.mjs";
 import { classifyHarnessFailure } from './harness-errors.mjs';
+import { isContinuationTurn, rehydrateTurnTask } from "./rehydration.mjs";
 
 const RUNNER = join(dirname(fileURLToPath(import.meta.url)), "..", "runner", "acp-runner.mjs");
 const b64 = (v) => Buffer.from(typeof v === "string" ? v : JSON.stringify(v), "utf8").toString("base64");
 
-/** turn.start payload → runner argv (no shell — we spawn node directly). */
-export function buildRunnerArgs(turn, workDir, profile) {
-  const args = ["--task-b64", b64(turn.task || ""), "--work-dir", workDir];
-  // The Server's coder payload signals plan mode as `planMode`, not as an
-  // agent name (the analyzer host does this same mapping before spawning
-  // its runner). Without it, a device Plan turn silently ran as build:
-  // full write permissions, no plan artifact, no "Implement this plan?".
-  const agent = turn.agent ?? (turn.planMode ? "kai-planner" : undefined);
+// The Server's coder payload signals plan mode as `planMode`, not as an
+// agent name (the analyzer host does this same mapping before spawning
+// its runner). Without it, a device Plan turn silently ran as build:
+// full write permissions, no plan artifact, no "Implement this plan?".
+const runnerAgent = (turn) => turn.agent ?? (turn.planMode ? "kai-planner" : undefined);
+
+/**
+ * A follow-up's task for a FRESH harness session (src/rehydration.mjs):
+ * the runner prompts with `feedback` (or the answers) INSTEAD of the task,
+ * so a follow-up that could not resume reached a blank agent holding only
+ * the latest message — after a merge the Server drops the resume id, and
+ * the agent got nothing but "can you help me generate an answer to her?"
+ * (#148327). Plan mode is the mode the runner will actually run in.
+ */
+export function rehydratedTaskFor(turn, { hasPriorBranch = false, restartedRepos = [], workspaceNote = "" } = {}) {
+  const isPlanMode = isPlanModeAgent(normalizeAgentName(runnerAgent(turn)));
+  return `${rehydrateTurnTask(turn, { isPlanMode, hasPriorBranch, restartedRepos })}${workspaceNote}`;
+}
+
+/**
+ * turn.start payload → runner argv (no shell — we spawn node directly).
+ *
+ * `workspaceNote` = the daemon's repo brief + live-preview note, appended
+ * to the task. `rehydratedTaskFile` = where runTurn wrote the follow-up's
+ * rehydrated task (rehydratedTaskFor): the runner prompts with it whenever
+ * the session starts fresh — also when a resume fails in the harness. With
+ * it and `resumable` false (runTurn checks the transcript on disk, see
+ * canResumeSession), the turn starts a clean session prompted with that
+ * task alone: no feedback, answers or resume id.
+ */
+export function buildRunnerArgs(turn, workDir, profile, { resumable = !!turn.acpSessionId, workspaceNote = "", rehydratedTaskFile = null } = {}) {
+  const agent = runnerAgent(turn);
+  const rehydrate = !!rehydratedTaskFile && !resumable;
+  const args = ["--task-b64", b64(`${turn.task || ""}${workspaceNote}`), "--work-dir", workDir];
   if (agent) args.push("--agent", agent);
   if (turn.model) args.push("--model", turn.model);
   if (turn.engineModelSlug) args.push("--engine-model", turn.engineModelSlug);
   if (turn.subagentModel) args.push("--subagent-model", turn.subagentModel);
   if (turn.effort) args.push("--effort", turn.effort);
-  // ACP resume id when the server split it out (acpSessionId); the
-  // canonical session id otherwise (turn 1 — the runner treats it as a
-  // hint and mints its own ACP id).
-  if (turn.acpSessionId || turn.sessionId) args.push("--session-id", turn.acpSessionId || turn.sessionId);
+  // The ACP resume id only (`acpSessionId`, set by the Server once a turn
+  // reported one). `turn.sessionId` is always the canonical Kai Code
+  // session (the worktree key), never a harness chat, but the runner reads
+  // `--session-id` as "resume this chat": handed the canonical id, a
+  // session's first turn asked the harness to resume a chat that does not
+  // exist (Cursor has no transcript to check first, and an adapter that
+  // accepted the id ran the turn without the persona prefix). None for a
+  // rehydrated turn either: it starts a clean session and never resumes
+  // the one its prompt retells.
+  if (!rehydrate && turn.acpSessionId) args.push("--session-id", turn.acpSessionId);
   if (turn.harness) args.push("--harness", turn.harness);
   // BYO turns run uncapped: no --max-steps and no --max-budget-usd, even
   // when the Server sends them — the work bills the operator's own harness
@@ -50,8 +86,11 @@ export function buildRunnerArgs(turn, workDir, profile) {
   if (profile?.kind === "gleap-key" && turn.maxBudgetUsd > 0) {
     args.push("--max-budget-usd", String(turn.maxBudgetUsd));
   }
-  if (turn.feedback) args.push("--feedback-b64", b64(turn.feedback));
-  if (turn.questionAnswers?.length) args.push("--answers-b64", b64(turn.questionAnswers));
+  if (turn.feedback && !rehydrate) args.push("--feedback-b64", b64(turn.feedback));
+  if (turn.questionAnswers?.length && !rehydrate) args.push("--answers-b64", b64(turn.questionAnswers));
+  // A file, not argv: history + plan + summary outgrow argv limits (32 KB
+  // for a whole Windows command line, 128 KB per Linux argument).
+  if (rehydratedTaskFile) args.push("--rehydrated-task-file", rehydratedTaskFile);
   if (turn.attachments?.length) args.push("--attachments-b64", b64(turn.attachments));
   if (turn.mcpServers?.length) args.push("--mcp-config-b64", b64(turn.mcpServers));
   if (turn.customInstructions?.trim()) args.push("--system-prompt-b64", b64(turn.customInstructions));
@@ -135,16 +174,61 @@ export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME, extraEnv = nul
   return env;
 }
 
+/**
+ * Can the harness resume the turn's ACP session? The runner's own check
+ * (HARNESS.hasResumableSession: the prior transcript is on disk), run
+ * against the config dir the runner will use (`env` from buildRunnerEnv).
+ * A session this machine does not have — the transcript was cleaned up,
+ * the session ran under another login or on another machine — would
+ * otherwise start fresh on the feedback alone. A harness without an
+ * on-disk check (Cursor) is trusted: the runner tries to continue the
+ * session (Cursor: `session/load`, it offers no `session/resume`).
+ */
+export function canResumeSession(turn, workDir, env) {
+  if (!turn.acpSessionId) return false;
+  const harnessId = resolveHarnessId(turn.harness, turn.model);
+  const harness = getHarness(harnessId);
+  if (!harness.hasResumableSession) return true;
+  // Resolved like the runner's main(): the profile's dir, else a
+  // per-harness dir under the state root.
+  const configDir = env.KAI_ACP_CONFIG_DIR || join(env.KAI_ACP_STATE_DIR || join(tmpdir(), "kai-acp-state"), harnessId);
+  try {
+    return !!harness.hasResumableSession({ configDir, workDir, resumeSessionId: turn.acpSessionId });
+  } catch {
+    return false;
+  }
+}
+
+/** A follow-up's rehydrated task in a private temp dir, removed when the turn ends. */
+function writeRehydratedTask(turn, opts) {
+  const dir = mkdtempSync(join(tmpdir(), "kai-turn-"));
+  const file = join(dir, "rehydrated-task.md");
+  writeFileSync(file, rehydratedTaskFor(turn, opts), { mode: 0o600 });
+  return { dir, file };
+}
+
 /**
  * Execute a turn. Resolves `{ code, result, rateLimited }`; events stream
  * through `onEvent(event)`. `signal` cancels (SIGTERM to the runner).
  * `onSpawn(handle)` hands out `handle.control(obj)` for the runner's stdin
- * control channel (mid-turn steering).
+ * control channel (mid-turn steering). `workspaceNote`: see
+ * buildRunnerArgs; `hasPriorBranch` / `restartedRepos`: see
+ * buildRehydrationTask (src/rehydration.mjs).
+ * `onRehydrate({ reason })` fires when a follow-up runs on its rehydrated
+ * task instead of a resumed session: `no_resume_id` / `session_not_found`
+ * before the spawn, `resume_failed` when the harness could not resume or
+ * load it, or loaded a chat with no conversation left in it.
  */
-export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onSpawn, signal, kaiHome = KAI_HOME, extraEnv = null }) {
+export function runTurn({ turn, profile, workDir, workspaceNote = "", hasPriorBranch = false, restartedRepos = [], onEvent, onLog = () => {}, onRehydrate, onSpawn, signal, kaiHome = KAI_HOME, extraEnv = null }) {
   return new Promise((resolve) => {
-    const args = buildRunnerArgs(turn, workDir, profile);
     const env = buildRunnerEnv(turn, profile, kaiHome, extraEnv);
+    const resumable = canResumeSession(turn, workDir, env);
+    // Every follow-up hands the runner its rehydrated task: the prompt when
+    // the session cannot be resumed, the fallback when a resume fails in
+    // the harness (a transcript it cannot load, a Cursor chat that is gone).
+    const rehydration = isContinuationTurn(turn) ? writeRehydratedTask(turn, { hasPriorBranch, restartedRepos, workspaceNote }) : null;
+    if (rehydration && !resumable) onRehydrate?.({ reason: turn.acpSessionId ? "session_not_found" : "no_resume_id" });
+    const args = buildRunnerArgs(turn, workDir, profile, { resumable, workspaceNote, rehydratedTaskFile: rehydration?.file });
     // stdin is the runner's control channel (JSONL: steer / cancel) — see
     // startControlChannel in runner/acp-runner.mjs. Never closed from
     // here; the runner exits on its own when the turn ends.
@@ -186,7 +270,13 @@ export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onS
       }
       onEvent(ev);
     });
-    child.stderr.on("data", (d) => onLog(String(d)));
+    child.stderr.on("data", (d) => {
+      const text = String(d);
+      // The runner's trace when the harness could not resume after all and
+      // the rehydrated task became the prompt (buildPrompt in acp-runner.mjs).
+      if (rehydration && text.includes(" resume.rehydrated")) onRehydrate?.({ reason: "resume_failed" });
+      onLog(text);
+    });
     const onAbort = () => {
       try {
         child.kill("SIGTERM");
@@ -195,9 +285,22 @@ export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onS
       }
     };
     signal?.addEventListener("abort", onAbort, { once: true });
-    child.on("close", (code) => {
+    let settled = false;
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
       signal?.removeEventListener("abort", onAbort);
+      if (rehydration) rmSync(rehydration.dir, { recursive: true, force: true });
       resolve({ code, result, rateLimited, lastError, errorCode: classifyHarnessFailure(lastError || '') });
+    };
+    // A runner that never started (e.g. a command line the OS refuses)
+    // fails the turn — unhandled, 'error' would take the daemon down. A
+    // failed kill also lands here; its 'close' still follows.
+    child.on("error", (err) => {
+      if (child.pid !== undefined) return;
+      lastError ||= `The runner could not start: ${err.message}`;
+      finish(null);
     });
+    child.on("close", (code) => finish(code));
   });
 }

package/src/rehydration.mjs

@@ -0,0 +1,129 @@
+// Rehydrating a follow-up turn that cannot resume its harness session.
+//
+// Ported from the analyzer (gleap_code_analyzer src/coder/rehydration.ts,
+// GleapSDK/gleap_code_analyzer#73). The runner sends `feedback` INSTEAD of
+// the task whenever it has one (runner/acp-runner.mjs `buildPrompt`), so a
+// follow-up that starts a fresh harness session reached a blank agent
+// holding only the latest message: no original task, no continuation
+// summary, no recent turns. That is every follow-up after the session's
+// PRs merged (the Server clears `analyzerSessionId` in the merge handler)
+// and every one whose transcript this machine no longer has. Such a turn
+// gets one self-contained task instead, built from what the Server already
+// sends with every resume (task, plan, sessionSummary, recentTurns,
+// feedback), and no separate feedback. Keep the sections and tails in sync
+// with the analyzer.
+
+/**
+ * Whether this turn continues an earlier one. On the bridge `sessionId` is
+ * always the canonical Kai Code session id (bridgeService.dispatchTurn
+ * pins it), so it proves nothing; the harness resume id travels as
+ * `acpSessionId`. Everything else matches the analyzer's signal list.
+ */
+export const isContinuationTurn = (turn = {}) =>
+  !!(turn.acpSessionId || turn.feedback || turn.sessionSummary || turn.recentTurns || turn.plan || turn.questionAnswers?.length);
+
+/**
+ * Structured question answers, worded the way the runner puts them in
+ * front of a resumed agent (renderAnswersBlock in runner/acp-runner.mjs).
+ * The runner would send them INSTEAD of the task too, so a rehydrated turn
+ * carries them inside the latest user message.
+ */
+export const renderQuestionAnswers = (answers) => {
+  if (!Array.isArray(answers) || answers.length === 0) return "";
+  const lines = answers.map((a, i) => `${i + 1}. ${Array.isArray(a) ? a.join(", ") : String(a)}`);
+  return `Answers to your questions:\n${lines.join("\n")}`;
+};
+
+/**
+ * Synthesize the first-turn prompt the rehydrated agent receives.
+ * Sections are stitched in order:
+ *   # Original task
+ *   # Approved/Prior plan          (when `plan` is set)
+ *   # Continuation summary         (when `sessionSummary` is set)
+ *   # Recent conversation          (when `recentTurns` is set)
+ *   # Latest user message          (when `feedback` is set)
+ *   <mode-specific tail>
+ *
+ * `hasPriorBranch`: the checkout already carries an earlier turn's work
+ * (on the bridge: a resumed session worktree with commits beyond its base
+ * or uncommitted changes — see hasPriorWork in workspace.mjs).
+ * `restartedRepos`: repositories whose pull request merged, restarted from
+ * the latest base on a new branch (materializeBinding in workspace.mjs).
+ * They are not prior work: their changes ship in a new pull request.
+ */
+export const buildRehydrationTask = (input) => {
+  const sections = [];
+
+  if (input.task) sections.push(`# Original task\n${input.task}`);
+
+  if (input.plan) {
+    const planHeading = input.isPlanMode ? "Prior plan" : "Approved plan";
+    sections.push(`# ${planHeading}\n${input.plan}`);
+  }
+
+  if (input.sessionSummary) {
+    sections.push(`# Continuation summary\n${input.sessionSummary}`);
+  }
+
+  if (input.recentTurns) {
+    sections.push(`# Recent conversation\n${input.recentTurns}`);
+  }
+
+  if (input.feedback) {
+    sections.push(`# Latest user message\n${input.feedback}`);
+  }
+
+  sections.push(buildRehydrationTail(input));
+  return sections.join("\n\n");
+};
+
+/**
+ * The repositories a multi-repo follow-up restarted because their pull
+ * request merged, said after the prior-work tail: that tail alone sends
+ * every repository's changes to "the same PR". Empty without any.
+ */
+export const restartedReposNote = (repos) => {
+  if (!Array.isArray(repos) || repos.length === 0) return "";
+  return repos.length === 1
+    ? ` The pull request for ${repos[0]} merged, so that repository starts from the latest base branch on a new branch; changes there ship in a new pull request.`
+    : ` The pull requests for ${repos.join(", ")} merged, so those repositories start from the latest base branch on new branches; changes there ship in new pull requests.`;
+};
+
+/**
+ * The instruction tail. Picked separately so tests can pin the wording
+ * for each branch independently.
+ */
+export const buildRehydrationTail = (input) => {
+  if (input.isPlanMode && !input.plan) {
+    return "Write the plan for the request above. Respond with the full plan as your final assistant message — that becomes the plan we surface to the user.";
+  }
+  if (input.isPlanMode) {
+    return "Refine the plan above based on the latest user message. Respond with the updated full plan as your final assistant message — that becomes the plan we surface to the user.";
+  }
+  if (input.hasPriorBranch) {
+    return `The repository is checked out on the prior work branch from an earlier turn — prior commits are already there. Run \`git log --oneline -20\` and \`git diff\` against the base branch first to see what's been done, then pick up from where it left off and apply the latest user message if present. The build pipeline will commit and push your new changes to the same PR.${restartedReposNote(input.restartedRepos)}`;
+  }
+  if (input.plan) {
+    return "The user has reviewed and approved the plan above; you are now in build mode. Implement the plan — this is a fresh branch with no prior commits, so make all the changes the plan specifies. Do not re-plan or ask for clarification: implement what was approved. The build pipeline will commit your changes and open a PR afterward.";
+  }
+  return "Continue the task on a fresh branch and apply the latest user message. If it needs code changes, make them; the build pipeline will commit your changes and open a PR afterward. If it only asks for an answer (a question, a reply draft), answer it without changing files.";
+};
+
+/**
+ * The rehydrated task for a bridge turn. `feedback` + `questionAnswers`
+ * are what the user sent this turn, so both land under "Latest user
+ * message" — the same text a resumed session would have been prompted with.
+ * `isPlanMode` = the mode the runner will actually run in (executor.mjs
+ * resolves it from the agent it passes).
+ */
+export const rehydrateTurnTask = (turn, { isPlanMode = !!turn.planMode, hasPriorBranch = false, restartedRepos = [] } = {}) =>
+  buildRehydrationTask({
+    task: turn.task || "",
+    plan: turn.plan,
+    sessionSummary: turn.sessionSummary,
+    recentTurns: turn.recentTurns,
+    feedback: [turn.feedback, renderQuestionAnswers(turn.questionAnswers)].filter(Boolean).join("\n\n"),
+    isPlanMode,
+    hasPriorBranch,
+    restartedRepos,
+  });

package/src/repos.mjs

@@ -23,10 +23,52 @@ export function defaultRoots(home = homedir()) {
   return DEFAULT_ROOT_NAMES.map((n) => join(home, n)).filter((p) => existsSync(p));
 }
 
+const reencodeSegment = (segment) => {
+  try {
+    return encodeURIComponent(decodeURIComponent(segment));
+  } catch {
+    return segment;
+  }
+};
+
+/**
+ * Azure DevOps spells one repository several ways, and the Server keys a
+ * connected repo by its `https://dev.azure.com/{org}/{project}/_git/{repo}`
+ * clone URL (segments URI-encoded). Every spelling maps to that
+ * `{org}/{project}/{repo}` path on dev.azure.com:
+ *   git@ssh.dev.azure.com:v3/{org}/{project}/{repo}           SSH
+ *   {org}@vs-ssh.visualstudio.com:v3/{org}/{project}/{repo}   legacy SSH
+ *   https://{org}.visualstudio.com/[DefaultCollection/]{project}/_git/{repo}
+ *   https://dev.azure.com/{org}/_git/{repo}                    repo named like its project
+ * Null for other hosts and shapes (they keep the generic rules).
+ */
+function azureDevOpsPath(host, path) {
+  const segs = path.split("/").filter(Boolean);
+  const canonical = (org, project, repo) => [org, project, repo].map(reencodeSegment).join("/");
+  if (host === "ssh.dev.azure.com" || host === "vs-ssh.visualstudio.com") {
+    return segs.length === 4 && segs[0].toLowerCase() === "v3" ? canonical(segs[1], segs[2], segs[3]) : null;
+  }
+  let org;
+  let rest; // after the org: [project, "_git", repo] or ["_git", repo]
+  const legacy = /^([^.]+)\.visualstudio\.com$/.exec(host);
+  if (host === "dev.azure.com") {
+    [org, ...rest] = segs;
+  } else if (legacy) {
+    org = legacy[1];
+    rest = segs[0]?.toLowerCase() === "defaultcollection" ? segs.slice(1) : segs;
+  } else {
+    return null;
+  }
+  if (org && rest.length === 3 && rest[1].toLowerCase() === "_git") return canonical(org, rest[0], rest[2]);
+  if (org && rest.length === 2 && rest[0].toLowerCase() === "_git") return canonical(org, rest[1], rest[1]);
+  return null;
+}
+
 /**
  * `git@github.com:Gleap/Server.git`, `https://github.com/Gleap/Server`,
  * `ssh://git@bitbucket.org/team/repo.git`, `https://user@dev.azure.com/org/proj/_git/repo`
  * → `{ host, owner, name, key: "host/owner/name" }` (lower-cased, `.git` stripped).
+ * Mirrored by `repoKeyFromUrl` in the Server (src/services/coderepo/repoKey.ts).
  */
 export function normalizeRemote(remote) {
   const raw = String(remote || "").trim();
@@ -56,6 +98,11 @@ export function normalizeRemote(remote) {
     }
   }
   path = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "").replace(/\/+$/, "");
+  const azurePath = azureDevOpsPath(host.toLowerCase(), path);
+  if (azurePath) {
+    host = "dev.azure.com";
+    path = azurePath;
+  }
   // Azure DevOps: org/project/_git/repo → keep org/project as "owner".
   path = path.replace(/\/_git\//, "/");
   const segments = path.split("/").filter(Boolean);
@@ -66,6 +113,22 @@ export function normalizeRemote(remote) {
   return { host: hostLc, owner: owner.toLowerCase(), name: name.toLowerCase(), key: `${hostLc}/${owner.toLowerCase()}/${name.toLowerCase()}` };
 }
 
+/**
+ * A remote as it may leave this machine: userinfo, query and fragment
+ * dropped (`https://x-access-token:<token>@github.com/o/r.git` →
+ * `https://github.com/o/r.git`). `git remote get-url` returns any token in
+ * the URL, and expands `url.<base>.insteadOf` rewrites that add one.
+ * scp-style remotes (`git@github.com:o/r.git`) and local paths are
+ * returned as given. Mirrored by `stripRemoteCredentials` in the Server
+ * (src/api/gleapcode/services/bridge.changes.ts).
+ */
+export function stripRemoteCredentials(remote) {
+  const url = /^([a-z][a-z\d+.-]*:\/\/)([^/?#]*)([^?#]*)/i.exec(remote.trim());
+  if (!url) return remote;
+  const [, scheme, authority, path] = url;
+  return `${scheme}${authority.slice(authority.lastIndexOf("@") + 1)}${path}`;
+}
+
 function git(cwd, args) {
   try {
     return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim();

package/src/workspace.mjs

@@ -18,6 +18,7 @@ import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 
 import { seedNodeModules } from "./deps.mjs";
+import { stripRemoteCredentials } from "./repos.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -165,6 +166,33 @@ export function worktreePath(kaiHome, repoName, slug) {
   return join(kaiHome, "worktrees", repoName, slug);
 }
 
+/**
+ * The branch a restarted session worktree moves to (see materializeBinding).
+ * It never reuses the merged branch's name: after a squash merge that
+ * branch is still on the remote and rejects the new history as a
+ * non-fast-forward push (or it was deleted), and a second pull request on
+ * a merged PR's branch name is ambiguous. The cloud names its follow-up
+ * branches the same way (`kai-code/<taskId>-<stamp>`).
+ */
+export const restartedBranchName = (sessionBranch, stamp = Date.now().toString(36)) => `${sessionBranch}-${stamp}`;
+
+/**
+ * The branch a resumed session worktree is on: `sessionBranch` or a
+ * restart of it (`<sessionBranch>-<stamp>`). Anything else (a detached
+ * HEAD, a branch the agent switched to, the base branch itself) reads as
+ * `sessionBranch`: the turn pushes `HEAD:<branch>`, and pushing to
+ * whatever happens to be checked out could publish onto the base branch.
+ */
+async function sessionBranchOf(cwd, sessionBranch) {
+  try {
+    const head = await gitAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    if (head === sessionBranch || head.startsWith(`${sessionBranch}-`)) return head;
+  } catch {
+    /* unreadable: the name the worktree was created with */
+  }
+  return sessionBranch;
+}
+
 /**
  * Copy the primary checkout's local env files (.env, .env.local, …) into a
  * worktree when the worktree doesn't have its own. They're gitignored, so a
@@ -198,12 +226,24 @@ export function copyPrimaryEnvFiles(primaryPath, cwd) {
 
 /**
  * Materialise one repo binding. Resolves `{ cwd, mode, branch, base }`.
- * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted? }`.
+ * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted?, mergedBranches? }`.
  * `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.
+ * built, or a merged one restarted — the slow path (fetch, checkout,
+ * node_modules) — before any of it starts; other resumed worktrees and
+ * local checkouts never call it.
+ *
+ * `mergedBranches` (from the Server): this repo's session branches whose
+ * pull request merged with no open one left on them. A resumed worktree
+ * still on one of them restarts in place from a freshly fetched
+ * `origin/<base>` on a new branch (restartedBranchName) and resolves
+ * `restarted: { from }`. Kept going, a follow-up pushed the merged commits
+ * again, and the Server opened a new pull request carrying them (the
+ * merged one no longer counts as open). Uncommitted changes come along
+ * when they fit the new base; when git refuses the switch (they conflict)
+ * the worktree stays as it is and resolves `restartSkipped` with git's
+ * reason: never lose work.
  */
-export async function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null, onPrepare = null }) {
+export async function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null, onPrepare = null, stamp = undefined }) {
   const mode = binding?.mode === "local" ? "local" : "worktree";
   if (mode === "local") {
     const branch = await gitAsync(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -215,7 +255,18 @@ export async function materializeBinding({ kaiHome, repo, binding, sessionId, ti
   const branch = `${branchPrefix}/${slug}`;
   if (existsSync(dir)) {
     // Resume: the worktree from the previous turn is the session state.
-    return { cwd: dir, mode, branch, base, resumed: true };
+    const current = await sessionBranchOf(dir, branch);
+    if (!binding?.mergedBranches?.includes(current)) return { cwd: dir, mode, branch: current, base, resumed: true };
+    await onPrepare?.({ repo: repo.name, base });
+    const fetched = await fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
+    const next = restartedBranchName(branch, stamp);
+    try {
+      await gitAsync(dir, ["checkout", "-q", "-b", next, `origin/${base}`]);
+    } catch (err) {
+      const reason = String(err?.stderr || err?.message || err).trim().slice(0, 500);
+      return { cwd: dir, mode, branch: current, base, resumed: true, fetch: fetched, restartSkipped: reason };
+    }
+    return { cwd: dir, mode, branch: next, base, resumed: true, restarted: { from: current }, fetch: fetched };
   }
   await onPrepare?.({ repo: repo.name, base });
   mkdirSync(dirname(dir), { recursive: true });
@@ -303,6 +354,26 @@ export function discardChanges(cwd) {
   return { discarded: before };
 }
 
+/**
+ * Does a resumed session worktree already carry an earlier turn's work?
+ * Commits on the session branch beyond `base` (tried as `origin/<base>`
+ * first), or changes a turn left uncommitted (a stopped or failed build).
+ * A plan turn leaves neither. A rehydrated follow-up is told to review
+ * that work before it continues (rehydration.mjs). Never throws.
+ */
+export async function hasPriorWork(cwd, base) {
+  try {
+    if (await gitAsync(cwd, ["status", "--porcelain"])) return true;
+    for (const ref of [base && `origin/${base}`, base].filter(Boolean)) {
+      const commit = await gitAsync(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]).catch(() => "");
+      if (commit) return Number(await gitAsync(cwd, ["rev-list", "--count", `${commit}..HEAD`])) > 0;
+    }
+  } catch {
+    /* not a checkout — nothing to review */
+  }
+  return false;
+}
+
 /** Drop a session's worktrees (after merge/close). */
 export function removeWorktree({ kaiHome, repo, sessionId, title }) {
   const dir = worktreePath(kaiHome, repo.name, sessionSlug(sessionId, title));
@@ -415,7 +486,8 @@ export function commitAndPush(cwd, { branch, message, allowEmpty = false, allowD
       out.committed = true;
     }
     out.commitSha = git(cwd, ["rev-parse", "HEAD"]);
-    out.remote = git(cwd, ["remote", "get-url", "origin"]);
+    // Reported to the Server with the turn result: never with a token in it.
+    out.remote = stripRemoteCredentials(git(cwd, ["remote", "get-url", "origin"]));
     git(cwd, ["push", "-u", "origin", `HEAD:${branch}`], withGitEnv(gitEnv, { timeout: 120_000 }));
     out.pushed = true;
   } catch (err) {