From 21684912c20feaf1d86a84e5ab8199dc205f32cc Mon Sep 17 00:00:00 2001
From: Yash <yash@sapiom.ai>
Date: Sat, 5 Sep 2026 12:12:00 +0000
Subject: [PATCH] feat(harness): activate ordinary bootstrap [Agent Map 07/15]

---
 .changeset/project-bootstrap-activation.md    |   14 +
 .../scripts/smoke-agent-stub.cjs              |   60 +
 packages/harness-desktop/scripts/smoke.sh     |   37 +-
 .../src/main/smoke-agent-stub.test.ts         |   60 +
 packages/harness-desktop/src/main/smoke.ts    |  294 +++-
 packages/harness/README.md                    |   31 +-
 packages/harness/src/core/paths.test.ts       |    6 -
 packages/harness/src/core/paths.ts            |    4 +-
 .../harness/src/core/planner-greeting.test.ts |  962 -----------
 packages/harness/src/core/planner-greeting.ts | 1489 -----------------
 .../harness/src/core/planning-session.test.ts |  817 ---------
 packages/harness/src/core/planning-session.ts |  551 ------
 .../harness/src/core/session-manager.test.ts  | 1374 ++++++++++++---
 packages/harness/src/core/session-manager.ts  |  532 ++++--
 .../harness/src/profiles/agent-map-planner.ts |   29 -
 .../src/server/agent-map-auth-wiring.test.ts  |   28 +-
 .../src/server/agent-map-mcp-wiring.test.ts   |  876 +++++++++-
 packages/harness/src/server/agent-map.test.ts |  340 ++--
 packages/harness/src/server/agent-map.ts      |  214 +--
 packages/harness/src/server/auth-routes.ts    |    9 +-
 packages/harness/src/server/index.ts          | 1038 +++++++++---
 packages/harness/src/server/ingest.test.ts    |   29 +-
 .../server/project-bootstrap-outbox.test.ts   |  547 ++++++
 .../src/server/rehydrate-session.test.ts      |  126 +-
 packages/harness/src/server/rest.test.ts      |  591 +++++--
 packages/harness/src/server/rest.ts           |  211 ++-
 packages/harness/src/shared/agent-map.ts      |  103 --
 packages/harness/src/shared/types.ts          |   47 +-
 28 files changed, 4929 insertions(+), 5490 deletions(-)
 create mode 100644 .changeset/project-bootstrap-activation.md
 create mode 100644 packages/harness-desktop/scripts/smoke-agent-stub.cjs
 create mode 100644 packages/harness-desktop/src/main/smoke-agent-stub.test.ts
 delete mode 100644 packages/harness/src/core/planner-greeting.test.ts
 delete mode 100644 packages/harness/src/core/planner-greeting.ts
 delete mode 100644 packages/harness/src/core/planning-session.test.ts
 delete mode 100644 packages/harness/src/core/planning-session.ts
 delete mode 100644 packages/harness/src/profiles/agent-map-planner.ts
 create mode 100644 packages/harness/src/server/project-bootstrap-outbox.test.ts

diff --git a/.changeset/project-bootstrap-activation.md b/.changeset/project-bootstrap-activation.md
new file mode 100644
index 000000000..3cfad9f50
--- /dev/null
+++ b/.changeset/project-bootstrap-activation.md
@@ -0,0 +1,14 @@
+---
+"@sapiom/harness": minor
+---
+
+Activate one recoverable first-session map bootstrap for newly opened Studio projects. Durable project intent, input receipts, readiness, preemption, and restart recovery share the ordinary session lifecycle.
+
+Breaking changes for embedders and HTTP clients:
+
+- Remove `HarnessSession.planning`, `SessionManager.setPlanningMetadata()`, and the trusted create/resume `planning` options. Read the neutral `agentMapIdentity` for project identity and optional `projectBootstrap` for lifecycle state. The server migrates valid persisted legacy metadata and input queues automatically.
+- Remove the planner contracts `PlannerGreetingErrorCode`, `PlannerGreetingState`, `PlannerSessionMetadata`, `PlannerQueuedInput`, `PlannerSessionRequest`, `PlannerSessionResponse`, `PlannerMessageRequest`, `PlannerSessionMetadataResponse`, and `PlannerLifecycleEvent`. Use ordinary session request/response types and `ProjectBootstrapMetadata`, `ProjectBootstrapState`, and `ProjectBootstrapInputReceipt` for bootstrap state and input acknowledgements.
+- Remove `POST /api/projects/:projectId/planner-sessions`, `POST /api/projects/:projectId/planner-sessions/:sessionId/messages`, and `POST /api/projects/:projectId/planner-sessions/:sessionId/greeting/retry`. Create, resume, and send input through `POST /api/sessions`, `POST /api/sessions/:id/resume`, and `POST /api/sessions/:id/input`. Bootstrap recovery is server-owned. Clients supplying the first prompt should set `initialUserInputPending: true` when creating a session.
+- Replace the `planner_session.*` and `planner_greeting.*` analytics event names with `project_agent.identity_*` and `project_bootstrap.*`. Their remote projections remain content-free.
+
+Project creation and root binding can return `202` with a committed project identity when automatic initialization must retry; treat that identity as successfully created. Settings updates return their committed values while new-root initialization continues in the background. Server shutdown keeps admission fenced and bounds its wait for bootstrap, persistence, archive, and telemetry drains before releasing the listener.
diff --git a/packages/harness-desktop/scripts/smoke-agent-stub.cjs b/packages/harness-desktop/scripts/smoke-agent-stub.cjs
new file mode 100644
index 000000000..9c4facb66
--- /dev/null
+++ b/packages/harness-desktop/scripts/smoke-agent-stub.cjs
@@ -0,0 +1,60 @@
+const fs = require("node:fs");
+
+function environmentCapturePath(base, sessionId) {
+  return `${base}.${encodeURIComponent(sessionId)}.json`;
+}
+
+function captureAgentEnvironment(env = process.env) {
+  const base = env.SAPIOM_SMOKE_AGENT_ENV;
+  const sessionId = env.SAPIOM_HARNESS_SESSION_ID;
+  if (!base || !sessionId) return null;
+
+  const file = environmentCapturePath(base, sessionId);
+  const snapshot = {
+    schemaVersion: 1,
+    sessionId,
+    variableCount: Object.keys(env).length,
+    hasEsbuildBinaryPath: Object.prototype.hasOwnProperty.call(
+      env,
+      "ESBUILD_BINARY_PATH",
+    ),
+    hasPath: typeof env.PATH === "string" && env.PATH.length > 0,
+  };
+  fs.writeFileSync(file, `${JSON.stringify(snapshot)}\n`, {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+  return file;
+}
+
+function runSessionStartHook() {
+  try {
+    const settingsIndex = process.argv.indexOf("--settings");
+    const settingsPath =
+      settingsIndex > -1 ? process.argv[settingsIndex + 1] : null;
+    if (!settingsPath) return;
+    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    const command = settings.hooks.SessionStart[0].hooks[0].command;
+    const { execFileSync, execSync } = require("node:child_process");
+    if (process.platform === "win32") {
+      const bash = "C:\\Program Files\\Git\\bin\\bash.exe";
+      if (fs.existsSync(bash)) {
+        execFileSync(bash, ["-c", command], { stdio: "ignore" });
+      } else {
+        execSync(command, { stdio: "ignore" });
+      }
+    } else {
+      execFileSync("/bin/sh", ["-c", command], { stdio: "ignore" });
+    }
+  } catch {
+    // A failed hook is exactly what checkSessionCreate's ready poll reports.
+  }
+}
+
+module.exports = { captureAgentEnvironment, environmentCapturePath };
+
+if (require.main === module) {
+  captureAgentEnvironment();
+  runSessionStartHook();
+  setTimeout(() => process.exit(0), 3000);
+}
diff --git a/packages/harness-desktop/scripts/smoke.sh b/packages/harness-desktop/scripts/smoke.sh
index 8ce6e15f6..2a5a6c790 100755
--- a/packages/harness-desktop/scripts/smoke.sh
+++ b/packages/harness-desktop/scripts/smoke.sh
@@ -75,52 +75,31 @@ export SAPIOM_SMOKE_OUT="$(native "$report_file")"
 # check can assert the WHOLE readiness chain (settings → hook command → node
 # resolution under the hook shell → POST → ready), the exact seam that broke
 # silently on Windows and dropped every held first prompt.
-cat > "$smoke_home/stub-agent.js" <<'STUBJS'
-const fs = require("fs");
-const envFile = process.env.SAPIOM_SMOKE_AGENT_ENV;
-if (envFile) fs.writeFileSync(envFile, Object.entries(process.env).map(([k, v]) => k + "=" + v).join("\n") + "\n");
-try {
-  const i = process.argv.indexOf("--settings");
-  const settingsPath = i > -1 ? process.argv[i + 1] : null;
-  if (settingsPath) {
-    const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
-    const command = settings.hooks.SessionStart[0].hooks[0].command;
-    const { execFileSync, execSync } = require("child_process");
-    if (process.platform === "win32") {
-      const bash = "C:\\Program Files\\Git\\bin\\bash.exe";
-      if (fs.existsSync(bash)) execFileSync(bash, ["-c", command], { stdio: "ignore" });
-      else execSync(command, { stdio: "ignore" });
-    } else {
-      execFileSync("/bin/sh", ["-c", command], { stdio: "ignore" });
-    }
-  }
-} catch {
-  // A failed hook is exactly what the ready-poll in checkSessionCreate reports.
-}
-setTimeout(() => process.exit(0), 3000);
-STUBJS
+cp "$here/smoke-agent-stub.cjs" "$smoke_home/stub-agent.cjs"
 if [ "$(uname -s)" != "Linux" ] && [ "$(uname -s)" != "Darwin" ]; then
   # Shaped like an npm shim on purpose — a `.cmd` that runs `node <script>` — because
   # that is exactly what `claude.cmd` is, and it's the shape resolveSpawnTarget has
   # to see through. A stub that were a plain .cmd (or an .exe) would exercise a path
   # real agents never take, and is now correctly refused rather than shelled out.
   stub="$smoke_home/stub-agent.cmd"
-  printf '@echo off\r\n"%%dp0%%\\node.exe" "%%dp0%%\\stub-agent.js" %%*\r\n' > "$stub"
+  printf '@echo off\r\n"%%dp0%%\\node.exe" "%%dp0%%\\stub-agent.cjs" %%*\r\n' > "$stub"
 else
   # `node` rather than a hardcoded path: the app's PATH augmentation (runtime
   # shims) must make it resolvable — that resolution is part of what's under test.
   stub="$smoke_home/stub-agent.sh"
-  printf '#!/bin/sh\nexec node "%s" "$@"\n' "$smoke_home/stub-agent.js" > "$stub"
+  printf '#!/bin/sh\nexec node "%s" "$@"\n' "$smoke_home/stub-agent.cjs" > "$stub"
   chmod +x "$stub"
 fi
-# Where the stub agent writes its environment, so a check can assert on what the
-# AGENT actually inherited rather than on what the main process meant to pass.
+# Base path where each stub agent writes a session-keyed environment snapshot,
+# so concurrent project sessions cannot overwrite one another's evidence and a
+# check can assert on what the exact AGENT inherited rather than on what the
+# main process meant to pass.
 # This caught a real regression: the desktop host pins ESBUILD_BINARY_PATH so its
 # own bundler can exec a binary outside app.asar, and the whole parent env is
 # copied into the pty — so every agent, and every tool it ran in the user's repo,
 # inherited a pin to OUR esbuild build ("Host version X does not match binary
 # version Y" on a project that builds fine outside the app).
-export SAPIOM_SMOKE_AGENT_ENV="$(native "$smoke_home/agent-env.txt")"
+export SAPIOM_SMOKE_AGENT_ENV="$(native "$smoke_home/agent-env")"
 # Native, because resolveSpawnTarget resolves this inside the app: a POSIX
 # path has no drive letter, so the Windows lookup would never find it.
 export SAPIOM_SMOKE_STUB_AGENT="$(native "$stub")"
diff --git a/packages/harness-desktop/src/main/smoke-agent-stub.test.ts b/packages/harness-desktop/src/main/smoke-agent-stub.test.ts
new file mode 100644
index 000000000..f5ba44803
--- /dev/null
+++ b/packages/harness-desktop/src/main/smoke-agent-stub.test.ts
@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+const require = createRequire(import.meta.url);
+const { captureAgentEnvironment, environmentCapturePath } =
+  require("../../scripts/smoke-agent-stub.cjs") as {
+    captureAgentEnvironment: (env: Record<string, string>) => string | null;
+    environmentCapturePath: (base: string, sessionId: string) => string;
+  };
+
+describe("packaged smoke agent environment evidence", () => {
+  const roots: string[] = [];
+
+  afterEach(() => {
+    for (const root of roots.splice(0)) {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it("retains exact per-session snapshots regardless of competing write order", () => {
+    const root = mkdtempSync(path.join(tmpdir(), "smoke-agent-env-"));
+    roots.push(root);
+    const base = path.join(root, "agent-env");
+    const firstId = "11111111-1111-4111-8111-111111111111";
+    const secondId = "22222222-2222-4222-8222-222222222222";
+
+    const secondFile = captureAgentEnvironment({
+      SAPIOM_SMOKE_AGENT_ENV: base,
+      SAPIOM_HARNESS_SESSION_ID: secondId,
+      PATH: "/bin",
+      PRIVATE_VALUE: "must-not-be-copied",
+    });
+    const firstFile = captureAgentEnvironment({
+      SAPIOM_SMOKE_AGENT_ENV: base,
+      SAPIOM_HARNESS_SESSION_ID: firstId,
+      PATH: "/bin",
+    });
+
+    expect(firstFile).toBe(environmentCapturePath(base, firstId));
+    expect(secondFile).toBe(environmentCapturePath(base, secondId));
+    expect(firstFile).not.toBe(secondFile);
+    expect(JSON.parse(readFileSync(firstFile!, "utf8"))).toMatchObject({
+      schemaVersion: 1,
+      sessionId: firstId,
+      hasEsbuildBinaryPath: false,
+      hasPath: true,
+    });
+    const secondRaw = readFileSync(secondFile!, "utf8");
+    expect(JSON.parse(secondRaw)).toMatchObject({
+      schemaVersion: 1,
+      sessionId: secondId,
+      hasEsbuildBinaryPath: false,
+      hasPath: true,
+    });
+    expect(secondRaw).not.toContain("must-not-be-copied");
+  });
+});
diff --git a/packages/harness-desktop/src/main/smoke.ts b/packages/harness-desktop/src/main/smoke.ts
index 8dd4583a2..ca74d1bae 100644
--- a/packages/harness-desktop/src/main/smoke.ts
+++ b/packages/harness-desktop/src/main/smoke.ts
@@ -43,7 +43,14 @@
  * so a CI log shows exactly which layer broke.
  */
 import { execFile } from "node:child_process";
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
@@ -72,16 +79,27 @@ function unpacked(p: string): string {
   return p.replace(/([\\/])app\.asar([\\/])/, "$1app.asar.unpacked$2");
 }
 
-async function check(name: string, fn: () => Promise<string>): Promise<SmokeCheck> {
+async function check(
+  name: string,
+  fn: () => Promise<string>,
+): Promise<SmokeCheck> {
   try {
     return { name, ok: true, detail: await fn() };
   } catch (err) {
-    return { name, ok: false, detail: err instanceof Error ? err.message : String(err) };
+    return {
+      name,
+      ok: false,
+      detail: err instanceof Error ? err.message : String(err),
+    };
   }
 }
 
 /** GET with the boot token, asserting status and (optionally) a body substring. */
-async function fetchOk(url: string, token: string | null, expectStatus: number): Promise<string> {
+async function fetchOk(
+  url: string,
+  token: string | null,
+  expectStatus: number,
+): Promise<string> {
   const res = await fetch(url, {
     headers: token ? { "X-Harness-Token": token } : {},
   });
@@ -103,7 +121,10 @@ async function checkPreloadBridge(): Promise<string> {
   const win = createSetupWindow();
   try {
     await new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("setup window did not finish loading in 15s")), 15_000);
+      const timer = setTimeout(
+        () => reject(new Error("setup window did not finish loading in 15s")),
+        15_000,
+      );
       win.webContents.once("did-finish-load", () => {
         clearTimeout(timer);
         resolve();
@@ -117,7 +138,8 @@ async function checkPreloadBridge(): Promise<string> {
       "({ bridge: typeof window.sapiomSetup, onProgress: typeof window.sapiomSetup?.onProgress," +
         " submitConsent: typeof window.sapiomSetup?.submitConsent })",
     )) as { bridge: string; onProgress: string; submitConsent: string };
-    if (shape.bridge !== "object") throw new Error("window.sapiomSetup is missing (preload did not run)");
+    if (shape.bridge !== "object")
+      throw new Error("window.sapiomSetup is missing (preload did not run)");
     if (shape.onProgress !== "function" || shape.submitConsent !== "function") {
       throw new Error(`bridge incomplete: ${JSON.stringify(shape)}`);
     }
@@ -220,10 +242,16 @@ async function checkNodePty(): Promise<string> {
   // must see through; elsewhere a shebang script. Spawning `cmd.exe`/`/bin/sh`
   // directly — as this check used to — passed on Windows while every real
   // session failed, because those are executable images and an agent is not.
-  const script = path.join(dir, isWindows ? "agent-probe.cmd" : "agent-probe.sh");
+  const script = path.join(
+    dir,
+    isWindows ? "agent-probe.cmd" : "agent-probe.sh",
+  );
   if (isWindows) {
     writeFileSync(path.join(dir, "agent-probe.js"), "process.exit(0);\n");
-    writeFileSync(script, '@echo off\r\n"%dp0%\\node.exe" "%dp0%\\agent-probe.js" %*\r\n');
+    writeFileSync(
+      script,
+      '@echo off\r\n"%dp0%\\node.exe" "%dp0%\\agent-probe.js" %*\r\n',
+    );
   } else {
     writeFileSync(script, "#!/bin/sh\nexit 0\n");
     chmodSync(script, 0o755);
@@ -236,7 +264,10 @@ async function checkNodePty(): Promise<string> {
       env: process.env as Record<string, string>,
     });
     const code = await new Promise<number>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("pty process did not exit in 10s")), 10_000);
+      const timer = setTimeout(
+        () => reject(new Error("pty process did not exit in 10s")),
+        10_000,
+      );
       proc.onExit(({ exitCode }) => {
         clearTimeout(timer);
         resolve(exitCode);
@@ -305,10 +336,14 @@ async function checkAgentShim(): Promise<string> {
  * path — HTTP, session record, pty spawn — is exercised for real on every OS.
  * Skipped, loudly, if the stub wasn't provided rather than silently passing.
  */
-async function checkSessionCreate(base: string, token: string | null): Promise<string> {
+async function checkSessionCreate(
+  base: string,
+  token: string | null,
+): Promise<string> {
   if (!token) throw new Error("boot url carried no token");
   const stub = process.env.SAPIOM_SMOKE_STUB_AGENT;
-  if (!stub) return "SKIPPED — no SAPIOM_SMOKE_STUB_AGENT (run via scripts/smoke.sh)";
+  if (!stub)
+    return "SKIPPED — no SAPIOM_SMOKE_STUB_AGENT (run via scripts/smoke.sh)";
 
   const cwd = mkdtempSync(path.join(tmpdir(), "sapiom-smoke-ws-"));
   try {
@@ -319,19 +354,31 @@ async function checkSessionCreate(base: string, token: string | null): Promise<s
     });
     const body = await res.text();
     if (res.status !== 201) {
-      throw new Error(`POST /api/sessions → ${res.status}: ${body.slice(0, 200)}`);
+      throw new Error(
+        `POST /api/sessions → ${res.status}: ${body.slice(0, 200)}`,
+      );
     }
-    const session = JSON.parse(body) as { id?: string; status?: string; cwd?: string };
-    if (!session.id) throw new Error(`no session id in response: ${body.slice(0, 120)}`);
+    const session = JSON.parse(body) as {
+      id?: string;
+      status?: string;
+      cwd?: string;
+    };
+    if (!session.id)
+      throw new Error(`no session id in response: ${body.slice(0, 120)}`);
 
     // The record must be visible in state too — a session that spawned but never
     // registered would leave the UI with nothing to attach to.
     const readState = async () =>
       (await (
-        await fetch(`${base}/api/state`, { headers: { "X-Harness-Token": token } })
-      ).json()) as { sessions?: Array<{ id: string; status?: string; ready?: boolean }> };
+        await fetch(`${base}/api/state`, {
+          headers: { "X-Harness-Token": token },
+        })
+      ).json()) as {
+        sessions?: Array<{ id: string; status?: string; ready?: boolean }>;
+      };
     let found = (await readState()).sessions?.find((s) => s.id === session.id);
-    if (!found) throw new Error(`session ${session.id} missing from /api/state`);
+    if (!found)
+      throw new Error(`session ${session.id} missing from /api/state`);
 
     // Hook delivery — the readiness chain end-to-end. The stub agent executes
     // its --settings file's SessionStart hook command the way Claude Code
@@ -387,36 +434,61 @@ async function checkSessionCreate(base: string, token: string | null): Promise<s
  * stale file from an earlier run can never be mistaken for this one's.
  */
 async function checkAgentEnvironment(sessionId: string): Promise<string> {
-  const file = process.env.SAPIOM_SMOKE_AGENT_ENV;
-  if (!file) return "agent env NOT CHECKED (no SAPIOM_SMOKE_AGENT_ENV — run via scripts/smoke.sh)";
+  const base = process.env.SAPIOM_SMOKE_AGENT_ENV;
+  if (!base)
+    return "agent env NOT CHECKED (no SAPIOM_SMOKE_AGENT_ENV — run via scripts/smoke.sh)";
+  const file = `${base}.${encodeURIComponent(sessionId)}.json`;
 
   // The pty spawns asynchronously; give the stub a moment to write.
   const deadline = Date.now() + 5_000;
-  let lines: string[] = [];
+  let snapshot:
+    | {
+        schemaVersion: number;
+        sessionId: string;
+        variableCount: number;
+        hasEsbuildBinaryPath: boolean;
+        hasPath: boolean;
+      }
+    | undefined;
   for (;;) {
     if (existsSync(file)) {
-      lines = readFileSync(file, "utf8").split("\n");
-      if (lines.some((l) => l === `SAPIOM_HARNESS_SESSION_ID=${sessionId}`)) break;
+      try {
+        const decoded = JSON.parse(
+          readFileSync(file, "utf8"),
+        ) as typeof snapshot;
+        if (
+          decoded?.schemaVersion === 1 &&
+          decoded.sessionId === sessionId &&
+          Number.isInteger(decoded.variableCount) &&
+          decoded.variableCount >= 0 &&
+          typeof decoded.hasEsbuildBinaryPath === "boolean" &&
+          typeof decoded.hasPath === "boolean"
+        ) {
+          snapshot = decoded;
+          break;
+        }
+      } catch {
+        // A partially observed write is retried until the same bounded deadline.
+      }
     }
     if (Date.now() > deadline) {
       throw new Error(
         existsSync(file)
-          ? `agent env dump is not this session's (no SAPIOM_HARNESS_SESSION_ID=${sessionId})`
+          ? `agent env snapshot is invalid for session ${sessionId}`
           : `agent never wrote ${file} — the stub did not run`,
       );
     }
     await new Promise((r) => setTimeout(r, 100));
   }
 
-  const leaked = lines.filter((l) => /^ESBUILD_BINARY_PATH=/.test(l));
-  if (leaked.length) {
-    throw new Error(`agent inherited the host's esbuild pin: ${leaked[0]!.slice(0, 160)}`);
+  if (snapshot.hasEsbuildBinaryPath) {
+    throw new Error("agent inherited the host's esbuild pin");
   }
   // PATH must still be there — this is a targeted strip, not a clean env.
-  if (!lines.some((l) => /^PATH=/.test(l))) {
+  if (!snapshot.hasPath) {
     throw new Error("agent inherited no PATH — the env strip took too much");
   }
-  return `agent env clean (${lines.length} vars, no esbuild pin)`;
+  return `agent env clean (${snapshot.variableCount} vars, no esbuild pin)`;
 }
 
 /**
@@ -442,9 +514,14 @@ async function checkUnpackedDeps(): Promise<string> {
     ["@sapiom/agent-core entry", agentCoreEntry],
     // The seed's template tree: cpSync can't opendir inside the archive, which
     // is what made POST /api/sample-project 500 with ENOTDIR in the packaged app.
-    ["agent-core templates", path.resolve(path.dirname(agentCoreEntry), "..", "..", "templates")],
+    [
+      "agent-core templates",
+      path.resolve(path.dirname(agentCoreEntry), "..", "..", "templates"),
+    ],
   ];
-  const missing = targets.filter(([, p]) => !existsSync(p)).map(([name, p]) => `${name} (${p})`);
+  const missing = targets
+    .filter(([, p]) => !existsSync(p))
+    .map(([name, p]) => `${name} (${p})`);
   if (missing.length) throw new Error(`not on disk: ${missing.join(", ")}`);
   return `${targets.length} entry points present on disk (asar-translated)`;
 }
@@ -466,7 +543,9 @@ type BundleForDeploy = (sourceDir: string) => Promise<{
  * the ESM entry out of the exports map and import that.
  */
 async function loadBundleForDeploy(): Promise<BundleForDeploy> {
-  const fromHarness = createRequire(require.resolve("@sapiom/harness/package.json"));
+  const fromHarness = createRequire(
+    require.resolve("@sapiom/harness/package.json"),
+  );
   const pkgPath = fromHarness.resolve("@sapiom/agent-core/package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
     exports?: { ".": { import?: string } };
@@ -474,15 +553,21 @@ async function loadBundleForDeploy(): Promise<BundleForDeploy> {
     main?: string;
   };
   const rel = pkg.exports?.["."]?.import ?? pkg.module ?? pkg.main;
-  if (!rel) throw new Error(`@sapiom/agent-core (${pkgPath}) declares no entry point`);
+  if (!rel)
+    throw new Error(`@sapiom/agent-core (${pkgPath}) declares no entry point`);
   const entry = path.resolve(path.dirname(pkgPath), rel);
 
-  const mod = (await import(pathToFileURL(entry).href)) as Record<string, unknown> & {
+  const mod = (await import(pathToFileURL(entry).href)) as Record<
+    string,
+    unknown
+  > & {
     default?: Record<string, unknown>;
   };
   const fn = mod.bundleForDeploy ?? mod.default?.bundleForDeploy;
   if (typeof fn !== "function") {
-    throw new Error(`${entry} exports no bundleForDeploy (got ${Object.keys(mod).join(", ") || "nothing"})`);
+    throw new Error(
+      `${entry} exports no bundleForDeploy (got ${Object.keys(mod).join(", ") || "nothing"})`,
+    );
   }
   return fn as BundleForDeploy;
 }
@@ -511,12 +596,17 @@ async function checkRuntimeShims(): Promise<string> {
     if (!existsSync(shim)) throw new Error(`no ${name} shim at ${shim}`);
     try {
       // shell on Windows: a .cmd cannot be spawned directly (CVE-2024-27980).
-      const { stdout } = await exec(shim, ["--version"], { shell: process.platform === "win32", windowsHide: true });
+      const { stdout } = await exec(shim, ["--version"], {
+        shell: process.platform === "win32",
+        windowsHide: true,
+      });
       const version = stdout.trim().split("\n")[0] ?? "";
       if (!version) throw new Error("no version output");
       reports.push(`${name} ${version}`);
     } catch (err) {
-      throw new Error(`${name} shim did not run: ${err instanceof Error ? err.message : String(err)}`);
+      throw new Error(
+        `${name} shim did not run: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
 
     // Windows also needs the EXTENSIONLESS sh flavor beside the .cmd: Claude
@@ -528,17 +618,27 @@ async function checkRuntimeShims(): Promise<string> {
     // execution — the hook-delivery poll in session-create covers execution.
     if (process.platform === "win32") {
       const shShim = path.join(dir, name);
-      if (!existsSync(shShim)) throw new Error(`no extensionless (Git Bash) ${name} shim at ${shShim}`);
+      if (!existsSync(shShim))
+        throw new Error(
+          `no extensionless (Git Bash) ${name} shim at ${shShim}`,
+        );
       const body = readFileSync(shShim, "utf8");
       if (!body.startsWith("#!/bin/sh")) {
-        throw new Error(`${shShim} is not a #!/bin/sh script (starts: ${JSON.stringify(body.slice(0, 20))})`);
+        throw new Error(
+          `${shShim} is not a #!/bin/sh script (starts: ${JSON.stringify(body.slice(0, 20))})`,
+        );
       }
       if (body.includes("\\")) {
-        throw new Error(`${shShim} embeds backslash paths — sh-unsafe, must be forward-slashed`);
+        throw new Error(
+          `${shShim} embeds backslash paths — sh-unsafe, must be forward-slashed`,
+        );
       }
     }
   }
-  return reports.join(", ") + (process.platform === "win32" ? " (+ extensionless Git Bash shims)" : "");
+  return (
+    reports.join(", ") +
+    (process.platform === "win32" ? " (+ extensionless Git Bash shims)" : "")
+  );
 }
 
 /**
@@ -558,7 +658,10 @@ async function checkRuntimeShims(): Promise<string> {
  * dependencies, no network, and deterministic. A packaging regression cannot
  * produce that error; it produces ENOTDIR, ERR_MODULE_NOT_FOUND, or silence.
  */
-async function checkRunLocal(base: string, token: string | null): Promise<string> {
+async function checkRunLocal(
+  base: string,
+  token: string | null,
+): Promise<string> {
   if (!token) throw new Error("boot url carried no token");
 
   const dir = mkdtempSync(path.join(tmpdir(), "sapiom-smoke-runlocal-"));
@@ -569,18 +672,32 @@ async function checkRunLocal(base: string, token: string | null): Promise<string
       body: JSON.stringify({ sourceDir: dir }),
     });
     const body = await res.text();
-    if (res.status !== 200) throw new Error(`POST /api/runs/local → ${res.status}: ${body.slice(0, 200)}`);
+    if (res.status !== 200)
+      throw new Error(
+        `POST /api/runs/local → ${res.status}: ${body.slice(0, 200)}`,
+      );
 
     const lines = body.trim().split("\n").filter(Boolean);
     if (lines.length === 0) {
       // No NDJSON at all is the signature of the child never running — e.g. the
       // app relaunching itself instead of executing the bootstrap.
-      throw new Error("no NDJSON from the run-local child (did it spawn at all?)");
+      throw new Error(
+        "no NDJSON from the run-local child (did it spawn at all?)",
+      );
     }
-    const terminal = JSON.parse(lines[lines.length - 1]) as { kind?: string; error?: string };
+    const terminal = JSON.parse(lines[lines.length - 1]) as {
+      kind?: string;
+      error?: string;
+    };
     const message = terminal.error ?? "";
-    if (/ENOTDIR|ENOENT|ERR_MODULE_NOT_FOUND|Cannot find (module|package)/i.test(message)) {
-      throw new Error(`packaging failure reached the child: ${message.slice(0, 300)}`);
+    if (
+      /ENOTDIR|ENOENT|ERR_MODULE_NOT_FOUND|Cannot find (module|package)/i.test(
+        message,
+      )
+    ) {
+      throw new Error(
+        `packaging failure reached the child: ${message.slice(0, 300)}`,
+      );
     }
     if (!/index\.ts/i.test(message)) {
       throw new Error(
@@ -615,7 +732,10 @@ async function checkDeployBundle(): Promise<string> {
 
   const dir = mkdtempSync(path.join(tmpdir(), "sapiom-smoke-bundle-"));
   try {
-    writeFileSync(path.join(dir, "shared.ts"), "export const answer: number = 42;\n");
+    writeFileSync(
+      path.join(dir, "shared.ts"),
+      "export const answer: number = 42;\n",
+    );
     writeFileSync(
       path.join(dir, "index.ts"),
       'import { answer } from "./shared.js";\nexport default { answer };\n',
@@ -635,7 +755,9 @@ async function checkDeployBundle(): Promise<string> {
     });
     // The relative import must have been INLINED — that's the whole job.
     if (!code.includes("42")) {
-      throw new Error(`bundle did not inline ./shared.ts: ${code.slice(0, 200)}`);
+      throw new Error(
+        `bundle did not inline ./shared.ts: ${code.slice(0, 200)}`,
+      );
     }
     const binPath = process.env.ESBUILD_BINARY_PATH;
     return `bundled a 2-file project (${code.length} bytes) via ${binPath ? path.basename(path.dirname(binPath)) + "/" + path.basename(binPath) : "esbuild's own resolution"}`;
@@ -684,7 +806,10 @@ async function checkDesktopBridge(boot: BootResult): Promise<string> {
   // ahead of this one happen to take long enough, which is not a guarantee.
   if (win.webContents.isLoading()) {
     await new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("main window did not finish loading in 15s")), 15_000);
+      const timer = setTimeout(
+        () => reject(new Error("main window did not finish loading in 15s")),
+        15_000,
+      );
       const done = (): void => {
         clearTimeout(timer);
         resolve();
@@ -716,34 +841,46 @@ async function checkDesktopBridge(boot: BootResult): Promise<string> {
   };
 
   if (shape.bridge !== "object") {
-    throw new Error("window.sapiomDesktop is missing — the main window's preload did not run");
+    throw new Error(
+      "window.sapiomDesktop is missing — the main window's preload did not run",
+    );
   }
   if (shape.check !== "function") {
-    throw new Error(`bridge incomplete — checkForUpdates missing: ${JSON.stringify(shape)}`);
+    throw new Error(
+      `bridge incomplete — checkForUpdates missing: ${JSON.stringify(shape)}`,
+    );
   }
   // Shape-only for chooseDirectory: unlike checkForUpdates, we must NOT invoke it —
   // it opens a real OS folder sheet that would block a headless CI run forever. Its
   // ipcMain handler is registered on every boot path (dialogs.ts, alongside the
   // updater's), so presence of the wrapped method is the honest thing to assert here.
   if (shape.choose !== "function") {
-    throw new Error(`bridge incomplete — chooseDirectory missing: ${JSON.stringify(shape)}`);
+    throw new Error(
+      `bridge incomplete — chooseDirectory missing: ${JSON.stringify(shape)}`,
+    );
   }
   // Shape-only, like chooseDirectory: onDeepLink is a receive-only subscription
   // (main → renderer push), so there is nothing to invoke here — asserting the
   // wrapped method is present is the honest check.
   if (shape.deep !== "function") {
-    throw new Error(`bridge incomplete — onDeepLink missing: ${JSON.stringify(shape)}`);
+    throw new Error(
+      `bridge incomplete — onDeepLink missing: ${JSON.stringify(shape)}`,
+    );
   }
   // Shape-only again: onUpdateState is the other receive-only subscription
   // (drives the rail's "Update now" card; the apply path stays native).
   if (shape.updateState !== "function") {
-    throw new Error(`bridge incomplete — onUpdateState missing: ${JSON.stringify(shape)}`);
+    throw new Error(
+      `bridge incomplete — onUpdateState missing: ${JSON.stringify(shape)}`,
+    );
   }
   // Shape-only: pathForFile needs a real dropped File to return anything, and it
   // is read-only + local (webUtils.getPathForFile, no IPC) — what a drop on the
   // terminal uses to type the file's path into the pty.
   if (shape.pathForFile !== "function") {
-    throw new Error(`bridge incomplete — pathForFile missing: ${JSON.stringify(shape)}`);
+    throw new Error(
+      `bridge incomplete — pathForFile missing: ${JSON.stringify(shape)}`,
+    );
   }
   // The bridge must stay MINIMAL as well as present. Beyond appVersion the only
   // members allowed are checkForUpdates (no destructive counterpart — applying
@@ -758,7 +895,9 @@ async function checkDesktopBridge(boot: BootResult): Promise<string> {
     "Object.keys(window.sapiomDesktop).filter((k) => k !== 'appVersion' && k !== 'checkForUpdates' && k !== 'chooseDirectory' && k !== 'onDeepLink' && k !== 'onUpdateState' && k !== 'pathForFile')",
   )) as string[];
   if (extra.length > 0) {
-    throw new Error(`bridge exposes unexpected members to page code: ${extra.join(", ")}`);
+    throw new Error(
+      `bridge exposes unexpected members to page code: ${extra.join(", ")}`,
+    );
   }
   // Not cosmetic-only: the version arrives via `additionalArguments`, which is the
   // documented way to pass a value to a preload precisely because reading a
@@ -786,12 +925,16 @@ async function checkDesktopBridge(boot: BootResult): Promise<string> {
       "(e) => ({ ok: false, kind: String((e && e.message) || e) }))",
   )) as { ok: boolean; kind?: string; reason?: string };
   if (!outcome.ok) {
-    throw new Error(`checkForUpdates() rejected: ${outcome.kind} (is the ipcMain handler registered?)`);
+    throw new Error(
+      `checkForUpdates() rejected: ${outcome.kind} (is the ipcMain handler registered?)`,
+    );
   }
   if (outcome.kind !== "disabled") {
     // A smoke run must never reach the network; any other outcome means the gate
     // leaked and CI would start depending on GitHub.
-    throw new Error(`expected a "disabled" outcome under --smoke, got "${outcome.kind}"`);
+    throw new Error(
+      `expected a "disabled" outcome under --smoke, got "${outcome.kind}"`,
+    );
   }
   // The REASON is what makes this check meaningful now that senders are validated.
   // A rejected sender also answers `disabled`, so matching on the kind alone could
@@ -833,10 +976,14 @@ async function checkUpdateConfig(): Promise<string> {
   const owner = field("owner");
   const repo = field("repo");
   if (provider !== "github") {
-    throw new Error(`app-update.yml provider is "${provider ?? "(none)"}", expected "github"`);
+    throw new Error(
+      `app-update.yml provider is "${provider ?? "(none)"}", expected "github"`,
+    );
   }
   if (!owner || !repo) {
-    throw new Error(`app-update.yml names no owner/repo (owner="${owner}", repo="${repo}")`);
+    throw new Error(
+      `app-update.yml names no owner/repo (owner="${owner}", repo="${repo}")`,
+    );
   }
 
   // Reading the getter is the test: it constructs the updater for THIS packaging
@@ -886,7 +1033,8 @@ export async function runSmokeChecks(boot: BootResult): Promise<SmokeCheck[]> {
   return [
     await check("http-spa", async () => {
       const html = await fetchOk(`${base}/`, null, 200);
-      if (!html.includes('id="root"')) throw new Error("served HTML has no #root — wrong webDir?");
+      if (!html.includes('id="root"'))
+        throw new Error("served HTML has no #root — wrong webDir?");
       return `index.html served from ${resolveWebDir()}`;
     }),
     await check("host-terminology", async () => {
@@ -902,12 +1050,16 @@ export async function runSmokeChecks(boot: BootResult): Promise<SmokeCheck[]> {
     }),
     await check("http-state", async () => {
       if (!token) throw new Error("boot url carried no token");
-      const body = JSON.parse(await fetchOk(`${base}/api/state`, token, 200)) as {
+      const body = JSON.parse(
+        await fetchOk(`${base}/api/state`, token, 200),
+      ) as {
         version?: string;
         sessions?: unknown[];
       };
       if (typeof body.version !== "string" || !Array.isArray(body.sessions)) {
-        throw new Error(`unexpected /api/state shape: ${JSON.stringify(body).slice(0, 120)}`);
+        throw new Error(
+          `unexpected /api/state shape: ${JSON.stringify(body).slice(0, 120)}`,
+        );
       }
       return `version ${body.version}, ${body.sessions.length} session(s)`;
     }),
@@ -942,15 +1094,21 @@ export function reportSmoke(checks: SmokeCheck[]): number {
   // most in: the Windows agent install failing, `agent-shim` skipping, and the
   // log claiming full coverage it didn't have. Skips don't fail the run, but they
   // are visibly distinct.
-  const isSkip = (c: SmokeCheck): boolean => c.ok && c.detail.startsWith("SKIPPED");
+  const isSkip = (c: SmokeCheck): boolean =>
+    c.ok && c.detail.startsWith("SKIPPED");
   const skipped = checks.filter(isSkip);
   const passed = checks.filter((c) => c.ok && !isSkip(c));
 
   const lines = [
-    ...checks.map((c) => `[smoke] ${!c.ok ? "FAIL" : isSkip(c) ? "SKIP" : "PASS"} ${c.name} — ${c.detail}`),
+    ...checks.map(
+      (c) =>
+        `[smoke] ${!c.ok ? "FAIL" : isSkip(c) ? "SKIP" : "PASS"} ${c.name} — ${c.detail}`,
+    ),
     failed.length === 0
       ? `[smoke] OK — ${passed.length} passed` +
-        (skipped.length ? `, ${skipped.length} skipped (${skipped.map((c) => c.name).join(", ")})` : "")
+        (skipped.length
+          ? `, ${skipped.length} skipped (${skipped.map((c) => c.name).join(", ")})`
+          : "")
       : `[smoke] FAILED — ${failed.length}/${checks.length}: ${failed.map((c) => c.name).join(", ")}`,
   ];
   for (const line of lines) console.log(line);
@@ -960,7 +1118,9 @@ export function reportSmoke(checks: SmokeCheck[]): number {
     try {
       writeFileSync(outFile, lines.join("\n") + "\n", "utf8");
     } catch (err) {
-      console.error(`[smoke] could not write ${outFile}: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(
+        `[smoke] could not write ${outFile}: ${err instanceof Error ? err.message : String(err)}`,
+      );
     }
   }
   return failed.length === 0 ? 0 : 1;
diff --git a/packages/harness/README.md b/packages/harness/README.md
index 6a357f009..32d6ca475 100644
--- a/packages/harness/README.md
+++ b/packages/harness/README.md
@@ -41,11 +41,11 @@ session lifecycle) to improve Sapiom. Opt out any time; `--no-telemetry`
 disables collection entirely. Events are also written locally to
 `~/.sapiom/harness/events.ndjson` for your own inspection.
 
-Project planner sessions add content-free `planner_session.*` and
-`planner_greeting.*` lifecycle events. Those events contain bounded project,
-session, attempt, resolution, queue-depth, and error-code fields only. They never
-contain planner prompts, assistant text, local paths, or provider error text;
-the same telemetry opt-in controls whether they leave the machine. Planner hook
+Project bootstrap adds content-free `project_bootstrap.*` and
+`project_agent.identity_*` lifecycle events. They contain bounded project,
+session, attempt, retry, queue-depth, and error-code fields. Prompts, assistant
+text, local paths, and provider error text remain local. The same telemetry
+opt-in controls whether lifecycle events leave the machine. Project hook
 projections reduce session-start source to a fixed enum, model identity to a
 presence boolean, and usage to allowlisted, clamped token counters; arbitrary
 provider strings and usage fields remain local.
@@ -57,10 +57,9 @@ Agent Studio makes one Sapiom request of its own, separate from telemetry
 from what its other components do on their own (the app's product analytics, and
 `npx @sapiom/mcp@latest` fetching and running the local MCP server each session):
 
-Planner-session bootstrap makes no additional network request. Its focused
-context, greeting coordination, FIFO, and lifecycle persistence stay inside the
-local server. Existing outbound surfaces remain the system-prompt fetch below,
-the coding agent's ordinary provider traffic, and opt-in telemetry.
+Project bootstrap adds no separate network endpoint. Its state, durable input
+FIFO, and recovery stay inside the local server. The initial map seed uses the
+coding agent's ordinary provider traffic and existing project tools.
 
 - **System prompt, on every session start** — an unauthenticated
   `GET https://api.sapiom.ai/v1/harness/system-prompt`, so the Studio conventions
@@ -108,10 +107,16 @@ only project, user, and session IDs. Stop branching on its former `role` or
 `assignment` fields. Valid persisted legacy metadata is normalized while
 preserving the session/provider IDs, cwd, title, transcript, and Canvas;
 conflicting or malformed authority fails closed. Optional `projectBootstrap`
-is lifecycle metadata, not an authority or session type. The legacy startup
-projection and project-scoped aliases remain temporarily for existing durable
-startup queues. Migrated sessions use ordinary HTTP input, with the server
-retaining FIFO ownership until those queues finish.
+is lifecycle metadata, not an authority or session type. On upgrade, the server migrates legacy startup queues into the durable bootstrap
+FIFO. The old planner-session create, message, and retry routes are removed.
+Use the ordinary `/api/sessions` create, resume, and input routes.
+
+When Studio opens a new project, it schedules one automatic first conversation,
+named **Plan Agents**, to seed an evidence-supported Agent Map. The catalog
+outbox and first-session claim keep this lifecycle recoverable across restart.
+The complete coordinator handles readiness, interrupted delivery, retries,
+user-input preemption, and shutdown before another turn may be sent. Existing
+projects are not enrolled merely by reading their map.
 
 `POST /api/sessions` accepts the content-free
 `initialUserInputPending: true` hint when the caller owns the first prompt.
diff --git a/packages/harness/src/core/paths.test.ts b/packages/harness/src/core/paths.test.ts
index 1177e89ce..a690170ac 100644
--- a/packages/harness/src/core/paths.test.ts
+++ b/packages/harness/src/core/paths.test.ts
@@ -31,9 +31,6 @@ describe("resolveStatePaths", () => {
     expect(paths.settings).toBe(path.join(root, "settings.json"));
     expect(paths.studioProjects).toBe(path.join(root, "studio-projects.json"));
     expect(paths.agentMap).toBe(path.join(root, "agent-map"));
-    expect(paths.plannerSessions).toBe(
-      path.join(root, "agent-map", "planner-sessions"),
-    );
     expect(paths.generated).toBe(path.join(root, "generated"));
     expect(paths.sampleProject).toBe(path.join(root, "sample-project"));
   });
@@ -48,9 +45,6 @@ describe("resolveStatePaths", () => {
     expect(paths.settings).toBe("/scratch/state/settings.json");
     expect(paths.studioProjects).toBe("/scratch/state/studio-projects.json");
     expect(paths.agentMap).toBe("/scratch/state/agent-map");
-    expect(paths.plannerSessions).toBe(
-      "/scratch/state/agent-map/planner-sessions",
-    );
     expect(paths.generated).toBe("/scratch/state/generated");
     expect(paths.sampleProject).toBe("/scratch/state/sample-project");
   });
diff --git a/packages/harness/src/core/paths.ts b/packages/harness/src/core/paths.ts
index 587bb026a..aaa26598d 100644
--- a/packages/harness/src/core/paths.ts
+++ b/packages/harness/src/core/paths.ts
@@ -28,7 +28,7 @@ export interface HarnessStatePaths {
   studioProjects: string;
   pendingSecrets: string;
   agentMap: string;
-  plannerSessions: string;
+  projectBootstrap: string;
   generated: string;
   records: string;
   sampleProject: string;
@@ -60,7 +60,7 @@ export function resolveStatePaths(stateRoot?: string): HarnessStatePaths {
     studioProjects: join(root, relativeToHome(HARNESS_PATHS.studioProjects)),
     pendingSecrets: join(root, relativeToHome(HARNESS_PATHS.pendingSecrets)),
     agentMap: join(root, relativeToHome(HARNESS_PATHS.agentMap)),
-    plannerSessions: join(root, "agent-map", "planner-sessions"),
+    projectBootstrap: join(root, "agent-map", "project-bootstrap"),
     generated: join(root, relativeToHome(HARNESS_PATHS.generated)),
     records: join(root, relativeToHome(HARNESS_PATHS.records)),
     sampleProject: join(root, relativeToHome(HARNESS_PATHS.sampleProject)),
diff --git a/packages/harness/src/core/planner-greeting.test.ts b/packages/harness/src/core/planner-greeting.test.ts
deleted file mode 100644
index dd1b46c9e..000000000
--- a/packages/harness/src/core/planner-greeting.test.ts
+++ /dev/null
@@ -1,962 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { AnalyticsEvent, HarnessSession } from "../shared/types.js";
-import type { SessionManager } from "./session-manager.js";
-import {
-  PlannerGreetingCoordinator,
-  PlannerGreetingRetryUnavailableError,
-  plannerGreetingPrompt,
-} from "./planner-greeting.js";
-
-function event(
-  sessionId: string,
-  type: AnalyticsEvent["type"],
-  payload: Record<string, unknown>,
-): AnalyticsEvent {
-  return {
-    eventId: `event-${type}`,
-    seq: 1,
-    ts: "2026-09-01T00:00:00.000Z",
-    userId: "user-1",
-    tenantId: null,
-    machineId: "machine-1",
-    harnessSessionId: sessionId,
-    agentSessionId: "agent-1",
-    harness: "codex",
-    type,
-    payload,
-  };
-}
-
-function plannerSession(id = "session-1"): HarnessSession {
-  return {
-    id,
-    agentSessionId: "agent-1",
-    harness: "codex",
-    cwd: "/private/project",
-    title: "project",
-    status: "running",
-    createdAt: "2026-09-01T00:00:00.000Z",
-    lastActiveAt: "2026-09-01T00:00:00.000Z",
-    exitCode: null,
-    boundWorkflowPath: null,
-    ready: true,
-    planning: {
-      identity: {
-        projectId: "project-1",
-        sessionId: id,
-        userId: "user-1",
-        role: "map-planner",
-      },
-      greeting: { status: "pending" },
-      queuedInputIds: [],
-    },
-  };
-}
-
-describe("PlannerGreetingCoordinator", () => {
-  let root: string;
-  let session: HarnessSession;
-  let submitted: string[];
-  let manager: SessionManager;
-
-  beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), "planner-greeting-"));
-    session = plannerSession();
-    submitted = [];
-    manager = {
-      get: (id: string) => (id === session.id ? session : undefined),
-      setPlanningMetadata: async (_id: string, metadata: NonNullable<HarnessSession["planning"]>) => {
-        session.planning = structuredClone(metadata);
-      },
-      submitInput: async (_id: string, text: string) => {
-        submitted.push(text);
-        return true;
-      },
-    } as unknown as SessionManager;
-  });
-
-  afterEach(async () => {
-    vi.useRealTimers();
-    await fs.rm(root, { recursive: true, force: true });
-  });
-
-  it("persists one ready-gated greeting, then releases accepted input FIFO", async () => {
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.onSessionStatus(session);
-    expect(submitted).toHaveLength(1);
-    const greeting = submitted[0]!;
-
-    await coordinator.enqueue(session.id, "first user message");
-    await coordinator.enqueue(session.id, "second user message");
-    expect(submitted).toEqual([greeting]);
-
-    const localPrompt = coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: greeting }),
-    );
-    expect(localPrompt.payload).toMatchObject({
-      prompt: greeting,
-      plannerOrigin: "infrastructure",
-    });
-    expect(coordinator.redactForTelemetry(localPrompt).payload).not.toHaveProperty(
-      "prompt",
-    );
-
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: "What should we build?" }),
-    );
-    expect(submitted).toEqual([
-      greeting,
-      "first user message",
-      "second user message",
-    ]);
-    expect(session.planning).toMatchObject({
-      greeting: { status: "delivered", messageId: "event-turn.completed" },
-      queuedInputIds: [],
-    });
-    const durable = JSON.parse(
-      await fs.readFile(
-        path.join(root, session.id, "input-queue.json"),
-        "utf8",
-      ),
-    ) as { inputs: unknown[] };
-    expect(durable.inputs).toEqual([]);
-  });
-
-  it("rejects a planner session identity that could escape the queue root", async () => {
-    session = plannerSession("../outside-planner-root");
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-
-    await expect(
-      coordinator.register(session, { emptyProject: true, mode: "created" }),
-    ).rejects.toThrow("invalid planner session storage identity");
-    await expect(fs.readdir(root)).resolves.toEqual([]);
-  });
-
-  it("recovers a generating restart without duplicating onboarding", async () => {
-    const first = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await first.register(session, { emptyProject: true, mode: "created" });
-    await first.onSessionStatus(session);
-    await first.enqueue(session.id, "continue with my request");
-    const greeting = submitted[0]!;
-
-    const restarted = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await restarted.register(session, { emptyProject: true, mode: "boot" });
-
-    expect(submitted).toEqual([greeting, "continue with my request"]);
-    expect(session.planning).toMatchObject({
-      greeting: { status: "skipped", reason: "user-proceeded" },
-      queuedInputIds: [],
-    });
-  });
-
-  it("lets queued user work win an in-flight greeting failure", async () => {
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: false, mode: "created" });
-    await coordinator.onSessionStatus(session);
-    const greeting = submitted[0]!;
-    await coordinator.enqueue(session.id, "review the existing plan");
-    coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: greeting }),
-    );
-
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: null }),
-    );
-
-    expect(submitted).toEqual([greeting, "review the existing plan"]);
-    expect(session.planning?.greeting).toEqual({
-      status: "skipped",
-      reason: "user-proceeded",
-    });
-  });
-
-  it("bounds retry to failed, retryable sessions without accepted user work", async () => {
-    session.planning!.greeting = {
-      status: "failed",
-      retryable: true,
-      errorCode: "model_turn_failed",
-    };
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.retry(session.id);
-    expect(submitted).toHaveLength(1);
-    expect(session.planning?.greeting.status).toBe("generating");
-    await expect(coordinator.retry(session.id)).rejects.toBeInstanceOf(
-      PlannerGreetingRetryUnavailableError,
-    );
-  });
-
-  it("keeps a same-process generating attempt live on idempotent registration", async () => {
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.onSessionStatus(session);
-    const generating = structuredClone(session.planning!.greeting);
-
-    await coordinator.register(session, { emptyProject: true, mode: "live" });
-
-    expect(session.planning?.greeting).toEqual(generating);
-    expect(submitted).toHaveLength(1);
-  });
-
-  it("keeps resume-suppressed skipped state authoritative over a stale queue file", async () => {
-    const first = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await first.register(session, { emptyProject: true, mode: "created" });
-    await first.onSessionStatus(session);
-    await first.enqueue(session.id, "continue from durable input");
-    session.planning!.greeting = { status: "skipped", reason: "user-proceeded" };
-
-    const resumed = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await resumed.register(session, { emptyProject: true, mode: "resumed" });
-
-    expect(session.planning).toMatchObject({
-      greeting: { status: "skipped", reason: "user-proceeded" },
-      queuedInputIds: [],
-    });
-    expect(submitted.at(-1)).toBe("continue from durable input");
-  });
-
-  it("uses its accepted ledger to finish a failed dequeue after restart without duplicate or loss", async () => {
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    let failAcceptedDequeue = true;
-    const first = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-      writeState: async (file, value) => {
-        const state = value as {
-          dispatchingInputId: string | null;
-          inputs: unknown[];
-        };
-        if (
-          failAcceptedDequeue &&
-          submitted.length === 1 &&
-          state.dispatchingInputId === null &&
-          state.inputs.length === 0
-        ) {
-          failAcceptedDequeue = false;
-          throw new Error("injected queue cleanup failure");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-    });
-    await first.register(session, { emptyProject: true, mode: "created" });
-
-    await expect(
-      first.enqueue(session.id, "deliver exactly once"),
-    ).resolves.toBeDefined();
-    expect(submitted).toEqual(["deliver exactly once"]);
-    const durableBeforeRestart = JSON.parse(
-      await fs.readFile(
-        path.join(root, session.id, "input-queue.json"),
-        "utf8",
-      ),
-    ) as { dispatchingInputId: string | null; inputs: Array<{ id: string }> };
-    expect(durableBeforeRestart.dispatchingInputId).toBe(
-      durableBeforeRestart.inputs[0]!.id,
-    );
-    const acceptedBeforeRestart = JSON.parse(
-      await fs.readFile(
-        path.join(root, session.id, "accepted-inputs.json"),
-        "utf8",
-      ),
-    ) as { inputIds: string[] };
-    expect(acceptedBeforeRestart.inputIds).toEqual([
-      durableBeforeRestart.inputs[0]!.id,
-    ]);
-
-    const restarted = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await restarted.register(session, { emptyProject: true, mode: "boot" });
-
-    expect(submitted).toEqual(["deliver exactly once"]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-    const durableAfterRestart = JSON.parse(
-      await fs.readFile(
-        path.join(root, session.id, "input-queue.json"),
-        "utf8",
-      ),
-    ) as { dispatchingInputId: string | null; inputs: unknown[] };
-    expect(durableAfterRestart).toMatchObject({
-      dispatchingInputId: null,
-      inputs: [],
-    });
-  });
-
-  it("does not publish a phantom dispatch intent when its durable write fails", async () => {
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    let failIntentWrite = true;
-    const lifecycle: unknown[] = [];
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      writeState: async (file, value) => {
-        const state = value as {
-          dispatchingInputId: string | null;
-          inputs: unknown[];
-        };
-        if (
-          failIntentWrite &&
-          state.dispatchingInputId !== null &&
-          state.inputs.length === 1
-        ) {
-          failIntentWrite = false;
-          throw new Error("transient dispatch-intent write failure");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-      onEvent: (value) => {
-        lifecycle.push(value);
-      },
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-
-    await coordinator.enqueue(session.id, "first was never submitted");
-    expect(submitted).toEqual([]);
-    await coordinator.enqueue(session.id, "second triggers a safe retry");
-
-    expect(submitted).toEqual([
-      "first was never submitted",
-      "second triggers a safe retry",
-    ]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-    expect(lifecycle).not.toContainEqual(
-      expect.objectContaining({
-        name: "planner_session.input_delivery_uncertain",
-      }),
-    );
-  });
-
-  it("does not resurrect an enqueue whose primary queue write was rejected", async () => {
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    let rejectFirstEnqueue = true;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      writeState: async (file, value) => {
-        const state = value as {
-          dispatchingInputId: string | null;
-          inputs: Array<{ text: string }>;
-        };
-        if (
-          rejectFirstEnqueue &&
-          state.dispatchingInputId === null &&
-          state.inputs.some((input) => input.text === "rejected input")
-        ) {
-          rejectFirstEnqueue = false;
-          throw new Error("primary enqueue write rejected");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-
-    await expect(
-      coordinator.enqueue(session.id, "rejected input"),
-    ).rejects.toThrow("planner state persistence failed");
-    await coordinator.enqueue(session.id, "accepted input");
-
-    expect(submitted).toEqual(["accepted input"]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-    expect(
-      await fs.readFile(
-        path.join(root, session.id, "input-queue.json"),
-        "utf8",
-      ),
-    ).not.toContain("rejected input");
-  });
-
-  it("keeps dispatching when only the secondary sessions projection fails", async () => {
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    const setPlanningMetadata = vi.fn(async () => {
-      throw new Error("sessions.json projection unavailable");
-    });
-    manager.setPlanningMetadata = setPlanningMetadata;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-
-    await expect(
-      coordinator.enqueue(session.id, "deliver from the authoritative queue"),
-    ).resolves.toMatchObject({ queuedInputIds: [] });
-
-    expect(submitted).toEqual(["deliver from the authoritative queue"]);
-    expect(setPlanningMetadata).toHaveBeenCalled();
-    const durable = JSON.parse(
-      await fs.readFile(
-        path.join(root, session.id, "input-queue.json"),
-        "utf8",
-      ),
-    ) as { dispatchingInputId: string | null; inputs: unknown[] };
-    expect(durable).toMatchObject({
-      dispatchingInputId: null,
-      inputs: [],
-    });
-  });
-
-  it("resolves an orphaned dispatch as uncertain and lets the later FIFO continue", async () => {
-    session.ready = false;
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    let firstSubmitAttempted = false;
-    let failRollback = true;
-    manager.submitInput = async (_id: string, text: string) => {
-      if (!firstSubmitAttempted) {
-        firstSubmitAttempted = true;
-        throw new Error("process ended before PTY acceptance was knowable");
-      }
-      submitted.push(text);
-      return true;
-    };
-    const first = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      writeState: async (file, value) => {
-        const state = value as {
-          dispatchingInputId: string | null;
-          inputs: unknown[];
-        };
-        if (
-          failRollback &&
-          firstSubmitAttempted &&
-          state.dispatchingInputId === null &&
-          state.inputs.length === 2
-        ) {
-          failRollback = false;
-          throw new Error("simulated crash before intent rollback");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-    });
-    await first.register(session, { emptyProject: true, mode: "created" });
-    await first.enqueue(session.id, "delivery became uncertain");
-    await first.enqueue(session.id, "must still make progress");
-    session.ready = true;
-    await first.onSessionStatus(session);
-
-    const lifecycle: unknown[] = [];
-    const restarted = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      onEvent: (value) => {
-        lifecycle.push(value);
-      },
-    });
-    await restarted.register(session, { emptyProject: true, mode: "boot" });
-
-    expect(submitted).toEqual(["must still make progress"]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-    expect(lifecycle).toContainEqual(
-      expect.objectContaining({
-        name: "planner_session.input_delivery_uncertain",
-        errorCode: "delivery_uncertain",
-        queueDepth: 1,
-      }),
-    );
-    expect(JSON.stringify(lifecycle)).not.toContain("delivery became uncertain");
-  });
-
-  it("compacts a stale accepted-ledger entry before acknowledging later input", async () => {
-    session.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    let failFirstCleanup = true;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      writeAcceptedLedger: async (file, value) => {
-        const ledger = value as { inputIds: string[] };
-        if (failFirstCleanup && ledger.inputIds.length === 0) {
-          failFirstCleanup = false;
-          throw new Error("injected accepted-ledger cleanup failure");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-
-    await coordinator.enqueue(session.id, "first accepted input");
-    await coordinator.enqueue(session.id, "second accepted input");
-
-    expect(submitted).toEqual(["first accepted input", "second accepted input"]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-    expect(
-      JSON.parse(
-        await fs.readFile(
-          path.join(root, session.id, "accepted-inputs.json"),
-          "utf8",
-        ),
-      ),
-    ).toEqual({ schemaVersion: 1, inputIds: [] });
-  });
-
-  it("bounds pending readiness, then drains its durable FIFO when readiness arrives", async () => {
-    vi.useFakeTimers();
-    session.ready = false;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 100,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.enqueue(session.id, "queued while booting");
-    await vi.advanceTimersByTimeAsync(101);
-    await (coordinator as unknown as { writes: Map<string, Promise<unknown>> })
-      .writes.get(session.id);
-    expect(session.planning?.greeting).toEqual({
-      status: "skipped",
-      reason: "user-proceeded",
-    });
-    expect(submitted).toEqual([]);
-
-    session.ready = true;
-    await coordinator.onSessionStatus(session);
-    expect(submitted).toEqual(["queued while booting"]);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-  });
-
-  it("contains timer persistence rejection with only a bounded local classification", async () => {
-    vi.useFakeTimers();
-    session.ready = false;
-    let rejectWrites = false;
-    const localErrors = vi.spyOn(console, "error").mockImplementation(() => {});
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 100,
-      writeState: async (file, value) => {
-        if (rejectWrites) {
-          throw new Error("/private/customer provider-secret");
-        }
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-      },
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-
-    rejectWrites = true;
-    await vi.advanceTimersByTimeAsync(101);
-    await vi.waitFor(() => {
-      expect(localErrors).toHaveBeenCalledWith(
-        "[harness] planner greeting timeout transition failed: persistence_failed",
-      );
-    });
-
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: true,
-      errorCode: "persistence_failed",
-    });
-    expect(JSON.stringify(localErrors.mock.calls)).not.toContain(
-      "private/customer",
-    );
-    expect(JSON.stringify(localErrors.mock.calls)).not.toContain(
-      "provider-secret",
-    );
-    localErrors.mockRestore();
-  });
-
-  it("keeps a queued planner message out of the PTY when its live dispatch authority is rebound before readiness", async () => {
-    session.ready = false;
-    let authorized = true;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      canDispatch: async () => authorized,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.enqueue(session.id, "private queued plan request");
-    expect(submitted).toEqual([]);
-
-    authorized = false;
-    session.ready = true;
-    await coordinator.onSessionStatus(session);
-
-    expect(submitted).toEqual([]);
-    expect(session.planning?.queuedInputIds).toHaveLength(1);
-  });
-
-  it("does not extend the readiness deadline on live re-registration", async () => {
-    vi.useFakeTimers();
-    session.ready = false;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 100,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await vi.advanceTimersByTimeAsync(60);
-    await coordinator.register(session, { emptyProject: true, mode: "live" });
-    await vi.advanceTimersByTimeAsync(41);
-    await (coordinator as unknown as { writes: Map<string, Promise<unknown>> })
-      .writes.get(session.id);
-
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: true,
-      errorCode: "session_not_ready",
-    });
-  });
-
-  it("classifies an exit from pending and clears stale correlation state", async () => {
-    session.ready = false;
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    session.status = "exited";
-    await coordinator.onSessionStatus(session);
-
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: false,
-      errorCode: "session_exited",
-    });
-    const decorated = coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", {
-        prompt: plannerGreetingPrompt(true),
-      }),
-    );
-    expect(decorated.payload).not.toHaveProperty("plannerOrigin");
-  });
-
-  it("uses unique prompts and FIFO tombstones so a late old turn cannot deliver a retry", async () => {
-    vi.useFakeTimers();
-    const ids = ["attempt-1", "attempt-2"];
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      generateId: () => ids.shift() ?? "state-write",
-      deliveryTimeoutMs: 100,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    const oldPrompt = submitted[0]!;
-    await vi.advanceTimersByTimeAsync(101);
-    await (coordinator as unknown as { writes: Map<string, Promise<unknown>> })
-      .writes.get(session.id);
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: true,
-      errorCode: "delivery_timeout",
-    });
-
-    await coordinator.retry(session.id);
-    const retryPrompt = submitted[1]!;
-    expect(retryPrompt).not.toBe(oldPrompt);
-    const lateOldPrompt = coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: oldPrompt }),
-    );
-    expect(lateOldPrompt.payload.plannerAttemptId).toBe("attempt-1");
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", {
-        assistantText: "Late answer from the first attempt",
-      }),
-    );
-    expect(session.planning?.greeting).toEqual({
-      status: "generating",
-      attemptId: "attempt-2",
-    });
-
-    const retryEvent = coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: retryPrompt }),
-    );
-    expect(retryEvent.payload.plannerAttemptId).toBe("attempt-2");
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", {
-        assistantText: "What kind of agent architecture should we build?",
-      }),
-    );
-
-    expect(session.planning?.greeting).toEqual({
-      status: "delivered",
-      messageId: "event-turn.completed",
-    });
-  });
-
-  it("pre-registers correlation before submit and removes it on a proven false return", async () => {
-    const holder: { coordinator?: PlannerGreetingCoordinator } = {};
-    const synchronousPrompts: AnalyticsEvent[] = [];
-    manager.submitInput = async (_id, prompt) => {
-      synchronousPrompts.push(
-        holder.coordinator!.decorateLocalEvent(
-          event(session.id, "prompt.submitted", { prompt }),
-        ),
-      );
-      return true;
-    };
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      generateId: () => "attempt-synchronous",
-      deliveryTimeoutMs: 60_000,
-    });
-    holder.coordinator = coordinator;
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    expect(synchronousPrompts[0]?.payload.plannerAttemptId).toBe(
-      "attempt-synchronous",
-    );
-
-    session = plannerSession("session-false");
-    manager.submitInput = async () => false;
-    const rejected = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await rejected.register(session, { emptyProject: true, mode: "created" });
-    const decorated = rejected.decorateLocalEvent(
-      event(session.id, "prompt.submitted", {
-        prompt: plannerGreetingPrompt(true),
-      }),
-    );
-
-    expect(decorated.payload).not.toHaveProperty("plannerOrigin");
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: false,
-      errorCode: "session_exited",
-    });
-  });
-
-  it("consumes unmatched prompt completions before the active greeting barrier", async () => {
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      generateId: () => "attempt-1",
-      deliveryTimeoutMs: 60_000,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    const greetingPrompt = submitted[0]!;
-
-    coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: "unmatched user turn" }),
-    );
-    coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: greetingPrompt }),
-    );
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: "user answer" }),
-    );
-    expect(session.planning?.greeting).toEqual({
-      status: "generating",
-      attemptId: "attempt-1",
-    });
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: "greeting answer" }),
-    );
-    expect(session.planning?.greeting.status).toBe("delivered");
-  });
-
-  it("consumes a late completion while failed before a retry begins", async () => {
-    vi.useFakeTimers();
-    const ids = ["attempt-1", "attempt-2"];
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      generateId: () => ids.shift() ?? "state-write",
-      deliveryTimeoutMs: 100,
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: submitted[0]! }),
-    );
-    await vi.advanceTimersByTimeAsync(101);
-    await (coordinator as unknown as { writes: Map<string, Promise<unknown>> })
-      .writes.get(session.id);
-
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: "late old answer" }),
-    );
-    await coordinator.retry(session.id);
-    coordinator.decorateLocalEvent(
-      event(session.id, "prompt.submitted", { prompt: submitted[1]! }),
-    );
-    await coordinator.onEventPersisted(
-      event(session.id, "turn.completed", { assistantText: "retry answer" }),
-    );
-    expect(session.planning?.greeting.status).toBe("delivered");
-  });
-
-  it("quarantines a corrupt queue without preventing local registration", async () => {
-    const dir = path.join(root, session.id);
-    await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(path.join(dir, "input-queue.json"), "{secret-corrupt");
-    session.planning!.queuedInputIds = ["stale-registry-input"];
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-
-    await expect(
-      coordinator.register(session, { emptyProject: true, mode: "boot" }),
-    ).resolves.toBeUndefined();
-    const names = await fs.readdir(dir);
-    expect(names).toContain("input-queue.json");
-    expect(names.some((name) => name.startsWith("input-queue.corrupt-"))).toBe(true);
-    expect(session.planning?.queuedInputIds).toEqual([]);
-  });
-
-  it("durably classifies queue persistence failure without raw error content", async () => {
-    const events: unknown[] = [];
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      writeState: async () => {
-        throw new Error("/private/path provider secret");
-      },
-      onEvent: (value) => {
-        events.push(value);
-      },
-    });
-
-    await expect(
-      coordinator.register(session, { emptyProject: true, mode: "created" }),
-    ).rejects.toThrow("planner state persistence failed");
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: true,
-      errorCode: "persistence_failed",
-    });
-    expect(
-      (
-        coordinator as unknown as {
-          states: Map<string, { metadata: NonNullable<HarnessSession["planning"]> }>;
-        }
-      ).states.get(session.id)?.metadata.greeting,
-    ).toEqual(session.planning?.greeting);
-    await expect(coordinator.retry(session.id)).rejects.toThrow(
-      "planner state persistence failed",
-    );
-    expect(session.planning?.greeting).toEqual({
-      status: "failed",
-      retryable: true,
-      errorCode: "persistence_failed",
-    });
-    expect(JSON.stringify(events)).not.toContain("private/path");
-    expect(JSON.stringify(events)).not.toContain("provider secret");
-  });
-
-  it("emits bounded lifecycle codes without prompts, paths, or provider errors", async () => {
-    const lifecycle: unknown[] = [];
-    manager.submitInput = async () => {
-      throw new Error("provider said /private/customer secret-token");
-    };
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      onEvent: (value) => {
-        lifecycle.push(value);
-      },
-    });
-    await coordinator.register(session, { emptyProject: true, mode: "created" });
-    await coordinator.onSessionStatus(session);
-
-    expect(lifecycle).toEqual([
-      expect.objectContaining({
-        name: "planner_greeting.attempted",
-        projectId: "project-1",
-        sessionId: session.id,
-      }),
-      expect.objectContaining({
-        name: "planner_greeting.failed",
-        errorCode: "injection_failed",
-      }),
-    ]);
-    const serialized = JSON.stringify(lifecycle);
-    expect(serialized).not.toContain("Agent Studio control turn");
-    expect(serialized).not.toContain("/private/customer");
-    expect(serialized).not.toContain("secret-token");
-  });
-});
-
-describe("plannerGreetingPrompt", () => {
-  it("keeps the automatic greeting scoped to collaborative planning and one question", () => {
-    const empty = plannerGreetingPrompt(true);
-    const existing = plannerGreetingPrompt(false);
-    for (const prompt of [empty, existing]) {
-      expect(prompt).toContain("project planning agent");
-      expect(prompt).toContain("agents, responsibilities, data flow, resources, and connectors");
-      expect(prompt).toContain("exactly one open-ended question");
-      expect(prompt).toContain("Do not propose an architecture");
-      expect(prompt).toContain("invoke tools");
-    }
-    expect(empty).toContain(
-      "what kind of agent architecture the user wants to build",
-    );
-    expect(existing).toContain("current plan exists");
-    const attempted = plannerGreetingPrompt(true, "attempt-private-1");
-    expect(attempted).toContain("Internal attempt ID: attempt-private-1");
-    expect(attempted).toContain("Never mention this ID");
-    expect(empty).not.toContain("attempt-private-1");
-  });
-});
diff --git a/packages/harness/src/core/planner-greeting.ts b/packages/harness/src/core/planner-greeting.ts
deleted file mode 100644
index facd4e80c..000000000
--- a/packages/harness/src/core/planner-greeting.ts
+++ /dev/null
@@ -1,1489 +0,0 @@
-import { randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-
-import type {
-  PlannerGreetingErrorCode,
-  PlannerLifecycleEvent,
-  PlannerQueuedInput,
-  PlannerSessionMetadata,
-} from "../shared/agent-map.js";
-import type { AnalyticsEvent, HarnessSession } from "../shared/types.js";
-import {
-  SessionInputGuardRejectedError,
-  SessionManager,
-  SessionNotReadyError,
-} from "./session-manager.js";
-
-interface PersistedPlannerState {
-  schemaVersion: 1;
-  metadata: PlannerSessionMetadata;
-  inputs: PlannerQueuedInput[];
-  /**
-   * Durable write-ahead intent for the one FIFO head that may be crossing the
-   * PTY boundary. An unresolved intent is never replayed automatically after a
-   * restart because the process cannot prove whether the PTY accepted it.
-   */
-  dispatchingInputId: string | null;
-  retryCount: number;
-  emptyProject: boolean;
-}
-
-interface AcceptedInputLedger {
-  schemaVersion: 1;
-  inputIds: string[];
-}
-
-interface ExpectedPrompt {
-  kind: "greeting" | "user";
-  id: string;
-  text: string;
-  /** A failed/timed-out greeting stays as a FIFO tombstone so a late hook
-   * cannot be mistaken for a later retry. */
-  retired?: boolean;
-}
-
-interface ObservedGreetingAttempt {
-  id: string;
-  retired: boolean;
-}
-
-interface AttemptTimer {
-  key: "pending" | string;
-  handle: ReturnType<typeof setTimeout>;
-}
-
-export type PlannerRegistrationMode =
-  | "boot"
-  | "created"
-  | "live"
-  | "resumed"
-  | "rehydrated";
-
-export interface PlannerRegistrationContext {
-  emptyProject: boolean;
-  mode: PlannerRegistrationMode;
-}
-
-export interface PlannerGreetingCoordinatorOptions {
-  root: string;
-  sessionManager: SessionManager;
-  now?: () => string;
-  generateId?: () => string;
-  /** Applies both while waiting for readiness and while awaiting a model turn. */
-  deliveryTimeoutMs?: number;
-  /** Test seam for classifying queue-store failures without exposing raw errors. */
-  writeState?: (file: string, state: unknown) => Promise<void>;
-  /** Test seam for accepted-ledger cleanup/commit failures. */
-  writeAcceptedLedger?: (file: string, state: unknown) => Promise<void>;
-  /** Test seam for the atomic predecessor-to-successor queue handoff. */
-  moveStateDirectory?: (source: string, target: string) => Promise<void>;
-  /** Live authorization gate checked immediately before every PTY dispatch. */
-  canDispatch?: (session: HarnessSession) => boolean | Promise<boolean>;
-  onEvent?: (event: PlannerLifecycleEvent) => Promise<void> | void;
-}
-
-export class PlannerGreetingRetryUnavailableError extends Error {
-  readonly code = "greeting_retry_unavailable";
-
-  constructor() {
-    super("greeting retry is not available");
-    this.name = "PlannerGreetingRetryUnavailableError";
-  }
-}
-
-export class PlannerDispatchForbiddenError extends Error {
-  readonly code = "planner_dispatch_forbidden";
-
-  constructor() {
-    super("planner session is no longer authorized for this project binding");
-    this.name = "PlannerDispatchForbiddenError";
-  }
-}
-
-const MAX_RETRIES = 2;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isTerminal(metadata: PlannerSessionMetadata): boolean {
-  return (
-    metadata.greeting.status === "delivered" ||
-    metadata.greeting.status === "skipped"
-  );
-}
-
-function isPersistedPlannerState(
-  value: unknown,
-  session: HarnessSession,
-): value is PersistedPlannerState {
-  if (!isRecord(value) || value.schemaVersion !== 1 || !session.planning) {
-    return false;
-  }
-  const metadata = value.metadata;
-  if (!isRecord(metadata) || !isRecord(metadata.identity)) return false;
-  const expected = session.planning.identity;
-  if (
-    metadata.identity.role !== "map-planner" ||
-    metadata.identity.sessionId !== expected.sessionId ||
-    metadata.identity.projectId !== expected.projectId ||
-    metadata.identity.userId !== expected.userId ||
-    !Array.isArray(metadata.queuedInputIds) ||
-    !metadata.queuedInputIds.every((id) => typeof id === "string") ||
-    !isRecord(metadata.greeting) ||
-    typeof metadata.greeting.status !== "string" ||
-    !["pending", "generating", "delivered", "failed", "skipped"].includes(
-      metadata.greeting.status,
-    ) ||
-    !Array.isArray(value.inputs) ||
-    (value.dispatchingInputId !== undefined &&
-      value.dispatchingInputId !== null &&
-      typeof value.dispatchingInputId !== "string") ||
-    !Number.isSafeInteger(value.retryCount) ||
-    (value.retryCount as number) < 0 ||
-    (value.retryCount as number) > MAX_RETRIES ||
-    typeof value.emptyProject !== "boolean"
-  ) {
-    return false;
-  }
-  const inputs = value.inputs;
-  if (
-    !inputs.every(
-      (input) =>
-        isRecord(input) &&
-        typeof input.id === "string" &&
-        input.id !== "" &&
-        input.sessionId === session.id &&
-        typeof input.text === "string" &&
-        input.text.length <= 100_000 &&
-        typeof input.acceptedAt === "string",
-    ) ||
-    metadata.queuedInputIds.length !== inputs.length ||
-    metadata.queuedInputIds.some(
-      (id, index) => id !== (inputs[index] as Record<string, unknown>).id,
-    ) ||
-    (typeof value.dispatchingInputId === "string" &&
-      value.dispatchingInputId !==
-        (inputs[0] as Record<string, unknown> | undefined)?.id)
-  ) {
-    return false;
-  }
-  const greeting = metadata.greeting;
-  switch (greeting.status) {
-    case "pending":
-      return true;
-    case "generating":
-      return typeof greeting.attemptId === "string" && greeting.attemptId !== "";
-    case "delivered":
-      return typeof greeting.messageId === "string" && greeting.messageId !== "";
-    case "failed":
-      return (
-        typeof greeting.retryable === "boolean" &&
-        typeof greeting.errorCode === "string" &&
-        [
-          "session_not_ready",
-          "session_exited",
-          "injection_failed",
-          "model_turn_failed",
-          "delivery_timeout",
-          "persistence_failed",
-        ].includes(greeting.errorCode)
-      );
-    case "skipped":
-      return greeting.reason === "user-proceeded";
-    default:
-      return false;
-  }
-}
-
-/** A directory rename can commit before the successor rewrites the embedded
- * session identity. The trusted `rehydratedFrom` link is the recovery marker:
- * accept only an otherwise-valid predecessor state with the same scoped
- * project/user/role, then re-key every identity-bearing field in memory. */
-function adoptRehydratedState(
-  value: unknown,
-  session: HarnessSession,
-): PersistedPlannerState | null {
-  if (!session.planning || !session.rehydratedFrom) return null;
-  const predecessorId = session.rehydratedFrom;
-  const predecessor: HarnessSession = {
-    ...session,
-    id: predecessorId,
-    planning: {
-      ...structuredClone(session.planning),
-      identity: {
-        ...structuredClone(session.planning.identity),
-        sessionId: predecessorId,
-      },
-    },
-  };
-  if (!isPersistedPlannerState(value, predecessor)) return null;
-  return {
-    ...structuredClone(value),
-    metadata: {
-      ...structuredClone(value.metadata),
-      identity: structuredClone(session.planning.identity),
-    },
-    inputs: value.inputs.map((input) => ({
-      ...structuredClone(input),
-      sessionId: session.id,
-    })),
-    dispatchingInputId: value.dispatchingInputId ?? null,
-  };
-}
-
-export function plannerGreetingPrompt(
-  emptyProject: boolean,
-  attemptId?: string,
-): string {
-  const question = emptyProject
-    ? "Ask exactly one open-ended question about what kind of agent architecture the user wants to build."
-    : "Briefly acknowledge that a current plan exists, then ask exactly one open-ended question about what the user wants to review, extend, or change.";
-  return [
-    "This is a private Agent Studio control turn.",
-    "Respond as the project planning agent with one brief greeting.",
-    "Explain that you and the user will plan the agents, responsibilities, data flow, resources, and connectors together.",
-    question,
-    "Do not propose an architecture, create nodes or relationships, invoke tools, or ask a second question before the user replies.",
-    ...(attemptId
-      ? [`Internal attempt ID: ${attemptId}. Never mention this ID in your response.`]
-      : []),
-  ].join(" ");
-}
-
-const PLANNER_SESSION_SOURCES = new Set([
-  "startup",
-  "resume",
-  "clear",
-  "compact",
-  "codex",
-]);
-const MAX_TELEMETRY_TOKEN_COUNT = 1_000_000_000_000;
-
-function telemetrySource(value: unknown): string {
-  return typeof value === "string" && PLANNER_SESSION_SOURCES.has(value)
-    ? value
-    : "unknown";
-}
-
-function telemetryTokenCount(value: unknown): number | null {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
-    return null;
-  }
-  return Math.min(Math.trunc(value), MAX_TELEMETRY_TOKEN_COUNT);
-}
-
-function telemetryUsage(value: unknown): Record<string, number | null> | null {
-  if (!isRecord(value)) return null;
-  const inputTokens = telemetryTokenCount(value.inputTokens);
-  const outputTokens = telemetryTokenCount(value.outputTokens);
-  if (inputTokens === null && outputTokens === null) return null;
-  return { inputTokens, outputTokens };
-}
-
-function telemetryPayload(event: AnalyticsEvent): Record<string, unknown> {
-  switch (event.type) {
-    case "session.start":
-      return { source: telemetrySource(event.payload.source), planner: true };
-    case "prompt.submitted":
-      return {
-        planner: true,
-        origin: event.payload.plannerOrigin ?? "user",
-        ...(typeof event.payload.plannerInputId === "string"
-          ? { plannerInputId: event.payload.plannerInputId }
-          : {}),
-        ...(typeof event.payload.plannerAttemptId === "string"
-          ? { plannerAttemptId: event.payload.plannerAttemptId }
-          : {}),
-      };
-    case "tool.call":
-      return { planner: true, toolObserved: true };
-    case "turn.completed":
-      return {
-        planner: true,
-        hasAssistantText:
-          typeof event.payload.assistantText === "string" &&
-          event.payload.assistantText.length > 0,
-        // Provider/model text is never remotely projected. Even a syntactically
-        // plausible model identifier is an attacker-controlled covert channel.
-        modelReported:
-          typeof event.payload.model === "string" &&
-          event.payload.model.length > 0,
-        usage: telemetryUsage(event.payload.usage),
-      };
-    default:
-      return { planner: true };
-  }
-}
-
-export class PlannerGreetingCoordinator {
-  private readonly root: string;
-  private readonly now: () => string;
-  private readonly generateId: () => string;
-  private readonly deliveryTimeoutMs: number;
-  private readonly states = new Map<string, PersistedPlannerState>();
-  private readonly writes = new Map<string, Promise<unknown>>();
-  private readonly expected = new Map<string, ExpectedPrompt[]>();
-  private readonly observedAttempts = new Map<
-    string,
-    Array<ObservedGreetingAttempt | null>
-  >();
-  private readonly correlationOverflow = new Set<string>();
-  private readonly timers = new Map<string, AttemptTimer>();
-  /** Status hooks can race a freshly spawned PTY ahead of register/handoff. */
-  private readonly registeredSessions = new Set<string>();
-  /** A successfully handed-off predecessor can never dispatch or mutate its
-   * retired FIFO again, even if a late status/hook callback arrives. */
-  private readonly retiredSessions = new Set<string>();
-  /** Successors loaded after a crash between the atomic directory move and
-   * the best-effort embedded-identity rewrite. */
-  private readonly adoptedSessions = new Set<string>();
-
-  constructor(private readonly options: PlannerGreetingCoordinatorOptions) {
-    this.root = path.resolve(options.root);
-    this.now = options.now ?? (() => new Date().toISOString());
-    this.generateId = options.generateId ?? randomUUID;
-    this.deliveryTimeoutMs = options.deliveryTimeoutMs ?? 45_000;
-  }
-
-  private sessionDirectory(sessionId: string): string {
-    const directory = path.resolve(this.root, sessionId);
-    const rootPrefix = `${this.root}${path.sep}`;
-    if (!directory.startsWith(rootPrefix)) {
-      throw new Error("invalid planner session storage identity");
-    }
-    return directory;
-  }
-
-  private file(sessionId: string): string {
-    return path.join(this.sessionDirectory(sessionId), "input-queue.json");
-  }
-
-  private acceptedFile(sessionId: string): string {
-    return path.join(this.sessionDirectory(sessionId), "accepted-inputs.json");
-  }
-
-  private emit(event: PlannerLifecycleEvent): void {
-    try {
-      void Promise.resolve(this.options.onEvent?.(event)).catch(() => {});
-    } catch {
-      // Telemetry is best effort and must never change planner semantics.
-    }
-  }
-
-  private async canDispatch(session: HarnessSession): Promise<boolean> {
-    try {
-      return (await this.options.canDispatch?.(session)) ?? true;
-    } catch {
-      return false;
-    }
-  }
-
-  private serialize<T>(sessionId: string, operation: () => Promise<T>): Promise<T> {
-    const prior = this.writes.get(sessionId) ?? Promise.resolve();
-    const next = prior.catch(() => {}).then(operation);
-    this.writes.set(sessionId, next);
-    void next.then(
-      () => {
-        if (this.writes.get(sessionId) === next) this.writes.delete(sessionId);
-      },
-      () => {
-        if (this.writes.get(sessionId) === next) this.writes.delete(sessionId);
-      },
-    );
-    return next;
-  }
-
-  private newState(
-    session: HarnessSession,
-    emptyProject: boolean,
-  ): PersistedPlannerState {
-    if (!session.planning) throw new Error("planner metadata missing");
-    return {
-      schemaVersion: 1,
-      metadata: {
-        ...structuredClone(session.planning),
-        // The queue file owns FIFO membership. If that file is missing or was
-        // quarantined, stale registry IDs cannot resurrect content we no
-        // longer possess or make the replacement state invalid on next boot.
-        queuedInputIds: [],
-      },
-      inputs: [],
-      dispatchingInputId: null,
-      retryCount: 0,
-      emptyProject,
-    };
-  }
-
-  private async quarantine(sessionId: string): Promise<void> {
-    const file = this.file(sessionId);
-    const quarantine = path.join(
-      path.dirname(file),
-      `input-queue.corrupt-${this.now().replace(/[^0-9A-Za-z]/g, "-")}-${randomUUID()}.json`,
-    );
-    await fs.rename(file, quarantine).catch(() => {});
-  }
-
-  private async load(
-    session: HarnessSession,
-    emptyProject = true,
-  ): Promise<PersistedPlannerState> {
-    const cached = this.states.get(session.id);
-    // Every transition works on an isolated snapshot. Nothing may mutate the
-    // authoritative cache until persist() commits the primary queue file.
-    if (cached) return structuredClone(cached);
-    let state: PersistedPlannerState;
-    try {
-      const parsed: unknown = JSON.parse(
-        await fs.readFile(this.file(session.id), "utf8"),
-      );
-      if (isPersistedPlannerState(parsed, session)) {
-        state = {
-          ...parsed,
-          // Backward-compatible with queue files written by the first SAP-3055
-          // review head before dispatch intent became explicit.
-          dispatchingInputId: parsed.dispatchingInputId ?? null,
-        };
-      } else {
-        const adopted = adoptRehydratedState(parsed, session);
-        if (!adopted) throw new Error("invalid planner state");
-        state = adopted;
-        this.adoptedSessions.add(session.id);
-      }
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        // A single damaged or unreadable session queue is local corruption,
-        // never a reason to prevent the rest of the harness from booting.
-        await this.quarantine(session.id);
-      }
-      state = this.newState(session, emptyProject);
-    }
-    this.states.set(session.id, structuredClone(state));
-    return state;
-  }
-
-  private async writeState(file: string, state: PersistedPlannerState): Promise<void> {
-    if (this.options.writeState) {
-      await this.options.writeState(file, structuredClone(state));
-      return;
-    }
-    await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-    const tmp = `${file}.tmp-${process.pid}-${randomUUID()}`;
-    await fs.writeFile(tmp, JSON.stringify(state, null, 2) + "\n", {
-      encoding: "utf8",
-      mode: 0o600,
-    });
-    await fs.rename(tmp, file);
-  }
-
-  private async acceptedInputIds(
-    sessionId: string,
-  ): Promise<Set<string> | null> {
-    const file = this.acceptedFile(sessionId);
-    try {
-      const decoded: unknown = JSON.parse(await fs.readFile(file, "utf8"));
-      if (
-        !isRecord(decoded) ||
-        decoded.schemaVersion !== 1 ||
-        !Array.isArray(decoded.inputIds) ||
-        !decoded.inputIds.every(
-          (inputId) => typeof inputId === "string" && inputId !== "",
-        )
-      ) {
-        throw new Error("invalid accepted-input ledger");
-      }
-      return new Set(decoded.inputIds);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") return new Set();
-      // An unreadable acknowledgement is safety-significant. Keep the queue's
-      // write-ahead intent unresolved instead of guessing and replaying it.
-      const quarantine = path.join(
-        path.dirname(file),
-        `accepted-inputs.corrupt-${this.now().replace(/[^0-9A-Za-z]/g, "-")}-${randomUUID()}.json`,
-      );
-      await fs.rename(file, quarantine).catch(() => {});
-      return null;
-    }
-  }
-
-  private async writeAcceptedInputIds(
-    sessionId: string,
-    inputIds: readonly string[],
-  ): Promise<void> {
-    const file = this.acceptedFile(sessionId);
-    const temporary = `${file}.tmp-${process.pid}-${randomUUID()}`;
-    const ledger: AcceptedInputLedger = {
-      schemaVersion: 1,
-      inputIds: [...inputIds],
-    };
-    if (this.options.writeAcceptedLedger) {
-      await this.options.writeAcceptedLedger(file, structuredClone(ledger));
-      return;
-    }
-    try {
-      await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
-      await fs.writeFile(temporary, `${JSON.stringify(ledger, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-      await fs.rename(temporary, file);
-    } finally {
-      await fs.rm(temporary, { force: true }).catch(() => {});
-    }
-  }
-
-  private async recordAcceptedInput(
-    state: PersistedPlannerState,
-    inputId: string,
-  ): Promise<void> {
-    const sessionId = state.metadata.identity.sessionId;
-    const accepted = await this.acceptedInputIds(sessionId);
-    if (accepted === null) {
-      throw new Error("planner input acceptance ledger unavailable");
-    }
-    // IDs whose queue entries were already durably removed are stale cleanup
-    // residue and can be compacted. The active FIFO is bounded by the request
-    // body limit, and only its IDs are retained here (never input content).
-    const queuedIds = new Set(state.inputs.map((input) => input.id));
-    const retained = [...accepted].filter((id) => queuedIds.has(id));
-    if (!retained.includes(inputId)) retained.push(inputId);
-    await this.writeAcceptedInputIds(sessionId, retained);
-  }
-
-  private async reconcileAcceptedInputs(
-    state: PersistedPlannerState,
-  ): Promise<PersistedPlannerState> {
-    const sessionId = state.metadata.identity.sessionId;
-    const accepted = await this.acceptedInputIds(sessionId);
-    if (accepted === null || accepted.size === 0) return state;
-    const remaining = state.inputs.filter((input) => !accepted.has(input.id));
-    if (remaining.length === state.inputs.length) return state;
-    const reconciled: PersistedPlannerState = {
-      ...structuredClone(state),
-      inputs: remaining,
-      dispatchingInputId:
-        state.dispatchingInputId && accepted.has(state.dispatchingInputId)
-          ? null
-          : state.dispatchingInputId,
-      metadata: {
-        ...structuredClone(state.metadata),
-        queuedInputIds: remaining.map((input) => input.id),
-      },
-    };
-    await this.persist(sessionId, reconciled);
-    // The queue commit is now authoritative. Ledger cleanup is best effort:
-    // stale accepted IDs are harmless and are compacted on the next accept.
-    await this.writeAcceptedInputIds(
-      sessionId,
-      [...accepted].filter((id) => remaining.some((input) => input.id === id)),
-    ).catch(() => {});
-    return reconciled;
-  }
-
-  private async resolveUncertainDispatch(
-    state: PersistedPlannerState,
-  ): Promise<PersistedPlannerState> {
-    const inputId = state.dispatchingInputId;
-    if (inputId === null || state.inputs[0]?.id !== inputId) return state;
-    const remaining = state.inputs.slice(1);
-    const resolved: PersistedPlannerState = {
-      ...structuredClone(state),
-      inputs: remaining,
-      dispatchingInputId: null,
-      metadata: {
-        ...structuredClone(state.metadata),
-        queuedInputIds: remaining.map((input) => input.id),
-      },
-    };
-    await this.persist(state.metadata.identity.sessionId, resolved);
-    this.emit({
-      name: "planner_session.input_delivery_uncertain",
-      projectId: state.metadata.identity.projectId,
-      sessionId: state.metadata.identity.sessionId,
-      inputId,
-      errorCode: "delivery_uncertain",
-      queueDepth: remaining.length,
-    });
-    // There was no readable acceptance proof for this ID. Any stale ledger is
-    // cleanup residue or was quarantined; reset it after the queue resolution.
-    await this.writeAcceptedInputIds(
-      state.metadata.identity.sessionId,
-      [],
-    ).catch(() => {});
-    return resolved;
-  }
-
-  private clearTimer(sessionId: string, key?: string): void {
-    const timer = this.timers.get(sessionId);
-    if (!timer || (key !== undefined && timer.key !== key)) return;
-    clearTimeout(timer.handle);
-    this.timers.delete(sessionId);
-  }
-
-  private armTimer(sessionId: string, key: "pending" | string): void {
-    if (this.timers.get(sessionId)?.key === key) return;
-    this.clearTimer(sessionId);
-    const handle = setTimeout(() => {
-      void this.fail(
-        sessionId,
-        key,
-        key === "pending" ? "session_not_ready" : "delivery_timeout",
-        true,
-      ).catch(() => {
-        // Timer callbacks have no request boundary to receive a rejection.
-        // persist() already projects/emits `persistence_failed` wherever one
-        // durable store remains; log only a fixed local classification here,
-        // never the provider/storage error or planner content.
-        console.error(
-          "[harness] planner greeting timeout transition failed: persistence_failed",
-        );
-      });
-    }, this.deliveryTimeoutMs);
-    handle.unref?.();
-    this.timers.set(sessionId, { key, handle });
-  }
-
-  private retireAttemptCorrelation(sessionId: string, attemptId: string): void {
-    const expected = this.expected.get(sessionId);
-    if (expected) {
-      this.expected.set(
-        sessionId,
-        expected.map((entry) =>
-          entry.kind === "greeting" && entry.id === attemptId
-            ? { ...entry, retired: true }
-            : entry,
-        ),
-      );
-    }
-    const observed = this.observedAttempts.get(sessionId);
-    if (observed) {
-      this.observedAttempts.set(
-        sessionId,
-        observed.map((entry) =>
-          entry?.id === attemptId ? { ...entry, retired: true } : entry,
-        ),
-      );
-    }
-  }
-
-  private removeExpectedGreeting(sessionId: string, attemptId: string): void {
-    const expected = this.expected.get(sessionId);
-    if (!expected) return;
-    const remaining = expected.filter(
-      (entry) => !(entry.kind === "greeting" && entry.id === attemptId),
-    );
-    if (remaining.length === 0) this.expected.delete(sessionId);
-    else this.expected.set(sessionId, remaining);
-  }
-
-  private clearCorrelation(sessionId: string): void {
-    this.expected.delete(sessionId);
-    this.observedAttempts.delete(sessionId);
-    this.correlationOverflow.delete(sessionId);
-  }
-
-  private async persist(
-    sessionId: string,
-    state: PersistedPlannerState,
-  ): Promise<void> {
-    try {
-      await this.writeState(this.file(sessionId), state);
-    } catch {
-      if (!isTerminal(state.metadata)) {
-        const attemptId =
-          state.metadata.greeting.status === "generating"
-            ? state.metadata.greeting.attemptId
-            : undefined;
-        this.clearTimer(sessionId);
-        state.metadata.greeting = {
-          status: "failed",
-          retryable: true,
-          errorCode: "persistence_failed",
-        };
-        // At least one of the two stores may still be available. Keep the
-        // bounded classification wherever possible; never persist raw errors.
-        let fallbackCommitted = false;
-        try {
-          await this.options.sessionManager.setPlanningMetadata(
-            sessionId,
-            state.metadata,
-          );
-          fallbackCommitted = true;
-        } catch {
-          // The primary queue fallback below may still retain the bounded
-          // terminal classification.
-        }
-        try {
-          await this.writeState(this.file(sessionId), state);
-          fallbackCommitted = true;
-        } catch {
-          // If sessions.json committed, mergeRegistration treats that terminal
-          // projection as authoritative on restart. Only a total two-store
-          // outage retains the last committed cache.
-        }
-        if (fallbackCommitted) this.states.set(sessionId, structuredClone(state));
-        this.emit({
-          name: "planner_greeting.failed",
-          projectId: state.metadata.identity.projectId,
-          sessionId,
-          ...(attemptId ? { attemptId } : {}),
-          errorCode: "persistence_failed",
-          retryable: true,
-          queueDepth: state.inputs.length,
-        });
-      }
-      throw new Error("planner state persistence failed");
-    }
-
-    // The queue file contains the full coordinator state and is authoritative.
-    // Publish its clone only after that primary write commits: a transient
-    // failure before this point must not leave a phantom dispatch intent in
-    // memory. SessionManager's sessions.json metadata is a UI/list projection,
-    // not a second commit prerequisite. If that projection write fails after
-    // the queue commit, aborting here would strand a durable pre-PTY intent
-    // that restart must conservatively drop even though submitInput was never
-    // called. Keep dispatch moving and retry the projection on every later
-    // transition/registration instead.
-    this.states.set(sessionId, structuredClone(state));
-    await this.options.sessionManager
-      .setPlanningMetadata(sessionId, state.metadata)
-      .catch(() => {});
-  }
-
-  /**
-   * Merge the two durable stores under a single serialized registration CAS.
-   * Queue-file inputs are authoritative. A terminal manager greeting is newer
-   * than a non-terminal queue greeting (resume suppression), while a terminal
-   * queue greeting is newer than a stale non-terminal manager snapshot.
-   */
-  private mergeRegistration(
-    state: PersistedPlannerState,
-    session: HarnessSession,
-  ): void {
-    if (!session.planning) return;
-    const managerTerminal = isTerminal(session.planning);
-    const queueTerminal = isTerminal(state.metadata);
-    if (managerTerminal && !queueTerminal) {
-      state.metadata.greeting = structuredClone(session.planning.greeting);
-    }
-    state.metadata.queuedInputIds = state.inputs.map((input) => input.id);
-  }
-
-  private async retireHandoffPredecessor(
-    predecessor: HarnessSession,
-    source?: PersistedPlannerState,
-  ): Promise<void> {
-    const predecessorId = predecessor.id;
-    const retired: PersistedPlannerState | undefined = source
-      ? {
-          ...structuredClone(source),
-          inputs: [],
-          dispatchingInputId: null,
-          metadata: {
-            ...structuredClone(source.metadata),
-            queuedInputIds: [],
-          },
-        }
-      : undefined;
-    if (retired) this.states.set(predecessorId, retired);
-    const metadata =
-      retired?.metadata ??
-      (predecessor.planning
-        ? { ...structuredClone(predecessor.planning), queuedInputIds: [] }
-        : undefined);
-    if (metadata) {
-      await this.options.sessionManager
-        .setPlanningMetadata(predecessorId, metadata)
-        .catch(() => {});
-    }
-    this.clearTimer(predecessorId);
-    this.clearCorrelation(predecessorId);
-    this.registeredSessions.delete(predecessorId);
-    this.retiredSessions.add(predecessorId);
-  }
-
-  /** Atomically move a predecessor's entire coordinator directory into its
-   * rehydrated replacement. There is never a point with two durable FIFO
-   * copies: before rename only the predecessor exists; after rename only the
-   * exact successor exists. The embedded identity rewrite is best effort and
-   * recoverable through `adoptRehydratedState` after a crash. Accepted entries
-   * are removed and unresolved dispatch intent is classified uncertain before
-   * the move, so neither can become replayable under the successor. */
-  private async handoffRehydratedInputs(
-    session: HarnessSession,
-    replacementState: PersistedPlannerState,
-  ): Promise<{ state: PersistedPlannerState; moved: boolean }> {
-    const predecessorId = session.rehydratedFrom;
-    if (!predecessorId || predecessorId === session.id) {
-      return { state: replacementState, moved: false };
-    }
-    const predecessor = this.options.sessionManager.get(predecessorId);
-    const sourceIdentity = predecessor?.planning?.identity;
-    const targetIdentity = session.planning?.identity;
-    if (
-      !predecessor ||
-      !sourceIdentity ||
-      !targetIdentity ||
-      sourceIdentity.role !== "map-planner" ||
-      targetIdentity.role !== "map-planner" ||
-      sourceIdentity.projectId !== targetIdentity.projectId ||
-      sourceIdentity.userId !== targetIdentity.userId
-    ) {
-      return { state: replacementState, moved: false };
-    }
-
-    return this.serialize(predecessorId, async () => {
-      // A canonical or adoptable target file proves a prior atomic move
-      // already committed. On a later boot the old HarnessSession may register
-      // first and recreate an empty source queue; never rename that directory
-      // over the authoritative target. A non-empty second source is an
-      // impossible/conflicting dual owner and fails closed.
-      try {
-        await fs.access(this.file(session.id));
-        let recreatedSource: PersistedPlannerState | undefined;
-        try {
-          await fs.access(this.file(predecessorId));
-          recreatedSource = await this.load(predecessor);
-          recreatedSource = await this.reconcileAcceptedInputs(recreatedSource);
-          if (recreatedSource.dispatchingInputId !== null) {
-            recreatedSource = await this.resolveUncertainDispatch(recreatedSource);
-          }
-          if (recreatedSource.inputs.length > 0) {
-            throw new Error("conflicting planner handoff queues");
-          }
-        } catch (error) {
-          if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-        }
-        await this.retireHandoffPredecessor(predecessor, recreatedSource);
-        return { state: replacementState, moved: true };
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-      }
-
-      try {
-        await fs.access(this.file(predecessorId));
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-          return {
-            state: replacementState,
-            moved: this.adoptedSessions.has(session.id),
-          };
-        }
-        throw error;
-      }
-      let source = await this.load(predecessor);
-      source = await this.reconcileAcceptedInputs(source);
-      if (source.dispatchingInputId !== null) {
-        source = await this.resolveUncertainDispatch(source);
-      }
-
-      const transferred = source.inputs.map((input) => ({
-        ...structuredClone(input),
-        sessionId: session.id,
-      }));
-      const transferredIds = new Set(transferred.map((input) => input.id));
-      const mergedInputs = [
-        ...transferred,
-        ...replacementState.inputs.filter(
-          (input) => !transferredIds.has(input.id),
-        ),
-      ];
-      const replacement: PersistedPlannerState = {
-        ...structuredClone(source),
-        inputs: mergedInputs,
-        dispatchingInputId: null,
-        metadata: {
-          ...structuredClone(source.metadata),
-          identity: structuredClone(targetIdentity),
-          queuedInputIds: mergedInputs.map((input) => input.id),
-        },
-      };
-      const sourceDirectory = path.dirname(this.file(predecessorId));
-      const targetDirectory = path.dirname(this.file(session.id));
-      const move = this.options.moveStateDirectory ?? fs.rename;
-      await move(sourceDirectory, targetDirectory);
-
-      // The rename above is the only ownership commit. Publish the re-keyed
-      // cache immediately; rewriting the moved file is merely canonicalization
-      // because a crash can always adopt its predecessor identity in place.
-      this.states.set(session.id, structuredClone(replacement));
-      this.states.delete(predecessorId);
-      try {
-        await this.writeState(this.file(session.id), replacement);
-        this.adoptedSessions.delete(session.id);
-      } catch {
-        this.adoptedSessions.add(session.id);
-      }
-      await this.writeAcceptedInputIds(session.id, []).catch(() => {});
-
-      await this.retireHandoffPredecessor(predecessor, source);
-      return { state: replacement, moved: true };
-    });
-  }
-
-  async register(
-    session: HarnessSession,
-    context: PlannerRegistrationContext,
-  ): Promise<void> {
-    if (!session.planning) return;
-    let shouldStart = false;
-    let shouldDrain = false;
-    await this.serialize(session.id, async () => {
-      const cached = this.states.has(session.id);
-      let state = await this.load(session, context.emptyProject);
-      let handoffMoved = false;
-      // A crash can occur after the replacement queue commit but before the
-      // predecessor retirement commit. `rehydratedFrom` is persisted on the
-      // HarnessSession, so repeat this idempotent handoff during process boot
-      // as well as the original rehydration callback.
-      if (session.rehydratedFrom) {
-        const handoff = await this.handoffRehydratedInputs(session, state);
-        state = handoff.state;
-        handoffMoved = handoff.moved;
-      }
-      this.mergeRegistration(state, session);
-
-      // Only a process-boot load proves an in-flight dispatch was abandoned.
-      // Live re-registration is idempotent and must not fail its active turn.
-      if (
-        context.mode === "boot" &&
-        !cached &&
-        state.metadata.greeting.status === "generating"
-      ) {
-        const attemptId = state.metadata.greeting.attemptId;
-        state.metadata.greeting = state.inputs.length
-          ? { status: "skipped", reason: "user-proceeded" }
-          : {
-              status: "failed",
-              retryable: true,
-              errorCode: "delivery_timeout",
-            };
-        if (state.inputs.length) {
-          this.emit({
-            name: "planner_greeting.skipped",
-            projectId: state.metadata.identity.projectId,
-            sessionId: session.id,
-            attemptId,
-            reason: "user-proceeded",
-            queueDepth: state.inputs.length,
-          });
-        } else {
-          this.emit({
-            name: "planner_greeting.failed",
-            projectId: state.metadata.identity.projectId,
-            sessionId: session.id,
-            attemptId,
-            errorCode: "delivery_timeout",
-            retryable: true,
-            queueDepth: 0,
-          });
-        }
-      }
-      if (handoffMoved) {
-        // The directory rename already durably committed FIFO ownership. A
-        // failed canonical rewrite must not reject the exact successor and let
-        // a later open mint a second owner; future pre-PTY transitions retry
-        // the normal authoritative queue write.
-        this.states.set(session.id, structuredClone(state));
-        try {
-          await this.writeState(this.file(session.id), state);
-          this.adoptedSessions.delete(session.id);
-        } catch {
-          this.adoptedSessions.add(session.id);
-        }
-        await this.options.sessionManager
-          .setPlanningMetadata(session.id, state.metadata)
-          .catch(() => {});
-      } else {
-        await this.persist(session.id, state);
-      }
-      this.registeredSessions.add(session.id);
-      if (state.metadata.greeting.status === "pending") {
-        const allowed = await this.canDispatch(session);
-        if (
-          session.ready &&
-          session.status === "running" &&
-          allowed
-        ) shouldStart = true;
-        else if (allowed) this.armTimer(session.id, "pending");
-      } else if (isTerminal(state.metadata)) {
-        shouldDrain =
-          session.ready &&
-          session.status === "running" &&
-          (await this.canDispatch(session));
-      }
-    });
-    if (shouldStart) await this.startGreeting(session.id, false);
-    else if (shouldDrain) await this.drainSession(session.id);
-  }
-
-  async onSessionStatus(session: HarnessSession): Promise<void> {
-    if (!session.planning) return;
-    if (
-      !this.registeredSessions.has(session.id) ||
-      this.retiredSessions.has(session.id)
-    ) return;
-    if (
-      session.ready &&
-      session.status === "running" &&
-      (await this.canDispatch(session))
-    ) {
-      this.clearTimer(session.id, "pending");
-      const state = this.states.get(session.id);
-      if (state && isTerminal(state.metadata)) await this.drainSession(session.id);
-      else await this.startGreeting(session.id, false);
-      return;
-    }
-    if (session.status === "exited") {
-      const timer = this.timers.get(session.id);
-      this.clearTimer(session.id);
-      this.expected.delete(session.id);
-      this.observedAttempts.delete(session.id);
-      this.correlationOverflow.delete(session.id);
-      await this.fail(
-        session.id,
-        timer?.key ?? "pending",
-        "session_exited",
-        false,
-      );
-    }
-  }
-
-  private async startGreeting(sessionId: string, retry: boolean): Promise<void> {
-    await this.serialize(sessionId, async () => {
-      if (this.retiredSessions.has(sessionId)) return;
-      const session = this.options.sessionManager.get(sessionId);
-      if (!session?.planning) return;
-      const state = await this.load(session);
-      if (!(await this.canDispatch(session))) {
-        if (retry) throw new PlannerDispatchForbiddenError();
-        if (state.metadata.greeting.status === "pending") {
-          await this.setFailure(state, "pending", "session_exited", false);
-        }
-        return;
-      }
-      if (retry) {
-        if (
-          state.metadata.greeting.status !== "failed" ||
-          !state.metadata.greeting.retryable ||
-          state.inputs.length > 0 ||
-          state.retryCount >= MAX_RETRIES
-        ) {
-          throw new PlannerGreetingRetryUnavailableError();
-        }
-        state.retryCount += 1;
-      } else if (state.metadata.greeting.status !== "pending") {
-        return;
-      }
-      this.clearTimer(sessionId, "pending");
-      const attemptId = this.generateId();
-      state.metadata.greeting = { status: "generating", attemptId };
-      await this.persist(sessionId, state);
-      this.emit({
-        name: retry ? "planner_greeting.retried" : "planner_greeting.attempted",
-        projectId: state.metadata.identity.projectId,
-        sessionId,
-        attemptId,
-        queueDepth: state.inputs.length,
-      });
-      const prompt = plannerGreetingPrompt(state.emptyProject, attemptId);
-      if (!(await this.canDispatch(session))) {
-        await this.setFailure(state, attemptId, "session_exited", false);
-        if (retry) throw new PlannerDispatchForbiddenError();
-        return;
-      }
-      // Register before crossing the PTY boundary. A prompt hook may arrive
-      // immediately after the write, before submitInput's delayed Enter has
-      // resolved; registering afterward loses the only safe correlation.
-      const queue = this.expected.get(sessionId) ?? [];
-      queue.push({
-        kind: "greeting",
-        id: attemptId,
-        text: prompt,
-        retired: false,
-      });
-      this.expected.set(sessionId, queue);
-      try {
-        const accepted = await this.options.sessionManager.submitInput(
-          sessionId,
-          prompt,
-          true,
-          () => this.canDispatch(session),
-        );
-        if (!accepted) {
-          // A false return proves the prompt did not cross the PTY boundary.
-          this.removeExpectedGreeting(sessionId, attemptId);
-          await this.setFailure(state, attemptId, "session_exited", false);
-          return;
-        }
-        this.armTimer(sessionId, attemptId);
-      } catch (error) {
-        if (
-          error instanceof SessionNotReadyError ||
-          (error instanceof SessionInputGuardRejectedError && !error.staged)
-        ) {
-          // Both cases prove absence at the PTY boundary. A guard rejection
-          // after staging is intentionally retained/retired as uncertain.
-          this.removeExpectedGreeting(sessionId, attemptId);
-        }
-        await this.setFailure(
-          state,
-          attemptId,
-          error instanceof SessionNotReadyError
-            ? "session_not_ready"
-            : error instanceof SessionInputGuardRejectedError
-              ? "session_exited"
-              : "injection_failed",
-          !(error instanceof SessionInputGuardRejectedError),
-        );
-        if (retry && error instanceof SessionInputGuardRejectedError) {
-          throw new PlannerDispatchForbiddenError();
-        }
-      }
-    });
-  }
-
-  private async setFailure(
-    state: PersistedPlannerState,
-    expectedKey: "pending" | string,
-    errorCode: PlannerGreetingErrorCode,
-    retryable: boolean,
-  ): Promise<void> {
-    const greeting = state.metadata.greeting;
-    const matches =
-      (expectedKey === "pending" && greeting.status === "pending") ||
-      (greeting.status === "generating" && greeting.attemptId === expectedKey);
-    if (!matches) return;
-    const sessionId = state.metadata.identity.sessionId;
-    const attemptId = greeting.status === "generating" ? greeting.attemptId : undefined;
-    this.clearTimer(sessionId, expectedKey);
-    if (attemptId) this.retireAttemptCorrelation(sessionId, attemptId);
-    if (state.inputs.length > 0) {
-      state.metadata.greeting = { status: "skipped", reason: "user-proceeded" };
-      await this.persist(sessionId, state);
-      this.clearCorrelation(sessionId);
-      this.emit({
-        name: "planner_greeting.skipped",
-        projectId: state.metadata.identity.projectId,
-        sessionId,
-        ...(attemptId ? { attemptId } : {}),
-        reason: "user-proceeded",
-        queueDepth: state.inputs.length,
-      });
-      await this.drain(state);
-      return;
-    }
-    state.metadata.greeting = { status: "failed", retryable, errorCode };
-    await this.persist(sessionId, state);
-    if (!retryable) this.clearCorrelation(sessionId);
-    this.emit({
-      name: "planner_greeting.failed",
-      projectId: state.metadata.identity.projectId,
-      sessionId,
-      ...(attemptId ? { attemptId } : {}),
-      errorCode,
-      retryable,
-      queueDepth: 0,
-    });
-  }
-
-  private async fail(
-    sessionId: string,
-    expectedKey: "pending" | string,
-    errorCode: PlannerGreetingErrorCode,
-    retryable: boolean,
-  ): Promise<void> {
-    await this.serialize(sessionId, async () => {
-      if (this.retiredSessions.has(sessionId)) return;
-      const session = this.options.sessionManager.get(sessionId);
-      if (!session?.planning) return;
-      const state = await this.load(session);
-      await this.setFailure(state, expectedKey, errorCode, retryable);
-    });
-  }
-
-  retry(sessionId: string): Promise<void> {
-    return this.startGreeting(sessionId, true);
-  }
-
-  async enqueue(sessionId: string, text: string): Promise<PlannerSessionMetadata> {
-    return this.serialize(sessionId, async () => {
-      if (this.retiredSessions.has(sessionId)) {
-        throw new PlannerDispatchForbiddenError();
-      }
-      const session = this.options.sessionManager.get(sessionId);
-      if (!session?.planning) throw new Error("planner session not found");
-      if (!(await this.canDispatch(session))) {
-        throw new PlannerDispatchForbiddenError();
-      }
-      const state = await this.load(session);
-      const input: PlannerQueuedInput = {
-        id: this.generateId(),
-        sessionId,
-        text,
-        acceptedAt: this.now(),
-      };
-      state.inputs.push(input);
-      state.metadata.queuedInputIds.push(input.id);
-      if (state.metadata.greeting.status === "failed") {
-        state.metadata.greeting = { status: "skipped", reason: "user-proceeded" };
-        this.emit({
-          name: "planner_greeting.skipped",
-          projectId: state.metadata.identity.projectId,
-          sessionId,
-          reason: "user-proceeded",
-          queueDepth: state.inputs.length,
-        });
-      }
-      await this.persist(sessionId, state);
-      if (isTerminal(state.metadata)) await this.drain(state, true);
-      // drain() advances through immutable queue-state clones. Return the
-      // latest authoritative projection rather than the pre-drain object so a
-      // 202 response never reports IDs that were already durably dequeued.
-      return structuredClone(this.states.get(sessionId)?.metadata ?? state.metadata);
-    });
-  }
-
-  private async drainSession(sessionId: string): Promise<void> {
-    await this.serialize(sessionId, async () => {
-      if (this.retiredSessions.has(sessionId)) return;
-      const session = this.options.sessionManager.get(sessionId);
-      if (!session?.planning) return;
-      const state = await this.load(session);
-      if (isTerminal(state.metadata)) await this.drain(state);
-    });
-  }
-
-  private async drain(
-    initialState: PersistedPlannerState,
-    throwOnForbidden = false,
-  ): Promise<void> {
-    let state: PersistedPlannerState;
-    try {
-      // An accepted-input ledger is the commit/ack boundary. If the prior
-      // process reached the PTY but failed to rewrite the FIFO, finish that
-      // dequeue without submitting the prompt again.
-      state = await this.reconcileAcceptedInputs(initialState);
-    } catch {
-      return;
-    }
-    while (state.inputs.length > 0) {
-      const input = state.inputs[0]!;
-      const session = this.options.sessionManager.get(input.sessionId);
-      if (
-        !session?.ready ||
-        session.status !== "running"
-      ) return;
-      if (!(await this.canDispatch(session))) {
-        if (throwOnForbidden) throw new PlannerDispatchForbiddenError();
-        return;
-      }
-
-      // A durable intent without a durable acceptance acknowledgement is
-      // irreducibly ambiguous across a crash. Never guess by replaying it: a
-      // later accepted ledger can complete the dequeue, while automatic replay
-      // could duplicate a user message already written to the PTY.
-      if (state.dispatchingInputId !== null) {
-        try {
-          state = await this.resolveUncertainDispatch(state);
-        } catch {
-          return;
-        }
-        continue;
-      }
-
-      const prepared: PersistedPlannerState = {
-        ...structuredClone(state),
-        dispatchingInputId: input.id,
-      };
-      try {
-        await this.persist(input.sessionId, prepared);
-      } catch {
-        // No external side effect occurred before the intent commit.
-        return;
-      }
-      state = prepared;
-      if (!(await this.canDispatch(session))) {
-        const rollback: PersistedPlannerState = {
-          ...structuredClone(state),
-          dispatchingInputId: null,
-        };
-        await this.persist(input.sessionId, rollback).catch(() => {});
-        if (throwOnForbidden) throw new PlannerDispatchForbiddenError();
-        return;
-      }
-      let accepted = false;
-      try {
-        accepted = await this.options.sessionManager.submitInput(
-          input.sessionId,
-          input.text,
-          true,
-          () => this.canDispatch(session),
-        );
-      } catch (error) {
-        const rollback: PersistedPlannerState = {
-          ...structuredClone(state),
-          dispatchingInputId: null,
-        };
-        await this.persist(input.sessionId, rollback).catch(() => {});
-        if (
-          throwOnForbidden &&
-          error instanceof SessionInputGuardRejectedError
-        ) {
-          throw new PlannerDispatchForbiddenError();
-        }
-        return;
-      }
-      if (!accepted) {
-        const rollback: PersistedPlannerState = {
-          ...structuredClone(state),
-          dispatchingInputId: null,
-        };
-        await this.persist(input.sessionId, rollback).catch(() => {});
-        return;
-      }
-      // Register local correlation only after acceptance. The accepted ledger
-      // then commits the external side effect before the FIFO is rewritten.
-      const queue = this.expected.get(input.sessionId) ?? [];
-      queue.push({ kind: "user", id: input.id, text: input.text });
-      this.expected.set(input.sessionId, queue);
-      try {
-        await this.recordAcceptedInput(state, input.id);
-      } catch {
-        // The durable intent remains unresolved and will not be replayed after
-        // restart. True PTY exactly-once is impossible without this ack.
-        return;
-      }
-
-      const committed: PersistedPlannerState = {
-        ...structuredClone(state),
-        inputs: state.inputs.slice(1),
-        dispatchingInputId: null,
-        metadata: {
-          ...structuredClone(state.metadata),
-          queuedInputIds: state.metadata.queuedInputIds.slice(1),
-        },
-      };
-      try {
-        await this.persist(input.sessionId, committed);
-      } catch {
-        // The accepted ledger is durable. A restart will finish this exact
-        // dequeue without submitting the input twice.
-        return;
-      }
-      state = committed;
-      await this.writeAcceptedInputIds(input.sessionId, []).catch(() => {});
-    }
-  }
-
-  /** Add local-only correlation without removing transcript content. */
-  decorateLocalEvent(event: AnalyticsEvent): AnalyticsEvent {
-    if (this.retiredSessions.has(event.harnessSessionId)) return event;
-    const session = this.options.sessionManager.get(event.harnessSessionId);
-    if (!session?.planning || event.type !== "prompt.submitted") return event;
-    const prompt = typeof event.payload.prompt === "string" ? event.payload.prompt : "";
-    const queue = this.expected.get(event.harnessSessionId) ?? [];
-    const index = queue.findIndex((entry) => entry.text === prompt);
-    const [match] = index < 0 ? [] : queue.splice(index, 1);
-    if (queue.length === 0) this.expected.delete(event.harnessSessionId);
-    const observed = this.observedAttempts.get(event.harnessSessionId) ?? [];
-    // One barrier per observed planner prompt, including unmatched/user
-    // prompts. turn.completed has no attempt token, so skipping those barriers
-    // would let their completion shift a later greeting attempt instead.
-    if (observed.length >= 256) {
-      this.clearCorrelation(event.harnessSessionId);
-      this.correlationOverflow.add(event.harnessSessionId);
-    } else {
-      observed.push(
-        match?.kind === "greeting"
-          ? { id: match.id, retired: match.retired === true }
-          : null,
-      );
-      this.observedAttempts.set(event.harnessSessionId, observed);
-    }
-    if (!match) return event;
-    return {
-      ...event,
-      payload: {
-        ...event.payload,
-        plannerOrigin: match.kind === "greeting" ? "infrastructure" : "user",
-        ...(match.kind === "greeting"
-          ? { plannerAttemptId: match.id }
-          : { plannerInputId: match.id }),
-      },
-    };
-  }
-
-  /** Product telemetry receives no planning content, paths, or provider text. */
-  redactForTelemetry(event: AnalyticsEvent): AnalyticsEvent {
-    const session = this.options.sessionManager.get(event.harnessSessionId);
-    return session?.planning
-      ? {
-          ...event,
-          // The normalized hook envelope is attacker-controlled too: every
-          // hook can supply `payload.session_id`. The harness session ID is the
-          // server-owned planner correlation key, so provider identity is not
-          // needed in remote planner telemetry at all.
-          agentSessionId: null,
-          payload: telemetryPayload(event),
-        }
-      : event;
-  }
-
-  async onEventPersisted(event: AnalyticsEvent): Promise<void> {
-    if (event.type !== "turn.completed") return;
-    await this.serialize(event.harnessSessionId, async () => {
-      if (this.retiredSessions.has(event.harnessSessionId)) return;
-      // Consume exactly one prompt barrier for every completion before looking
-      // at lifecycle state. In particular, a late completion while attempt 1
-      // is failed must not remain queued to satisfy a later retry.
-      const observed = this.observedAttempts.get(event.harnessSessionId);
-      const completedAttempt = observed?.shift();
-      if (observed?.length === 0) {
-        this.observedAttempts.delete(event.harnessSessionId);
-      }
-      const session = this.options.sessionManager.get(event.harnessSessionId);
-      if (!session?.planning) return;
-      const state = await this.load(session);
-      if (this.correlationOverflow.delete(event.harnessSessionId)) {
-        if (state.metadata.greeting.status === "generating") {
-          await this.setFailure(
-            state,
-            state.metadata.greeting.attemptId,
-            "model_turn_failed",
-            true,
-          );
-        }
-        return;
-      }
-      if (state.metadata.greeting.status !== "generating") return;
-      const attemptId = state.metadata.greeting.attemptId;
-      if (!completedAttempt) return;
-      // Stop/turn.completed carries no attempt token. Consume correlations in
-      // prompt-observation order: a retired older turn is a tombstone, never
-      // evidence that the currently generating retry completed.
-      if (completedAttempt.retired || completedAttempt.id !== attemptId) return;
-      const text = event.payload.assistantText;
-      if (typeof text !== "string" || text.trim() === "") {
-        await this.setFailure(state, attemptId, "model_turn_failed", true);
-        return;
-      }
-      this.clearTimer(event.harnessSessionId, attemptId);
-      state.metadata.greeting = {
-        status: "delivered",
-        messageId: event.eventId,
-      };
-      await this.persist(event.harnessSessionId, state);
-      this.clearCorrelation(event.harnessSessionId);
-      this.emit({
-        name: "planner_greeting.delivered",
-        projectId: state.metadata.identity.projectId,
-        sessionId: event.harnessSessionId,
-        attemptId,
-        queueDepth: state.inputs.length,
-      });
-      await this.drain(state);
-    });
-  }
-}
diff --git a/packages/harness/src/core/planning-session.test.ts b/packages/harness/src/core/planning-session.test.ts
deleted file mode 100644
index 1bc804a56..000000000
--- a/packages/harness/src/core/planning-session.test.ts
+++ /dev/null
@@ -1,817 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-
-import { describe, expect, it, vi } from "vitest";
-
-import { AGENT_MAP_PLANNER_SESSION_START_MESSAGE } from "../profiles/agent-map-planner.js";
-import type { AgentMapWorkspaceState } from "../shared/agent-map.js";
-import type { HarnessSession, SessionRecord } from "../shared/types.js";
-import type { AgentMapWorkspaceStore } from "./agent-map-workspace-store.js";
-import {
-  buildFocusedPlannerContext,
-  isPlannerDispatchAuthorized,
-  localPlanningPrincipal,
-  PlanningSessionError,
-  PlanningSessionService,
-} from "./planning-session.js";
-import type { SessionManager } from "./session-manager.js";
-import { PlannerGreetingCoordinator } from "./planner-greeting.js";
-import type {
-  StudioProjectCatalog,
-  StudioProjectIdentity,
-} from "./studio-project-catalog.js";
-
-const projectId = "project_00000000-0000-4000-8000-000000000001";
-
-const project: StudioProjectIdentity = {
-  projectId,
-  identityVersion: 1,
-  displayName: "Private research",
-  rootBindings: [
-    {
-      id: "root_00000000-0000-4000-8000-000000000001",
-      repositoryId: "repo-private",
-      localRootRef: "/Users/private/customer-secret-project",
-      status: "active",
-    },
-  ],
-  legacyWorkspaceKeys: ["private-workspace-key"],
-  createdAt: "2026-09-01T00:00:00.000Z",
-  updatedAt: "2026-09-01T00:00:00.000Z",
-};
-
-const workspace: AgentMapWorkspaceState = {
-  projectId,
-  schemaVersion: 1,
-  recordVersion: 1,
-  confirmedRevisionId: null,
-  activeProposalId: null,
-  projectBuildPlanId: null,
-  createdAt: "2026-09-01T00:00:00.000Z",
-  updatedAt: "2026-09-01T00:00:00.000Z",
-};
-
-function session(
-  id: string,
-  overrides: Partial<HarnessSession> = {},
-): HarnessSession {
-  return {
-    id,
-    agentSessionId: null,
-    harness: "codex",
-    cwd: project.rootBindings[0]!.localRootRef,
-    title: "Private research",
-    status: "running",
-    createdAt: "2026-09-01T00:00:00.000Z",
-    lastActiveAt: "2026-09-01T00:00:00.000Z",
-    exitCode: null,
-    boundWorkflowPath: null,
-    ready: false,
-    planning: {
-      identity: { projectId, sessionId: id, userId: "user-1", role: "map-planner" },
-      greeting: { status: "pending" },
-      queuedInputIds: [],
-    },
-    ...overrides,
-  };
-}
-
-function fixture(
-  existing: HarnessSession[] = [],
-  initialProject: StudioProjectIdentity = project,
-  initialWorkspace: AgentMapWorkspaceState = workspace,
-) {
-  let next = 0;
-  let resolvedProject = initialProject;
-  let currentUserId: string | null = "user-1";
-  const contexts: string[] = [];
-  const sessionStartMessages: Array<string | null> = [];
-  const created: HarnessSession[] = [];
-  const create = vi.fn(async (request, trusted) => {
-    const id = `new-${++next}`;
-    contexts.push(trusted.promptAppendix(id));
-    sessionStartMessages.push(trusted.sessionStartSystemMessage?.(id) ?? null);
-    const value = session(id, {
-      harness: request.harness,
-      cwd: request.cwd,
-      planning: trusted.planning(id),
-      rehydratedFrom:
-        trusted.handoffFromSessionId ?? request.rehydrateFrom ?? null,
-    });
-    created.push(value);
-    return value;
-  });
-  const resume = vi.fn(async (id, trusted) => {
-    const value = existing.find((candidate) => candidate.id === id)!;
-    value.planning = structuredClone(trusted.planning);
-    contexts.push(trusted.promptAppendix);
-    return value;
-  });
-  const kill = vi.fn(async (id: string) => {
-    const value = [...existing, ...created].find(
-      (candidate) => candidate.id === id,
-    );
-    if (value) value.status = "exited";
-    return Boolean(value);
-  });
-  const manager = {
-    create,
-    resume,
-    list: () => [...existing, ...created],
-    isLive: (id: string) =>
-      [...existing, ...created].some(
-        (candidate) => candidate.id === id && candidate.status === "running",
-      ),
-    get: (id: string) => [...existing, ...created].find((candidate) => candidate.id === id),
-    setPlanningMetadata: async (
-      id: string,
-      metadata: NonNullable<HarnessSession["planning"]>,
-    ) => {
-      const value = [...existing, ...created].find((candidate) => candidate.id === id);
-      if (value) value.planning = structuredClone(metadata);
-    },
-    submitInput: vi.fn(async () => true),
-    kill,
-  } as unknown as SessionManager;
-  const service = new PlanningSessionService({
-    catalog: {
-      resolveIdentity: async (id: string) =>
-        id === projectId ? resolvedProject : null,
-    } as unknown as StudioProjectCatalog,
-    workspaceStore: {
-      readOrCreate: async () => initialWorkspace,
-    } as unknown as AgentMapWorkspaceStore,
-    sessionManager: manager,
-    readRecord: async () => null,
-    userId: "user-1",
-    currentUserId: () => currentUserId,
-    machineId: "machine-1",
-    defaultHarness: "codex",
-  });
-  return {
-    service,
-    create,
-    resume,
-    kill,
-    contexts,
-    sessionStartMessages,
-    manager,
-    created,
-    setProject: (value: StudioProjectIdentity) => {
-      resolvedProject = value;
-    },
-    setUserId: (value: string | null) => {
-      currentUserId = value;
-    },
-  };
-}
-
-describe("planner session context and identity", () => {
-  it("uses the authenticated user or a stable machine-local principal", () => {
-    expect(localPlanningPrincipal("user-1", "machine-1")).toBe("user-1");
-    expect(localPlanningPrincipal(null, "machine-1")).toBe("local:machine-1");
-  });
-
-  it("serializes only allowlisted focused context and never a local path", () => {
-    const context = buildFocusedPlannerContext({
-      project,
-      workspace,
-      sessionId: "session-1",
-      userId: "user-1",
-      onboardOnFirstResponse: true,
-    });
-    expect(context).toContain(projectId);
-    expect(context).toContain(project.rootBindings[0]!.id);
-    expect(context).not.toContain('"role"');
-    expect(context).toContain('"empty":true');
-    expect(context).not.toContain("In your first response, briefly explain");
-    expect(context).not.toContain("/Users/private");
-    expect(context).not.toContain("private-workspace-key");
-    expect(context).not.toContain("localRootRef");
-
-    expect(context.length).toBeLessThan(16_384);
-  });
-
-  it("bounds revision summaries, proposal/build status, and warnings", () => {
-    const populated: AgentMapWorkspaceState = {
-      ...workspace,
-      confirmedRevisionId: "revision-1",
-      activeProposalId: "proposal-1",
-      projectBuildPlanId: "build-plan-1",
-    };
-    const context = buildFocusedPlannerContext({
-      project,
-      workspace: populated,
-      sessionId: "session-1",
-      userId: "user-1",
-      onboardOnFirstResponse: false,
-      details: {
-        confirmedRevision: {
-          digest: "d".repeat(2_000),
-          summaries: Array.from({ length: 80 }, (_, index) =>
-            `node-${index}-${"s".repeat(400)}`,
-          ),
-        },
-        activeProposal: { status: "draft", summary: "proposal summary" },
-        projectBuildPlan: { status: "pending", summary: "build summary" },
-        warnings: Array.from({ length: 40 }, (_, index) => `warning-${index}`),
-      },
-    });
-    const parsed = JSON.parse(context.split("\n")[2]!) as {
-      project: {
-        confirmedRevision: { digest: string; summaries: string[] };
-        activeProposal: { status: string };
-        projectBuildPlan: { status: string };
-        warnings: string[];
-      };
-    };
-
-    expect(parsed.project.confirmedRevision.digest).toHaveLength(512);
-    expect(parsed.project.confirmedRevision.summaries).toHaveLength(32);
-    expect(parsed.project.confirmedRevision.summaries[0]!.length).toBeLessThanOrEqual(256);
-    expect(parsed.project.activeProposal.status).toBe("draft");
-    expect(parsed.project.projectBuildPlan.status).toBe("pending");
-    expect(parsed.project.warnings).toHaveLength(16);
-    expect(context.length).toBeLessThan(16_384);
-    expect(context).not.toContain(project.rootBindings[0]!.localRootRef);
-  });
-
-  it("rechecks the live principal after an awaited dispatch binding lookup", async () => {
-    let userId = "user-1";
-    let resolveProject!: (value: StudioProjectIdentity | null) => void;
-    const authorization = isPlannerDispatchAuthorized({
-      session: session("planner-dispatch"),
-      currentPrincipal: () => userId,
-      resolveProject: () =>
-        new Promise((resolve) => {
-          resolveProject = resolve;
-        }),
-    });
-
-    await Promise.resolve();
-    userId = "user-b";
-    resolveProject(project);
-
-    await expect(authorization).resolves.toBe(false);
-  });
-});
-
-describe("PlanningSessionService", () => {
-  it("always creates a new, server-scoped planner for explicit fresh", async () => {
-    const { service, create, contexts, sessionStartMessages } = fixture();
-    const first = await service.open(projectId, { mode: "fresh" });
-    const second = await service.open(projectId, { mode: "fresh" });
-
-    expect(first.resolution).toBe("created");
-    expect(second.session.id).not.toBe(first.session.id);
-    expect(create).toHaveBeenCalledTimes(2);
-    expect(first.session.planning).toEqual({
-      identity: {
-        projectId,
-        sessionId: first.session.id,
-        userId: "user-1",
-        role: "map-planner",
-      },
-      greeting: { status: "skipped", reason: "user-proceeded" },
-      queuedInputIds: [],
-    });
-    expect(contexts.every((value) => !value.includes(project.rootBindings[0]!.localRootRef))).toBe(true);
-    expect(contexts).toEqual([
-      expect.stringContaining(
-        "This is bounded, server-derived Studio project context.",
-      ),
-      expect.stringContaining(
-        "This is bounded, server-derived Studio project context.",
-      ),
-    ]);
-    expect(contexts.join("\n")).not.toContain(
-      "This is a private Agent Studio control turn",
-    );
-    expect(sessionStartMessages).toEqual([null, null]);
-  });
-
-  it("uses native Claude startup orientation without repeating it in turn one", async () => {
-    const { service, contexts, sessionStartMessages } = fixture();
-
-    await service.open(projectId, {
-      mode: "fresh",
-      harness: "claude-code",
-    });
-
-    expect(sessionStartMessages).toEqual([
-      AGENT_MAP_PLANNER_SESSION_START_MESSAGE,
-    ]);
-    expect(contexts[0]).not.toContain(
-      "In your first response, briefly explain",
-    );
-  });
-
-  it("does not replay first-time onboarding for an already-planned project", async () => {
-    const { service, contexts } = fixture([], project, {
-      ...workspace,
-      confirmedRevisionId: "revision-1",
-    });
-
-    await service.open(projectId, { mode: "fresh" });
-
-    expect(contexts[0]).not.toContain(
-      "In your first response, briefly explain",
-    );
-  });
-
-  it("serializes concurrent resume-or-create so both callers resolve one planner", async () => {
-    const { service, create } = fixture();
-    const [first, second] = await Promise.all([
-      service.open(projectId, { mode: "resume-or-create" }),
-      service.open(projectId, { mode: "resume-or-create" }),
-    ]);
-
-    expect(create).toHaveBeenCalledTimes(1);
-    expect(first).toMatchObject({ resolution: "created" });
-    expect(second).toMatchObject({
-      resolution: "live",
-      session: { id: first.session.id },
-    });
-  });
-
-  it("keeps the latest live owned session and rejects cross-project replay", async () => {
-    const older = session("older", {
-      lastActiveAt: "2026-09-01T01:00:00.000Z",
-    });
-    const latest = session("latest", {
-      lastActiveAt: "2026-09-01T02:00:00.000Z",
-    });
-    const { service, create } = fixture([older, latest]);
-
-    await expect(
-      service.open(projectId, { mode: "resume-or-create" }),
-    ).resolves.toMatchObject({ resolution: "live", session: { id: "latest" } });
-    expect(create).not.toHaveBeenCalled();
-    await expect(
-      service.requireOwned("other-project", latest.id),
-    ).rejects.toThrow(PlanningSessionError);
-  });
-
-  it("accepts a planner on any current active root, not only the launch root", async () => {
-    const multiRoot: StudioProjectIdentity = {
-      ...project,
-      rootBindings: [
-        ...project.rootBindings,
-        {
-          id: "root_00000000-0000-4000-8000-000000000002",
-          repositoryId: "repo-secondary",
-          localRootRef: "/Users/private/secondary-root",
-          status: "active",
-        },
-      ],
-    };
-    const secondary = session("secondary", {
-      cwd: "/Users/private/secondary-root",
-    });
-    const { service, create } = fixture([secondary], multiRoot);
-
-    await expect(
-      service.open(projectId, { mode: "resume-or-create" }),
-    ).resolves.toMatchObject({ resolution: "live", session: { id: secondary.id } });
-    await expect(service.requireOwned(projectId, secondary.id)).resolves.toBe(
-      secondary,
-    );
-    expect(create).not.toHaveBeenCalled();
-  });
-
-  it("never returns or resumes a stale-root candidate after a move and rehydrates at the current root", async () => {
-    const moved: StudioProjectIdentity = {
-      ...project,
-      rootBindings: project.rootBindings.map((binding) => ({
-        ...binding,
-        localRootRef: "/Users/private/moved-project",
-      })),
-    };
-    const stale = session("stale-root", {
-      cwd: project.rootBindings[0]!.localRootRef,
-      status: "running",
-      agentSessionId: "old-vendor",
-    });
-    const { service, resume, create } = fixture([stale], moved);
-    (
-      service as unknown as {
-        options: { readRecord: () => Promise<SessionRecord> };
-      }
-    ).options.readRecord = async () => ({ turnCount: 1 } as SessionRecord);
-
-    const result = await service.open(projectId, {
-      mode: "resume-or-create",
-    });
-
-    expect(result.resolution).toBe("rehydrated");
-    expect(resume).not.toHaveBeenCalled();
-    expect(create).toHaveBeenCalledWith(
-      expect.objectContaining({
-        cwd: "/Users/private/moved-project",
-        rehydrateFrom: stale.id,
-      }),
-      expect.any(Object),
-    );
-  });
-
-  it("re-resolves current bindings for every scoped operation", async () => {
-    const owned = session("owned-root");
-    const { service, setProject } = fixture([owned]);
-    await expect(service.requireOwned(projectId, owned.id)).resolves.toBe(owned);
-
-    setProject({
-      ...project,
-      rootBindings: project.rootBindings.map((binding) => ({
-        ...binding,
-        localRootRef: "/Users/private/moved-project",
-      })),
-    });
-
-    await expect(service.requireOwned(projectId, owned.id)).rejects.toMatchObject({
-      code: "forbidden",
-    });
-  });
-
-  it("isolates planners across authenticated, local, and replacement principals", async () => {
-    const accountA = session("account-a");
-    const { service, setUserId } = fixture([accountA]);
-    await expect(service.requireOwned(projectId, accountA.id)).resolves.toBe(accountA);
-
-    setUserId(null);
-    await expect(service.requireOwned(projectId, accountA.id)).rejects.toMatchObject({
-      code: "forbidden",
-    });
-    const local = await service.open(projectId, { mode: "fresh" });
-    expect(local.session.planning?.identity.userId).toBe("local:machine-1");
-
-    setUserId("user-b");
-    await expect(service.requireOwned(projectId, local.session.id)).rejects.toMatchObject({
-      code: "forbidden",
-    });
-    const accountB = await service.open(projectId, { mode: "fresh" });
-    expect(accountB.session.planning?.identity.userId).toBe("user-b");
-  });
-
-  it("kills a newly created planner if principal or binding changes mid-open", async () => {
-    const principalSwitch = fixture();
-    (
-      principalSwitch.service as unknown as {
-        options: { onPlannerSession: () => void };
-      }
-    ).options.onPlannerSession = () => principalSwitch.setUserId(null);
-    await expect(
-      principalSwitch.service.open(projectId, { mode: "fresh" }),
-    ).rejects.toMatchObject({ code: "forbidden" });
-    expect(principalSwitch.kill).toHaveBeenCalledWith("new-1");
-
-    const bindingSwitch = fixture();
-    (
-      bindingSwitch.service as unknown as {
-        options: { onPlannerSession: () => void };
-      }
-    ).options.onPlannerSession = () =>
-      bindingSwitch.setProject({
-        ...project,
-        rootBindings: project.rootBindings.map((binding) => ({
-          ...binding,
-          localRootRef: "/Users/private/moved-during-open",
-        })),
-      });
-    await expect(
-      bindingSwitch.service.open(projectId, { mode: "fresh" }),
-    ).rejects.toMatchObject({ code: "forbidden" });
-    expect(bindingSwitch.kill).toHaveBeenCalledWith("new-1");
-  });
-
-  it("reattaches focused context and suppresses onboarding on vendor resume", async () => {
-    const prior = session("resume-me", {
-      status: "exited",
-      agentSessionId: "vendor-session",
-    });
-    const { service, resume, contexts } = fixture([prior]);
-
-    const result = await service.open(projectId, { mode: "resume-or-create" });
-
-    expect(result.resolution).toBe("resumed");
-    expect(resume).toHaveBeenCalledTimes(1);
-    expect(result.session.planning?.greeting).toEqual({
-      status: "skipped",
-      reason: "user-proceeded",
-    });
-    expect(contexts[0]).toContain(projectId);
-    expect(contexts[0]).not.toContain(
-      "In your first response, briefly explain",
-    );
-    expect(contexts[0]).not.toContain(project.rootBindings[0]!.localRootRef);
-  });
-
-  it("rehydrates recorded history when vendor resume is unavailable", async () => {
-    const prior = session("recorded", {
-      status: "exited",
-      agentSessionId: "stale-vendor-session",
-    });
-    const { service, resume, create, contexts, sessionStartMessages } = fixture([
-      prior,
-    ]);
-    resume.mockRejectedValueOnce(new Error("not resumable"));
-    (service as unknown as { options: { readRecord: () => Promise<SessionRecord> } }).options.readRecord =
-      async () => ({ turnCount: 1 } as SessionRecord);
-
-    const result = await service.open(projectId, { mode: "resume-or-create" });
-
-    expect(result.resolution).toBe("rehydrated");
-    expect(create).toHaveBeenCalledWith(
-      expect.objectContaining({ rehydrateFrom: prior.id }),
-      expect.any(Object),
-    );
-    expect(result.session.planning?.greeting.status).toBe("skipped");
-    expect(contexts[0]).not.toContain(
-      "In your first response, briefly explain",
-    );
-    expect(sessionStartMessages).toEqual([null]);
-  });
-
-  it("hands a restarted pre-ready FIFO to a rehydrated planner exactly once and retires the old queue", async () => {
-    const prior = session("queued-predecessor", {
-      status: "exited",
-      ready: false,
-      agentSessionId: "missing-vendor-history",
-    });
-    const { service, resume, manager } = fixture([prior]);
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "planner-handoff-"));
-    const beforeRestart = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    await beforeRestart.register(prior, {
-      emptyProject: true,
-      mode: "created",
-    });
-    await beforeRestart.enqueue(prior.id, "queued before readiness");
-
-    // New coordinator instance is the process-restart boundary. Vendor resume
-    // fails, so PlanningSessionService creates a replacement with
-    // rehydratedFrom=prior.id and registration performs the durable handoff.
-    const afterRestart = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    resume.mockRejectedValueOnce(new Error("vendor history unavailable"));
-    const options = (
-      service as unknown as {
-        options: {
-          readRecord: () => Promise<SessionRecord>;
-          onPlannerSession: PlanningSessionService["options"]["onPlannerSession"];
-        };
-      }
-    ).options;
-    options.readRecord = async () => ({ turnCount: 1 } as SessionRecord);
-    options.onPlannerSession = (value, context) =>
-      afterRestart.register(value, context);
-
-    try {
-      const result = await service.open(projectId, {
-        mode: "resume-or-create",
-      });
-      expect(result.resolution).toBe("rehydrated");
-      result.session.ready = true;
-      await afterRestart.onSessionStatus(result.session);
-
-      expect(manager.submitInput).toHaveBeenCalledTimes(1);
-      expect(manager.submitInput).toHaveBeenCalledWith(
-        result.session.id,
-        "queued before readiness",
-        true,
-        expect.any(Function),
-      );
-      const replacementQueue = JSON.parse(
-        await fs.readFile(
-          path.join(root, result.session.id, "input-queue.json"),
-          "utf8",
-        ),
-      ) as { inputs: unknown[] };
-      await expect(
-        fs.access(path.join(root, prior.id, "input-queue.json")),
-      ).rejects.toMatchObject({ code: "ENOENT" });
-      expect(replacementQueue.inputs).toEqual([]);
-
-      // A full later boot registers the historical predecessor first, which
-      // recreates its empty queue file. Registering the successor must detect
-      // its already-committed target directory and never rename the recreated
-      // source over it.
-      const secondBoot = new PlannerGreetingCoordinator({
-        root,
-        sessionManager: manager,
-        deliveryTimeoutMs: 60_000,
-      });
-      await secondBoot.register(prior, { emptyProject: true, mode: "boot" });
-      await expect(
-        secondBoot.register(result.session, {
-          emptyProject: true,
-          mode: "boot",
-        }),
-      ).resolves.toBeUndefined();
-      await secondBoot.onSessionStatus(result.session);
-      expect(manager.submitInput).toHaveBeenCalledTimes(1);
-      const durableAfterSecondBoot = JSON.parse(
-        await fs.readFile(
-          path.join(root, result.session.id, "input-queue.json"),
-          "utf8",
-        ),
-      ) as { inputs: unknown[] };
-      expect(durableAfterSecondBoot.inputs).toEqual([]);
-    } finally {
-      await fs.rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it.each(["atomic-move", "canonical-rewrite"] as const)(
-    "keeps exactly one FIFO successor when the %s boundary fails",
-    async (failurePoint) => {
-      const prior = session("handoff-fault-source", {
-        status: "exited",
-        ready: false,
-        agentSessionId: "missing-vendor-history",
-      });
-      const { service, resume, manager } = fixture([prior]);
-      const root = await fs.mkdtemp(path.join(os.tmpdir(), "planner-handoff-fault-"));
-      const seed = new PlannerGreetingCoordinator({
-        root,
-        sessionManager: manager,
-        deliveryTimeoutMs: 60_000,
-      });
-      await seed.register(prior, { emptyProject: true, mode: "created" });
-      await seed.enqueue(prior.id, "survive handoff fault");
-
-      let rejectMove = failurePoint === "atomic-move";
-      const firstSuccessor = new PlannerGreetingCoordinator({
-        root,
-        sessionManager: manager,
-        deliveryTimeoutMs: 60_000,
-        moveStateDirectory: async (source, target) => {
-          if (rejectMove) {
-            rejectMove = false;
-            throw new Error("injected atomic handoff failure");
-          }
-          await fs.rename(source, target);
-        },
-        ...(failurePoint === "canonical-rewrite"
-          ? {
-              writeState: async (file: string, value: unknown) => {
-                if (file.includes(`${path.sep}new-1${path.sep}`)) {
-                  throw new Error("injected canonical rewrite failure");
-                }
-                await fs.mkdir(path.dirname(file), { recursive: true });
-                await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`);
-              },
-            }
-          : {}),
-      });
-      resume.mockRejectedValue(new Error("vendor history unavailable"));
-      const options = (
-        service as unknown as {
-          options: {
-            readRecord: (id: string) => Promise<SessionRecord | null>;
-            onPlannerSession: PlanningSessionService["options"]["onPlannerSession"];
-          };
-        }
-      ).options;
-      options.readRecord = async (id) =>
-        id === prior.id ? ({ turnCount: 1 } as SessionRecord) : null;
-      options.onPlannerSession = (value, context) =>
-        firstSuccessor.register(value, context);
-
-      try {
-        if (failurePoint === "atomic-move") {
-          await expect(
-            service.open(projectId, { mode: "resume-or-create" }),
-          ).rejects.toThrow("injected atomic handoff failure");
-        } else {
-          const first = await service.open(projectId, {
-            mode: "resume-or-create",
-          });
-          // Exit before readiness. A same-process reopen must follow this exact
-          // queue-owning successor, even though its canonical rewrite failed.
-          await manager.kill(first.session.id);
-        }
-
-        const finalCoordinator = new PlannerGreetingCoordinator({
-          root,
-          sessionManager: manager,
-          deliveryTimeoutMs: 60_000,
-        });
-        options.onPlannerSession = (value, context) =>
-          finalCoordinator.register(value, context);
-        const result = await service.open(projectId, {
-          mode: "resume-or-create",
-        });
-        expect(result).toMatchObject({
-          resolution: "rehydrated",
-          session: {
-            id: "new-2",
-            rehydratedFrom:
-              failurePoint === "canonical-rewrite" ? "new-1" : prior.id,
-          },
-        });
-        expect(result.session.planning?.queuedInputIds).toHaveLength(1);
-        result.session.ready = true;
-        await finalCoordinator.onSessionStatus(result.session);
-
-        expect(manager.submitInput).toHaveBeenCalledTimes(1);
-        expect(manager.submitInput).toHaveBeenCalledWith(
-          result.session.id,
-          "survive handoff fault",
-          true,
-          expect.any(Function),
-        );
-        await expect(
-          fs.access(path.join(root, prior.id, "input-queue.json")),
-        ).rejects.toMatchObject({ code: "ENOENT" });
-        await expect(
-          fs.access(path.join(root, "new-1", "input-queue.json")),
-        ).rejects.toMatchObject({ code: "ENOENT" });
-        const durable = JSON.parse(
-          await fs.readFile(
-            path.join(root, result.session.id, "input-queue.json"),
-            "utf8",
-          ),
-        ) as { inputs: unknown[] };
-        expect(durable.inputs).toEqual([]);
-      } finally {
-        await fs.rm(root, { recursive: true, force: true });
-      }
-    },
-  );
-
-  it("rehydrates a delivered greeting-only record without generating a duplicate", async () => {
-    const prior = session("greeting-only", {
-      status: "exited",
-      agentSessionId: "missing-vendor-history",
-    });
-    prior.planning!.greeting = {
-      status: "delivered",
-      messageId: "greeting-message",
-    };
-    const { service, resume, manager } = fixture([prior]);
-    resume.mockRejectedValueOnce(new Error("vendor history unavailable"));
-    const record: SessionRecord = {
-      harnessSessionId: prior.id,
-      mergedSessionIds: [prior.id],
-      agentSessionId: prior.agentSessionId,
-      harness: prior.harness,
-      cwd: null,
-      startedAt: "2026-09-01T00:00:00.000Z",
-      endedAt: "2026-09-01T00:01:00.000Z",
-      turns: [
-        {
-          index: 1,
-          prompt: null,
-          promptAt: null,
-          toolCalls: [],
-          assistantText: "What system should we plan together?",
-          model: null,
-          usage: null,
-          completedAt: "2026-09-01T00:00:30.000Z",
-          incomplete: false,
-        },
-      ],
-      turnCount: 0,
-      eventCount: 2,
-      reconstructed: true,
-      archivedAt: null,
-      limitations: [],
-    };
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "planner-wired-"));
-    const coordinator = new PlannerGreetingCoordinator({
-      root,
-      sessionManager: manager,
-      deliveryTimeoutMs: 60_000,
-    });
-    const options = (
-      service as unknown as {
-        options: {
-          readRecord: () => Promise<SessionRecord>;
-          onPlannerSession: PlanningSessionService["options"]["onPlannerSession"];
-        };
-      }
-    ).options;
-    options.readRecord = async () => record;
-    options.onPlannerSession = (value, context) =>
-      coordinator.register(value, context);
-
-    try {
-      const result = await service.open(projectId, { mode: "resume-or-create" });
-      expect(result.resolution).toBe("rehydrated");
-      expect(result.session.planning?.greeting).toEqual({
-        status: "delivered",
-        messageId: "greeting-message",
-      });
-      expect(manager.submitInput).not.toHaveBeenCalled();
-    } finally {
-      await fs.rm(root, { recursive: true, force: true });
-    }
-  });
-});
diff --git a/packages/harness/src/core/planning-session.ts b/packages/harness/src/core/planning-session.ts
deleted file mode 100644
index 291ea8ae1..000000000
--- a/packages/harness/src/core/planning-session.ts
+++ /dev/null
@@ -1,551 +0,0 @@
-import { buildFocusedProjectContext } from "./project-session.js";
-import type {
-  AgentMapWorkspaceState,
-  PlannerLifecycleEvent,
-  PlannerGreetingState,
-  PlannerSessionRequest,
-  PlannerSessionResponse,
-  PlannerSessionMetadata,
-  StudioProjectId,
-} from "../shared/agent-map.js";
-import type {
-  CreateSessionRequest,
-  HarnessSession,
-  SessionRecord,
-} from "../shared/types.js";
-import type { AgentMapWorkspaceStore } from "./agent-map-workspace-store.js";
-import type { SessionManager } from "./session-manager.js";
-import type {
-  StudioProjectCatalog,
-  StudioProjectIdentity,
-} from "./studio-project-catalog.js";
-import type { PlannerRegistrationMode } from "./planner-greeting.js";
-import { canonicalGraphPath } from "./canonical-graph-path.js";
-import { AGENT_MAP_PLANNER_SESSION_START_MESSAGE } from "../profiles/agent-map-planner.js";
-
-export interface PlannerFocusedContextDetails {
-  confirmedRevision?: {
-    digest?: string | null;
-    summaries?: readonly string[];
-  } | null;
-  activeProposal?: {
-    status?: string | null;
-    summary?: string | null;
-  } | null;
-  projectBuildPlan?: {
-    status?: string | null;
-    summary?: string | null;
-  } | null;
-  warnings?: readonly string[];
-}
-
-export interface PlanningSessionServiceOptions {
-  catalog: StudioProjectCatalog;
-  workspaceStore: AgentMapWorkspaceStore;
-  sessionManager: SessionManager;
-  readRecord: (id: string) => Promise<SessionRecord | null>;
-  userId: string | null;
-  /** Live authenticated identity. When omitted, `userId` remains the static
-   * principal for tests/embedded callers. */
-  currentUserId?: () => string | null;
-  machineId: string;
-  defaultHarness: CreateSessionRequest["harness"];
-  readFocusedContext?: (
-    projectId: StudioProjectId,
-    workspace: AgentMapWorkspaceState,
-  ) => Promise<PlannerFocusedContextDetails>;
-  onPlannerSession?: (
-    session: HarnessSession,
-    context: { emptyProject: boolean; mode: PlannerRegistrationMode },
-  ) => Promise<void> | void;
-  onEvent?: (event: PlannerLifecycleEvent) => Promise<void> | void;
-}
-
-export class PlanningSessionError extends Error {
-  constructor(
-    readonly code:
-      | "project_not_found"
-      | "project_launch_unavailable"
-      | "session_not_found"
-      | "forbidden",
-  ) {
-    super(code.replace(/_/g, " "));
-    this.name = "PlanningSessionError";
-  }
-}
-
-export function localPlanningPrincipal(
-  userId: string | null,
-  machineId: string,
-): string {
-  return userId ?? `local:${machineId}`;
-}
-
-function launchRoot(project: StudioProjectIdentity): string {
-  const binding = project.rootBindings.find((entry) => entry.status === "active");
-  if (!binding) throw new PlanningSessionError("project_launch_unavailable");
-  return binding.localRootRef;
-}
-
-export function isCurrentProjectRoot(
-  project: StudioProjectIdentity,
-  cwd: string,
-): boolean {
-  const candidate = canonicalGraphPath(cwd);
-  return project.rootBindings.some(
-    (binding) =>
-      binding.status === "active" &&
-      canonicalGraphPath(binding.localRootRef) === candidate,
-  );
-}
-
-export async function isPlannerDispatchAuthorized(input: {
-  session: HarnessSession;
-  currentPrincipal: () => string;
-  resolveProject: (
-    projectId: StudioProjectId,
-  ) => Promise<StudioProjectIdentity | null>;
-}): Promise<boolean> {
-  const identity = input.session.planning?.identity;
-  const expectedPrincipal = input.currentPrincipal();
-  if (!identity || identity.userId !== expectedPrincipal) return false;
-  const project = await input.resolveProject(identity.projectId);
-  return Boolean(
-    project &&
-      input.currentPrincipal() === expectedPrincipal &&
-      isCurrentProjectRoot(project, input.session.cwd),
-  );
-}
-
-function isTerminalGreeting(value: PlannerGreetingState): boolean {
-  return value.status === "delivered" || value.status === "skipped";
-}
-
-function planningFor(
-  projectId: StudioProjectId,
-  sessionId: string,
-  userId: string,
-  greeting: PlannerGreetingState,
-): PlannerSessionMetadata {
-  return {
-    identity: { projectId, sessionId, userId, role: "map-planner" },
-    greeting,
-    queuedInputIds: [],
-  };
-}
-
-export function buildFocusedPlannerContext(input: {
-  project: StudioProjectIdentity;
-  workspace: AgentMapWorkspaceState;
-  sessionId: string;
-  userId: string;
-  onboardOnFirstResponse: boolean;
-  details?: PlannerFocusedContextDetails;
-}): string {
-  // Compatibility for the old startup service; authority and prompt are common.
-  return buildFocusedProjectContext(input);
-}
-
-function candidateOrder(left: HarnessSession, right: HarnessSession): number {
-  const live = (session: HarnessSession): number =>
-    session.status === "exited" ? 0 : 1;
-  const queued = (session: HarnessSession): number =>
-    session.planning?.queuedInputIds.length ? 1 : 0;
-  return (
-    live(right) - live(left) ||
-    queued(right) - queued(left) ||
-    right.lastActiveAt.localeCompare(left.lastActiveAt) ||
-    left.id.localeCompare(right.id)
-  );
-}
-
-function recordSupportsRehydration(
-  record: SessionRecord | null,
-  greeting: PlannerGreetingState,
-): boolean {
-  if (!record) return false;
-  if (record.turnCount > 0) return true;
-  return Boolean(
-    greeting.status === "delivered" &&
-      record.turns?.some(
-        (turn) =>
-          turn.prompt === null &&
-          typeof turn.assistantText === "string" &&
-          turn.assistantText.trim() !== "",
-      ),
-  );
-}
-
-export class PlanningSessionService {
-  private readonly projectOpens = new Map<string, Promise<unknown>>();
-
-  constructor(private readonly options: PlanningSessionServiceOptions) {}
-
-  private currentPrincipal(): string {
-    return localPlanningPrincipal(
-      this.options.currentUserId
-        ? this.options.currentUserId()
-        : this.options.userId,
-      this.options.machineId,
-    );
-  }
-
-  private assertPrincipal(expected: string): void {
-    if (this.currentPrincipal() !== expected) {
-      throw new PlanningSessionError("forbidden");
-    }
-  }
-
-  private emit(event: PlannerLifecycleEvent): void {
-    try {
-      void Promise.resolve(this.options.onEvent?.(event)).catch(() => {});
-    } catch {
-      // Lifecycle telemetry is best effort and content-free.
-    }
-  }
-
-  private async focusedDetails(
-    project: StudioProjectIdentity,
-    workspace: AgentMapWorkspaceState,
-  ): Promise<PlannerFocusedContextDetails | undefined> {
-    try {
-      return await this.options.readFocusedContext?.(
-        project.projectId,
-        workspace,
-      );
-    } catch {
-      return { warnings: ["focused_context_unavailable"] };
-    }
-  }
-
-  owns(
-    session: HarnessSession,
-    projectId: StudioProjectId,
-    principal = this.currentPrincipal(),
-  ): boolean {
-    const identity = session.planning?.identity;
-    return Boolean(
-      identity &&
-        identity.role === "map-planner" &&
-        identity.sessionId === session.id &&
-        identity.projectId === projectId &&
-        identity.userId === principal,
-    );
-  }
-
-  private async project(projectId: StudioProjectId): Promise<StudioProjectIdentity> {
-    const project = await this.options.catalog.resolveIdentity(projectId);
-    if (!project) throw new PlanningSessionError("project_not_found");
-    return project;
-  }
-
-  private async assertRunnable(
-    projectId: StudioProjectId,
-    cwd: string,
-    principal: string,
-  ): Promise<void> {
-    this.assertPrincipal(principal);
-    const current = await this.project(projectId);
-    this.assertPrincipal(principal);
-    if (!isCurrentProjectRoot(current, cwd)) {
-      throw new PlanningSessionError("forbidden");
-    }
-  }
-
-  private async create(
-    project: StudioProjectIdentity,
-    request: PlannerSessionRequest,
-    greeting: PlannerGreetingState,
-    rehydrateFrom?: string,
-    mode: "created" | "rehydrated" = "created",
-    principal = this.currentPrincipal(),
-    handoffFromSessionId = rehydrateFrom,
-  ): Promise<HarnessSession> {
-    const workspace = await this.options.workspaceStore.readOrCreate(
-      project.projectId,
-    );
-    const emptyProject =
-      workspace.confirmedRevisionId === null &&
-      workspace.activeProposalId === null &&
-      workspace.projectBuildPlanId === null;
-    const harness = request.harness ?? this.options.defaultHarness;
-    const cwd = launchRoot(project);
-    const details = await this.focusedDetails(project, workspace);
-    const session = await this.options.sessionManager.create(
-      {
-        cwd,
-        harness,
-        ...(request.theme ? { theme: request.theme } : {}),
-        ...(rehydrateFrom ? { rehydrateFrom } : {}),
-      },
-      {
-        planning: (sessionId) =>
-          planningFor(project.projectId, sessionId, principal, greeting),
-        promptAppendix: (sessionId) =>
-          buildFocusedPlannerContext({
-            project,
-            workspace,
-            sessionId,
-            userId: principal,
-            // Claude gets native SessionStart orientation before turn one.
-            // Other CLIs retain the hidden first-response instruction until
-            // they expose an equivalent display-only startup channel.
-            onboardOnFirstResponse:
-              mode === "created" && emptyProject && harness !== "claude-code",
-            ...(details ? { details } : {}),
-          }),
-        ...(mode === "created" && harness === "claude-code"
-          ? {
-              sessionStartSystemMessage: () =>
-                AGENT_MAP_PLANNER_SESSION_START_MESSAGE,
-            }
-          : {}),
-        ...(handoffFromSessionId ? { handoffFromSessionId } : {}),
-      },
-    );
-    if (this.currentPrincipal() !== principal) {
-      // Authentication changed while the process was being spawned. Do not
-      // return a planner minted for the old principal into the new caller's
-      // request; terminate the just-created PTY before failing closed.
-      await this.options.sessionManager.kill(session.id).catch(() => false);
-      throw new PlanningSessionError("forbidden");
-    }
-    this.emit({
-      name: mode === "created" ? "planner_session.created" : "planner_session.resumed",
-      projectId: project.projectId,
-      sessionId: session.id,
-      resolution: mode,
-    });
-    try {
-      await this.options.onPlannerSession?.(session, {
-        emptyProject,
-        mode,
-      });
-      await this.assertRunnable(project.projectId, session.cwd, principal);
-    } catch (error) {
-      await this.options.sessionManager.kill(session.id).catch(() => false);
-      throw error;
-    }
-    return session;
-  }
-
-  private serializeOpen<T>(
-    projectId: StudioProjectId,
-    operation: () => Promise<T>,
-  ): Promise<T> {
-    const prior = this.projectOpens.get(projectId) ?? Promise.resolve();
-    const next = prior.catch(() => {}).then(operation);
-    this.projectOpens.set(projectId, next);
-    const cleanup = (): void => {
-      if (this.projectOpens.get(projectId) === next) {
-        this.projectOpens.delete(projectId);
-      }
-    };
-    void next.then(cleanup, cleanup);
-    return next;
-  }
-
-  private async rehydrationHistorySource(
-    candidate: HarnessSession,
-    projectId: StudioProjectId,
-    principal: string,
-  ): Promise<string | undefined> {
-    const visited = new Set<string>();
-    let current: HarnessSession | undefined = candidate;
-    while (current && !visited.has(current.id) && visited.size < 32) {
-      visited.add(current.id);
-      const record = await this.options.readRecord(current.id).catch(() => null);
-      if (recordSupportsRehydration(record, current.planning!.greeting)) {
-        return current.id;
-      }
-      const predecessorId = current.rehydratedFrom;
-      if (!predecessorId) return undefined;
-      const predecessor = this.options.sessionManager.get(predecessorId);
-      if (!predecessor || !this.owns(predecessor, projectId, principal)) {
-        return undefined;
-      }
-      current = predecessor;
-    }
-    return undefined;
-  }
-
-  open(
-    projectId: StudioProjectId,
-    request: PlannerSessionRequest,
-  ): Promise<PlannerSessionResponse> {
-    return this.serializeOpen(projectId, () =>
-      this.openOnce(projectId, request),
-    );
-  }
-
-  private async openOnce(
-    projectId: StudioProjectId,
-    request: PlannerSessionRequest,
-  ): Promise<PlannerSessionResponse> {
-    const principal = this.currentPrincipal();
-    const project = await this.project(projectId);
-    this.assertPrincipal(principal);
-    // Validate that a launch target exists even when an existing candidate is
-    // reused. Candidate eligibility itself spans every active project root.
-    launchRoot(project);
-    if (request.mode === "fresh") {
-      return {
-        session: await this.create(
-          project,
-          request,
-          // Claude Code has no hidden assistant-first turn. A pending greeting
-          // is dispatched as ordinary PTY input and therefore appears as a
-          // synthetic user message in the raw CLI. Keep onboarding in the
-          // hidden prompt appendix above and let the user's real input lead.
-          { status: "skipped", reason: "user-proceeded" },
-          undefined,
-          "created",
-          principal,
-        ),
-        resolution: "created",
-      };
-    }
-
-    const candidates = this.options.sessionManager
-      .list()
-      .filter((session) => this.owns(session, projectId, principal))
-      .sort(candidateOrder);
-    for (const candidate of candidates) {
-      const atCurrentLaunchRoot = isCurrentProjectRoot(project, candidate.cwd);
-      if (
-        atCurrentLaunchRoot &&
-        this.options.sessionManager.isLive(candidate.id)
-      ) {
-        const workspace = await this.options.workspaceStore.readOrCreate(
-          project.projectId,
-        );
-        this.assertPrincipal(principal);
-        this.emit({
-          name: "planner_session.resumed",
-          projectId,
-          sessionId: candidate.id,
-          resolution: "live",
-        });
-        await this.options.onPlannerSession?.(candidate, {
-          emptyProject:
-            workspace.confirmedRevisionId === null &&
-            workspace.activeProposalId === null &&
-            workspace.projectBuildPlanId === null,
-          mode: "live",
-        });
-        await this.assertRunnable(projectId, candidate.cwd, principal);
-        return { session: candidate, resolution: "live" };
-      }
-      if (atCurrentLaunchRoot && candidate.agentSessionId) {
-        const workspace = await this.options.workspaceStore.readOrCreate(
-          project.projectId,
-        );
-        this.assertPrincipal(principal);
-        const prior = candidate.planning!.greeting;
-        const planning = {
-          ...candidate.planning!,
-          greeting: isTerminalGreeting(prior)
-            ? prior
-            : ({ status: "skipped", reason: "user-proceeded" } as const),
-        };
-        const details = await this.focusedDetails(project, workspace);
-        this.assertPrincipal(principal);
-        const resumed = await this.options.sessionManager
-          .resume(candidate.id, {
-            planning,
-            promptAppendix: buildFocusedPlannerContext({
-              project,
-              workspace,
-              sessionId: candidate.id,
-              userId: principal,
-              onboardOnFirstResponse: false,
-              ...(details ? { details } : {}),
-            }),
-          })
-          .catch(() => null);
-        if (resumed) {
-          if (this.currentPrincipal() !== principal) {
-            await this.options.sessionManager.kill(resumed.id).catch(() => false);
-            throw new PlanningSessionError("forbidden");
-          }
-          this.emit({
-            name: "planner_session.resumed",
-            projectId,
-            sessionId: resumed.id,
-            resolution: "resumed",
-          });
-          try {
-            await this.options.onPlannerSession?.(resumed, {
-              emptyProject:
-                workspace.confirmedRevisionId === null &&
-                workspace.activeProposalId === null &&
-                workspace.projectBuildPlanId === null,
-              mode: "resumed",
-            });
-            await this.assertRunnable(projectId, resumed.cwd, principal);
-          } catch (error) {
-            await this.options.sessionManager.kill(resumed.id).catch(() => false);
-            throw error;
-          }
-          return { session: resumed, resolution: "resumed" };
-        }
-        // A stale vendor record may still be safely rehydrated below.
-      }
-      const prior = candidate.planning!.greeting;
-      // A durable planner FIFO is itself rehydration-worthy even before the
-      // vendor emits history. This keeps a replacement that exits before
-      // readiness as the exact predecessor for the next launch instead of
-      // skipping back to an older record and orphaning its moved queue.
-      const hasQueuedInput = candidate.planning!.queuedInputIds.length > 0;
-      const historySource = await this.rehydrationHistorySource(
-        candidate,
-        projectId,
-        principal,
-      );
-      if (!historySource && !hasQueuedInput) continue;
-      const greeting = isTerminalGreeting(prior)
-        ? prior
-        : ({ status: "skipped", reason: "user-proceeded" } as const);
-      return {
-        session: await this.create(
-          project,
-          { ...request, harness: candidate.harness },
-          greeting,
-          historySource,
-          "rehydrated",
-          principal,
-          candidate.id,
-        ),
-        resolution: "rehydrated",
-      };
-    }
-
-    return {
-      session: await this.create(
-        project,
-        request,
-        { status: "skipped", reason: "user-proceeded" },
-        undefined,
-        "created",
-        principal,
-      ),
-      resolution: "created",
-    };
-  }
-
-  async requireOwned(
-    projectId: StudioProjectId,
-    sessionId: string,
-  ): Promise<HarnessSession> {
-    const session = this.options.sessionManager.get(sessionId);
-    const principal = this.currentPrincipal();
-    if (!session) throw new PlanningSessionError("session_not_found");
-    if (!this.owns(session, projectId, principal)) {
-      throw new PlanningSessionError("forbidden");
-    }
-    // Ownership metadata alone is insufficient after a project root moves or
-    // the old root is rebound to another project. Resolve on every operation.
-    await this.assertRunnable(projectId, session.cwd, principal);
-    return session;
-  }
-}
diff --git a/packages/harness/src/core/session-manager.test.ts b/packages/harness/src/core/session-manager.test.ts
index 2d60a031d..f4a93107e 100644
--- a/packages/harness/src/core/session-manager.test.ts
+++ b/packages/harness/src/core/session-manager.test.ts
@@ -18,6 +18,7 @@ import {
   SessionInputIsolationError,
   SessionManagerClosingError,
   ProjectSessionScopeUnavailableError,
+  ProjectBootstrapClaimUnavailableError,
   SessionManager,
   sanitizeExitTail,
   type PtySpawnFn,
@@ -118,13 +119,15 @@ describe("SessionManager", () => {
     opts: {
       adapter?: HarnessAdapter;
       spawnPty?: PtySpawnFn;
-      onRuntimeEpochTransition?: SessionManagerOptions["onRuntimeEpochTransition"];
-      onTerminalInput?: SessionManagerOptions["onTerminalInput"];
       loadSpawnPty?: SessionManagerOptions["loadSpawnPty"];
       buildLaunchOpts?: SessionManagerOptions["buildLaunchOpts"];
       resolveAgentMapIdentity?: SessionManagerOptions["resolveAgentMapIdentity"];
+      prepareProjectSession?: SessionManagerOptions["prepareProjectSession"];
       onAgentMapSessionExit?: SessionManagerOptions["onAgentMapSessionExit"];
+      onTerminalInput?: SessionManagerOptions["onTerminalInput"];
       onProjectAgentIdentityMigration?: SessionManagerOptions["onProjectAgentIdentityMigration"];
+      onProjectBootstrapSession?: SessionManagerOptions["onProjectBootstrapSession"];
+      onRuntimeEpochTransition?: SessionManagerOptions["onRuntimeEpochTransition"];
       writeWorkspaceContext?: SessionManagerOptions["writeWorkspaceContext"];
       prepareWorkspaceContext?: SessionManagerOptions["prepareWorkspaceContext"];
       ensureCanvasTemplate?: SessionManagerOptions["ensureCanvasTemplate"];
@@ -132,23 +135,23 @@ describe("SessionManager", () => {
       platform?: SessionManagerOptions["platform"];
       ingestCredentials?: SessionManagerOptions["ingestCredentials"];
       writeSessionRegistry?: SessionManagerOptions["writeSessionRegistry"];
-      writeAgentSessionOwnerRegistry?:
-        SessionManagerOptions["writeAgentSessionOwnerRegistry"];
+      writeAgentSessionOwnerRegistry?: SessionManagerOptions["writeAgentSessionOwnerRegistry"];
       /** Pid given to every fake pty this manager spawns — see createFakePty(). */
       fakePid?: number;
     } = {},
   ) {
     const adapter = opts.adapter ?? createFakeAdapter();
     const spawns: ReturnType<typeof createFakePty>[] = [];
-    const spawnPty: PtySpawnFn | undefined = opts.loadSpawnPty ? undefined :
-      opts.spawnPty ??
-      ((file, args) => {
-        const fake = createFakePty(opts.fakePid);
-        spawns.push(fake);
-        void file;
-        void args;
-        return fake.pty as unknown as ReturnType<PtySpawnFn>;
-      });
+    const spawnPty: PtySpawnFn | undefined = opts.loadSpawnPty
+      ? undefined
+      : (opts.spawnPty ??
+        ((file, args) => {
+          const fake = createFakePty(opts.fakePid);
+          spawns.push(fake);
+          void file;
+          void args;
+          return fake.pty as unknown as ReturnType<PtySpawnFn>;
+        }));
     const manager = new SessionManager({
       adapters: { "claude-code": adapter },
       ingestUrl: "http://127.0.0.1:4100",
@@ -158,12 +161,15 @@ describe("SessionManager", () => {
       sessionsPath,
       spawnPty,
       loadSpawnPty: opts.loadSpawnPty,
-      onTerminalInput: opts.onTerminalInput,
-      onRuntimeEpochTransition: opts.onRuntimeEpochTransition,
       buildLaunchOpts: opts.buildLaunchOpts,
       resolveAgentMapIdentity: opts.resolveAgentMapIdentity,
+      prepareProjectSession: opts.prepareProjectSession,
       onAgentMapSessionExit: opts.onAgentMapSessionExit,
+      onTerminalInput: opts.onTerminalInput,
       onProjectAgentIdentityMigration: opts.onProjectAgentIdentityMigration,
+      onProjectBootstrapSession: opts.onProjectBootstrapSession,
+      onRuntimeEpochTransition: opts.onRuntimeEpochTransition,
+
       writeWorkspaceContext: opts.writeWorkspaceContext,
       prepareWorkspaceContext: opts.prepareWorkspaceContext,
       ensureCanvasTemplate: opts.ensureCanvasTemplate,
@@ -171,6 +177,7 @@ describe("SessionManager", () => {
       platform: opts.platform,
       writeSessionRegistry: opts.writeSessionRegistry,
       writeAgentSessionOwnerRegistry: opts.writeAgentSessionOwnerRegistry,
+
     });
     managers.push(manager);
     return { manager, adapter, spawns };
@@ -178,10 +185,16 @@ describe("SessionManager", () => {
 
   it("creates a session, spawns via the adapter's SpawnSpec, and marks it running", async () => {
     const { manager, adapter } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     expect(adapter.launch).toHaveBeenCalledWith(
-      expect.objectContaining({ cwd: "/tmp/proj", harnessSessionId: session.id }),
+      expect.objectContaining({
+        cwd: "/tmp/proj",
+        harnessSessionId: session.id,
+      }),
     );
     expect(session.status).toBe("running");
     expect(session.cwd).toBe("/tmp/proj");
@@ -192,10 +205,15 @@ describe("SessionManager", () => {
 
   it("persists sessions to disk and reconciles non-exited sessions to exited on reload", async () => {
     const { manager } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
     expect(session.status).toBe("running");
 
-    const raw = JSON.parse(await readFile(sessionsPath, "utf8")) as HarnessSession[];
+    const raw = JSON.parse(
+      await readFile(sessionsPath, "utf8"),
+    ) as HarnessSession[];
     expect(raw).toHaveLength(1);
     expect(raw[0]?.id).toBe(session.id);
     expect(raw[0]?.status).toBe("running");
@@ -294,7 +312,7 @@ describe("SessionManager", () => {
         queuedInputIds: ["input-1"],
       },
     });
-    expect(manager.get(planner.id)?.agentMapIdentity).not.toHaveProperty("role");
+    expect(manager.get(planner.id)).not.toHaveProperty("planning");
     expect(manager.get(manual.id)).toMatchObject({
       id: manual.id,
       agentSessionId: manual.agentSessionId,
@@ -533,7 +551,10 @@ describe("SessionManager", () => {
 
   it("routes write() and resize() to the underlying pty", async () => {
     const { manager, spawns } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     expect(manager.write(session.id, "echo hi\r")).toBe(true);
     expect(spawns[0]?.pty.write).toHaveBeenCalledWith("echo hi\r");
@@ -556,10 +577,17 @@ describe("SessionManager", () => {
 
     it("splits non-empty submitted text into a text write, then a separate \\r after a delay", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
 
-      const submitPromise = manager.submitInput(session.id, "hello world", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "hello world",
+        true,
+      );
 
       // Text lands immediately; the trailing Enter must NOT be part of the
       // same write (that's exactly the bracketed-paste bug this fixes).
@@ -578,7 +606,10 @@ describe("SessionManager", () => {
 
     it("writes a bare \\r in a single call for submit:true with empty text (no splitting needed)", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
 
       const ok = await manager.submitInput(session.id, "", true);
@@ -590,7 +621,10 @@ describe("SessionManager", () => {
 
     it("writes only the text, with no \\r at all, when submit is false", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
 
       const ok = await manager.submitInput(session.id, "draft text", false);
@@ -602,13 +636,20 @@ describe("SessionManager", () => {
 
     it("brackets the text once the app has turned bracketed paste on", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       // The TUI announces mode 2004 in its own output; only then is it safe to
       // send the markers rather than have them rendered as literal text.
       spawns[0]?.emitData("\x1b[?1049;2004h");
 
-      const submitPromise = manager.submitInput(session.id, "step context\n\nDebug this step", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "step context\n\nDebug this step",
+        true,
+      );
       await vi.advanceTimersByTimeAsync(300);
       expect(await submitPromise).toBe(true);
 
@@ -622,12 +663,19 @@ describe("SessionManager", () => {
 
     it("writes the text raw again once the app turns bracketed paste back off", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       spawns[0]?.emitData("\x1b[?2004h");
       spawns[0]?.emitData("\x1b[?2004l");
 
-      const submitPromise = manager.submitInput(session.id, "hello world", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "hello world",
+        true,
+      );
       await vi.advanceTimersByTimeAsync(300);
       expect(await submitPromise).toBe(true);
 
@@ -637,11 +685,16 @@ describe("SessionManager", () => {
 
     it("never brackets a submit:false draft — the text is the user's to edit", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       spawns[0]?.emitData("\x1b[?2004h");
 
-      expect(await manager.submitInput(session.id, "draft text", false)).toBe(true);
+      expect(await manager.submitInput(session.id, "draft text", false)).toBe(
+        true,
+      );
       expect(spawns[0]?.pty.write).toHaveBeenCalledTimes(1);
       expect(spawns[0]?.pty.write).toHaveBeenCalledWith("draft text");
     });
@@ -656,15 +709,25 @@ describe("SessionManager", () => {
         adapter: createFakeAdapter({ assumesBracketedPaste: true }),
         platform: "win32",
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       spawns[0]?.emitData("welcome banner, no mode announcements");
 
-      const submitPromise = manager.submitInput(session.id, "line one\n\nline two", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "line one\n\nline two",
+        true,
+      );
       await vi.advanceTimersByTimeAsync(300);
       expect(await submitPromise).toBe(true);
 
-      expect(spawns[0]?.pty.write).toHaveBeenNthCalledWith(1, "\x1b[200~line one\n\nline two\x1b[201~");
+      expect(spawns[0]?.pty.write).toHaveBeenNthCalledWith(
+        1,
+        "\x1b[200~line one\n\nline two\x1b[201~",
+      );
       expect(spawns[0]?.pty.write).toHaveBeenNthCalledWith(2, "\r");
     });
 
@@ -675,12 +738,19 @@ describe("SessionManager", () => {
         adapter: createFakeAdapter({ assumesBracketedPaste: true }),
         platform: "win32",
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       spawns[0]?.emitData("\x1b[?2004h");
       spawns[0]?.emitData("\x1b[?2004l");
 
-      const submitPromise = manager.submitInput(session.id, "hello\nworld", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "hello\nworld",
+        true,
+      );
       await vi.advanceTimersByTimeAsync(300);
       expect(await submitPromise).toBe(true);
 
@@ -689,12 +759,17 @@ describe("SessionManager", () => {
 
     it("returns false for an unknown session without ever touching a pty", async () => {
       const { manager } = makeManager();
-      expect(await manager.submitInput("unknown-id", "hello", true)).toBe(false);
+      expect(await manager.submitInput("unknown-id", "hello", true)).toBe(
+        false,
+      );
     });
 
     it("does not write the trailing \\r if the session's pty is gone by the time the delay elapses", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
 
       const submitPromise = manager.submitInput(session.id, "hello", true);
@@ -711,7 +786,10 @@ describe("SessionManager", () => {
 
     it("rechecks a scoped guard before Enter and leaves staged text unsubmitted after a rebind", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setReady(session.id);
       const remainsAuthorized = vi
         .fn<() => boolean>()
@@ -741,9 +819,14 @@ describe("SessionManager", () => {
   describe("exit output capture (exitTail)", () => {
     it("preserves the tail of output when a session exits abnormally (non-zero code)", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
-      spawns[0]?.emitData("\x1b[31merror\x1b[0m: unknown option '--plugin-dir'\n");
+      spawns[0]?.emitData(
+        "\x1b[31merror\x1b[0m: unknown option '--plugin-dir'\n",
+      );
       spawns[0]?.emitExit(1);
       await manager.flush();
 
@@ -752,13 +835,18 @@ describe("SessionManager", () => {
       expect(exited?.exitCode).toBe(1);
       // The agent's own error line survives — with ANSI stripped — which is the
       // whole point: a startup crash is no longer an opaque exit code.
-      expect(exited?.exitTail).toContain("error: unknown option '--plugin-dir'");
+      expect(exited?.exitTail).toContain(
+        "error: unknown option '--plugin-dir'",
+      );
       expect(exited?.exitTail).not.toContain("\x1b");
     });
 
     it("captures nothing for a clean exit (code 0)", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       spawns[0]?.emitData("all good, bye\n");
       spawns[0]?.emitExit(0);
@@ -769,7 +857,10 @@ describe("SessionManager", () => {
 
     it("captures nothing when an abnormal exit produced no readable output", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       // Only cursor/clear control noise — nothing a human could read.
       spawns[0]?.emitData("\x1b[2J\x1b[H");
@@ -781,9 +872,14 @@ describe("SessionManager", () => {
 
     it("captures nothing for a user-initiated kill, even when the pty reports a non-zero signal code", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
-      spawns[0]?.emitData("some normal session output the user was looking at\n");
+      spawns[0]?.emitData(
+        "some normal session output the user was looking at\n",
+      );
       // kill() marks the handle; node-pty then reports 143 (128 + SIGTERM) on
       // some platforms — a non-zero code, but NOT a crash to diagnose.
       const killed = manager.kill(session.id);
@@ -823,20 +919,32 @@ describe("SessionManager", () => {
       vi.useRealTimers();
     });
 
-    it("a fresh session starts not-ready even though its pty is already \"running\"", async () => {
+    it('a fresh session starts not-ready even though its pty is already "running"', async () => {
       const { manager } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       expect(session.status).toBe("running");
       expect(session.ready).toBe(false);
     });
 
     it("write() (raw keystrokes) is never gated on readiness — a human must be able to answer a blocking prompt themselves", async () => {
-      const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const onTerminalInput = vi.fn();
+      const { manager, spawns } = makeManager({ onTerminalInput });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       expect(session.ready).toBe(false);
 
       expect(manager.write(session.id, "1\r")).toBe(true);
       expect(spawns[0]?.pty.write).toHaveBeenCalledWith("1\r");
+      expect(onTerminalInput).toHaveBeenCalledOnce();
+      expect(onTerminalInput).toHaveBeenCalledWith(session.id, {
+        blockingPrompt: false,
+        runtimeEpoch: manager.getRuntimeEpoch(session.id),
+      });
     });
 
     it(
@@ -871,7 +979,10 @@ describe("SessionManager", () => {
 
     it("rechecks a scoped guard after readiness and writes zero bytes after a queued planner is rebound", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       let authorized = true;
       const submitPromise = manager.submitInput(
         session.id,
@@ -894,7 +1005,10 @@ describe("SessionManager", () => {
 
     it("throws SessionNotReadyError (never silently proceeds) when a session never becomes ready within the grace period", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const submitPromise = manager.submitInput(session.id, "hello", true);
       const assertion = expect(submitPromise).rejects.toThrow(/not ready yet/i);
@@ -907,7 +1021,10 @@ describe("SessionManager", () => {
 
     it("resuming resets ready back to false, even for a session that was ready before its pty exited", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       await manager.setAgentSessionId(session.id, "agent-1");
       manager.setReady(session.id);
       expect(manager.get(session.id)?.ready).toBe(true);
@@ -930,8 +1047,16 @@ describe("SessionManager", () => {
     describe("harnesses with detectBlockingPrompt (Codex's lazy-rollout-file bridge)", () => {
       it("is not ready before the settle window elapses, even with a clean scrollback", async () => {
         const detectBlockingPrompt = vi.fn(() => false);
-        const { manager, spawns } = makeManager({ adapter: createFakeAdapter({ detectBlockingPrompt, readyFallback: "immediate" }) });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager, spawns } = makeManager({
+          adapter: createFakeAdapter({
+            detectBlockingPrompt,
+            readyFallback: "immediate",
+          }),
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         spawns[0]?.emitData("› Ask Codex to do anything\r\n");
 
         const submitPromise = manager.submitInput(session.id, "hello", true);
@@ -948,8 +1073,16 @@ describe("SessionManager", () => {
 
       it("becomes ready enough after the settle window when the scrollback shows no blocking prompt (the common already-trusted case)", async () => {
         const detectBlockingPrompt = vi.fn(() => false);
-        const { manager, spawns } = makeManager({ adapter: createFakeAdapter({ detectBlockingPrompt, readyFallback: "immediate" }) });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager, spawns } = makeManager({
+          adapter: createFakeAdapter({
+            detectBlockingPrompt,
+            readyFallback: "immediate",
+          }),
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         spawns[0]?.emitData("› Ask Codex to do anything\r\n");
 
         await vi.advanceTimersByTimeAsync(700);
@@ -966,8 +1099,16 @@ describe("SessionManager", () => {
       it("stays not-ready while the scrollback shows a blocking prompt, then proceeds once it clears", async () => {
         let showingPrompt = true;
         const detectBlockingPrompt = vi.fn(() => showingPrompt);
-        const { manager, spawns } = makeManager({ adapter: createFakeAdapter({ detectBlockingPrompt, readyFallback: "immediate" }) });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager, spawns } = makeManager({
+          adapter: createFakeAdapter({
+            detectBlockingPrompt,
+            readyFallback: "immediate",
+          }),
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         spawns[0]?.emitData("Do you trust the contents of this directory?\r\n");
 
         const submitPromise = manager.submitInput(session.id, "hello", true);
@@ -983,12 +1124,21 @@ describe("SessionManager", () => {
 
       it("throws SessionNotReadyError if the blocking prompt never clears within the grace period", async () => {
         const detectBlockingPrompt = vi.fn(() => true);
-        const { manager, spawns } = makeManager({ adapter: createFakeAdapter({ detectBlockingPrompt, readyFallback: "immediate" }) });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager, spawns } = makeManager({
+          adapter: createFakeAdapter({
+            detectBlockingPrompt,
+            readyFallback: "immediate",
+          }),
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         spawns[0]?.emitData("Do you trust the contents of this directory?\r\n");
 
         const submitPromise = manager.submitInput(session.id, "hello", true);
-        const assertion = expect(submitPromise).rejects.toThrow(/not ready yet/i);
+        const assertion =
+          expect(submitPromise).rejects.toThrow(/not ready yet/i);
         await vi.advanceTimersByTimeAsync(8_000);
         await assertion;
 
@@ -1021,7 +1171,10 @@ describe("SessionManager", () => {
       const { manager, spawns } = makeManager({ adapter: immediateAdapter() });
       const readyStatuses: boolean[] = [];
       manager.onStatusChange((session) => readyStatuses.push(session.ready));
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("\x1b[1;1H› Ask Codex to do anything\r\n");
 
       await vi.advanceTimersByTimeAsync(749);
@@ -1035,7 +1188,10 @@ describe("SessionManager", () => {
 
     it("requires pty output before publishing ready", async () => {
       const { manager, spawns } = makeManager({ adapter: immediateAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       await vi.advanceTimersByTimeAsync(1_000);
       expect(manager.get(session.id)?.ready).toBe(false);
@@ -1050,12 +1206,16 @@ describe("SessionManager", () => {
 
     it("ignores Codex's animation-only synchronized repaints when settling", async () => {
       const { manager, spawns } = makeManager({ adapter: immediateAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("› Ask Codex to do anything\r\n");
 
       // Real codex-cli 0.147.0 emits a control-only frame like this about
       // every 80ms while idle. It must not postpone readiness forever.
-      const animationFrame = "\x1b[?2026h\x1b[1;55H\x1b[0m\x1b[49m\x1b[K\x1b[?25l\x1b[?2026l";
+      const animationFrame =
+        "\x1b[?2026h\x1b[1;55H\x1b[0m\x1b[49m\x1b[K\x1b[?25l\x1b[?2026l";
       for (let elapsed = 100; elapsed <= 700; elapsed += 100) {
         await vi.advanceTimersByTimeAsync(100);
         spawns[0]?.emitData(animationFrame);
@@ -1067,27 +1227,38 @@ describe("SessionManager", () => {
     });
 
     it("keeps a blocking screen visible to readiness checks through ANSI-only redraw churn", async () => {
-      const detectBlockingPrompt = vi.fn((scrollback: string) => scrollback.includes("Sign in with ChatGPT"));
+      const detectBlockingPrompt = vi.fn((scrollback: string) =>
+        scrollback.includes("Sign in with ChatGPT"),
+      );
       const { manager, spawns } = makeManager({
         adapter: immediateAdapter(detectBlockingPrompt),
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       // A real Ratatui repaint — including its boundary markers — can span
       // several node-pty chunks.
       spawns[0]?.emitData("\x1b[?20");
       spawns[0]?.emitData("26h\x1b[2J");
-      spawns[0]?.emitData("\x1b[1;1HSign in with ChatGPT\r\nProvide your own API key");
+      spawns[0]?.emitData(
+        "\x1b[1;1HSign in with ChatGPT\r\nProvide your own API key",
+      );
       spawns[0]?.emitData("\x1b[?20");
       spawns[0]?.emitData("26l");
       // More than the 4KB detector window of raw ANSI noise must not evict the
       // sign-in copy that remains visibly painted on the terminal.
       const animationFrame =
-        "\x1b[?2026h" + "\x1b[1;55H\x1b[0m\x1b[49m\x1b[K".repeat(200) + "\x1b[?2026l";
+        "\x1b[?2026h" +
+        "\x1b[1;55H\x1b[0m\x1b[49m\x1b[K".repeat(200) +
+        "\x1b[?2026l";
       spawns[0]?.emitData(animationFrame);
       await vi.advanceTimersByTimeAsync(2_000);
       expect(manager.get(session.id)?.ready).toBe(false);
-      expect(detectBlockingPrompt).toHaveBeenCalledWith(expect.stringContaining("Sign in with ChatGPT"));
+      expect(detectBlockingPrompt).toHaveBeenCalledWith(
+        expect.stringContaining("Sign in with ChatGPT"),
+      );
 
       // A positive composer frame clears the old-screen latch.
       spawns[0]?.emitData(
@@ -1238,7 +1409,10 @@ describe("SessionManager", () => {
 
     it("restarts the settle window when later startup output arrives", async () => {
       const { manager, spawns } = makeManager({ adapter: immediateAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("early Codex banner\r\n");
 
       await vi.advanceTimersByTimeAsync(600);
@@ -1259,7 +1433,10 @@ describe("SessionManager", () => {
       const { manager, spawns } = makeManager({
         adapter: immediateAdapter(detectBlockingPrompt),
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("Do you trust the contents of this directory?\r\n");
 
       // Leave the prompt open beyond the hard ceiling. Clearing it must start
@@ -1283,14 +1460,21 @@ describe("SessionManager", () => {
       const { manager, spawns } = makeManager({
         adapter: immediateAdapter(() => showingPrompt),
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("› Ask Codex to do anything\r\n");
       await vi.advanceTimersByTimeAsync(750);
       expect(manager.get(session.id)?.ready).toBe(true);
 
       showingPrompt = true;
       spawns[0]?.emitData("Sign in with ChatGPT\r\n");
-      const submitPromise = manager.submitInput(session.id, "held prompt", true);
+      const submitPromise = manager.submitInput(
+        session.id,
+        "held prompt",
+        true,
+      );
       expect(spawns[0]?.pty.write).not.toHaveBeenCalled();
 
       // `ready` remains the single latched status transition, but injection
@@ -1312,7 +1496,10 @@ describe("SessionManager", () => {
       });
       const readyStatuses: boolean[] = [];
       manager.onStatusChange((session) => readyStatuses.push(session.ready));
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("› Ask Codex to do anything\r\n");
 
       await vi.advanceTimersByTimeAsync(300);
@@ -1329,7 +1516,10 @@ describe("SessionManager", () => {
 
     it("stops the old monitor when its pty exits and is replaced on resume", async () => {
       const { manager, spawns } = makeManager({ adapter: immediateAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       await manager.setAgentSessionId(session.id, "agent-1");
       spawns[0]?.emitData("› old Codex composer\r\n");
 
@@ -1352,7 +1542,10 @@ describe("SessionManager", () => {
       const { manager, spawns } = makeManager({
         adapter: createFakeAdapter({ detectBlockingPrompt }),
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("legacy composer\r\n");
 
       await vi.advanceTimersByTimeAsync(1_000);
@@ -1387,8 +1580,13 @@ describe("SessionManager", () => {
       // The Windows failure this rescues: the SessionStart hook runs `node`
       // through the agent's hook shell; where that resolution breaks, ready
       // never flips and the SPA's held first prompt is dropped after 10min.
-      const { manager, spawns } = makeManager({ adapter: hookTimeoutAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager, spawns } = makeManager({
+        adapter: hookTimeoutAdapter(),
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("welcome to claude\r\n> ");
 
       await vi.advanceTimersByTimeAsync(19_000);
@@ -1396,12 +1594,19 @@ describe("SessionManager", () => {
 
       await vi.advanceTimersByTimeAsync(2_500);
       expect(manager.get(session.id)?.ready).toBe(true);
-      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("marking ready by fallback"));
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining("marking ready by fallback"),
+      );
     });
 
     it("never fires when the real hook already landed — a healthy machine sees no behavior change", async () => {
-      const { manager, spawns } = makeManager({ adapter: hookTimeoutAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager, spawns } = makeManager({
+        adapter: hookTimeoutAdapter(),
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("welcome\r\n");
       manager.setReady(session.id);
 
@@ -1411,8 +1616,13 @@ describe("SessionManager", () => {
 
     it("keeps waiting while a blocking prompt is on screen — the submit \\r must never answer a trust dialog", async () => {
       let showingPrompt = true;
-      const { manager, spawns } = makeManager({ adapter: hookTimeoutAdapter(() => showingPrompt) });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager, spawns } = makeManager({
+        adapter: hookTimeoutAdapter(() => showingPrompt),
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("Do you trust the files in this folder?\r\n");
 
       await vi.advanceTimersByTimeAsync(30_000);
@@ -1426,26 +1636,39 @@ describe("SessionManager", () => {
 
     it("requires SOME output first — a pty that never drew anything is still starting, not hook-broken", async () => {
       const { manager } = makeManager({ adapter: hookTimeoutAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       await vi.advanceTimersByTimeAsync(30_000);
       expect(manager.get(session.id)?.ready).toBe(false);
     });
 
     it("stops polling once the pty exits", async () => {
-      const { manager, spawns } = makeManager({ adapter: hookTimeoutAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager, spawns } = makeManager({
+        adapter: hookTimeoutAdapter(),
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("output\r\n");
       spawns[0]?.emitExit(1);
 
       await vi.advanceTimersByTimeAsync(30_000);
       expect(manager.get(session.id)?.ready).toBe(false);
-      expect(console.warn).not.toHaveBeenCalledWith(expect.stringContaining("marking ready by fallback"));
+      expect(console.warn).not.toHaveBeenCalledWith(
+        expect.stringContaining("marking ready by fallback"),
+      );
     });
 
     it("is not armed for adapters without a declared fallback", async () => {
       const { manager, spawns } = makeManager({ adapter: createFakeAdapter() });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitData("output\r\n");
 
       await vi.advanceTimersByTimeAsync(30_000);
@@ -1455,7 +1678,10 @@ describe("SessionManager", () => {
 
   it("replays the scrollback buffer to new attach()ers and streams live data", async () => {
     const { manager, spawns } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     spawns[0]?.emitData("hello ");
     spawns[0]?.emitData("world");
@@ -1476,7 +1702,10 @@ describe("SessionManager", () => {
     it("broadcasts once immediately, then throttles further data within the window", async () => {
       vi.useFakeTimers();
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const activity: string[] = [];
       manager.onActivity((id) => activity.push(id));
@@ -1527,7 +1756,10 @@ describe("SessionManager", () => {
 
   it("marks a session exited when its pty exits, and notifies status listeners", async () => {
     const { manager, spawns } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     const statuses: HarnessSession["status"][] = [];
     manager.onStatusChange((s) => {
@@ -1543,10 +1775,13 @@ describe("SessionManager", () => {
 
   it("kill() signals the pty for a running session and returns a Promise resolving true; returns Promise<false> otherwise", async () => {
     const { manager, spawns } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
-
-    // kill() now returns Promise<boolean> — fire-and-forget still works via void,
-    // but here we confirm the resolved value and that the signal was sent.
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
+
+    // kill() now returns Promise<boolean> — fire-and-forget still works via void,
+    // but here we confirm the resolved value and that the signal was sent.
     const killResult = manager.kill(session.id);
     expect(killResult).toBeInstanceOf(Promise);
     expect(spawns[0]?.pty.kill).toHaveBeenCalled();
@@ -1583,9 +1818,14 @@ describe("SessionManager", () => {
 
   it("resume() requires a known agentSessionId and respawns via adapter.resume", async () => {
     const { manager, adapter, spawns } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
-    await expect(manager.resume(session.id)).rejects.toThrow(/no agentSessionId/);
+    await expect(manager.resume(session.id)).rejects.toThrow(
+      /no agentSessionId/,
+    );
 
     await manager.setAgentSessionId(session.id, "agent-uuid-1");
     spawns[0]?.emitExit(0);
@@ -1594,12 +1834,17 @@ describe("SessionManager", () => {
     const resumed = await manager.resume(session.id);
     expect(adapter.resume).toHaveBeenCalledWith(
       "agent-uuid-1",
-      expect.objectContaining({ harnessSessionId: session.id, cwd: "/tmp/proj" }),
+      expect.objectContaining({
+        harnessSessionId: session.id,
+        cwd: "/tmp/proj",
+      }),
     );
     expect(resumed.status).toBe("running");
     expect(resumed.id).toBe(session.id);
 
-    await expect(manager.resume("does-not-exist")).rejects.toThrow(/Unknown session/);
+    await expect(manager.resume("does-not-exist")).rejects.toThrow(
+      /Unknown session/,
+    );
   });
 
   it("pins vendor session identity write-once for live and resumed records", async () => {
@@ -1609,9 +1854,15 @@ describe("SessionManager", () => {
       harness: "claude-code",
     });
 
-    expect(await manager.setAgentSessionId(live.id, "agent-live", "startup")).toBe(true);
-    expect(await manager.setAgentSessionId(live.id, "agent-live", "compact")).toBe(true);
-    expect(await manager.setAgentSessionId(live.id, "agent-other", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(live.id, "agent-live", "startup"),
+    ).toBe(true);
+    expect(
+      await manager.setAgentSessionId(live.id, "agent-live", "compact"),
+    ).toBe(true);
+    expect(
+      await manager.setAgentSessionId(live.id, "agent-other", "clear"),
+    ).toBe(false);
     expect(manager.get(live.id)?.agentSessionId).toBe("agent-live");
 
     const resumed = await manager.registerHistorical({
@@ -1621,8 +1872,12 @@ describe("SessionManager", () => {
       title: "resumed",
       lastActiveAt: "2026-01-01T00:00:00.000Z",
     });
-    expect(await manager.setAgentSessionId(resumed.id, "agent-resumed")).toBe(true);
-    expect(await manager.setAgentSessionId(resumed.id, "agent-other", "resume")).toBe(false);
+    expect(await manager.setAgentSessionId(resumed.id, "agent-resumed")).toBe(
+      true,
+    );
+    expect(
+      await manager.setAgentSessionId(resumed.id, "agent-other", "resume"),
+    ).toBe(false);
     expect(manager.get(resumed.id)?.agentSessionId).toBe("agent-resumed");
   });
 
@@ -1632,17 +1887,23 @@ describe("SessionManager", () => {
       cwd: "/tmp/proj",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(session.id, "agent-before", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-before", "startup"),
+    ).toBe(true);
 
     expect(manager.write(session.id, "/cl")).toBe(true);
     expect(manager.write(session.id, "x")).toBe(true);
     expect(manager.write(session.id, "\x7f")).toBe(true);
     expect(manager.write(session.id, "ear\r")).toBe(true);
 
-    expect(await manager.setAgentSessionId(session.id, "agent-after", "clear")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-after", "clear"),
+    ).toBe(true);
     expect(manager.get(session.id)?.agentSessionId).toBe("agent-after");
     // The gesture was consumed by the accepted rotation.
-    expect(await manager.setAgentSessionId(session.id, "agent-replayed", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-replayed", "clear"),
+    ).toBe(false);
     expect(manager.get(session.id)?.agentSessionId).toBe("agent-after");
   });
 
@@ -1652,13 +1913,19 @@ describe("SessionManager", () => {
       cwd: "/tmp/proj",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(session.id, "agent-before", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-before", "startup"),
+    ).toBe(true);
 
     expect(manager.write(session.id, "please /clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(session.id, "agent-contained", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-contained", "clear"),
+    ).toBe(false);
 
     expect(manager.write(session.id, "context\n/clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(session.id, "agent-multiline", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-multiline", "clear"),
+    ).toBe(false);
 
     // xterm may split the wrappers and preserve CR inside a multiline paste.
     // No pasted line — including an inner exact command — may arm rotation.
@@ -1666,13 +1933,23 @@ describe("SessionManager", () => {
     expect(manager.write(session.id, "0~context\r/cl")).toBe(true);
     expect(manager.write(session.id, "ear\r\x1b[20")).toBe(true);
     expect(manager.write(session.id, "1~\r")).toBe(true);
-    expect(await manager.setAgentSessionId(session.id, "agent-pasted", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-pasted", "clear"),
+    ).toBe(false);
 
     // Ctrl-U safely abandons the prior draft and lets the exact replacement
     // line authorize, while an unrelated hook source cannot consume it.
     expect(manager.write(session.id, "draft\x15/clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(session.id, "agent-wrong-source", "resume")).toBe(false);
-    expect(await manager.setAgentSessionId(session.id, "agent-after", "clear")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(
+        session.id,
+        "agent-wrong-source",
+        "resume",
+      ),
+    ).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-after", "clear"),
+    ).toBe(true);
   });
 
   it("consumes a trusted transition when the matching hook repeats the same identity", async () => {
@@ -1681,11 +1958,17 @@ describe("SessionManager", () => {
       cwd: "/tmp/proj",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(session.id, "agent-same", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-same", "startup"),
+    ).toBe(true);
     expect(manager.write(session.id, "/clear\r")).toBe(true);
 
-    expect(await manager.setAgentSessionId(session.id, "agent-same", "clear")).toBe(true);
-    expect(await manager.setAgentSessionId(session.id, "agent-later", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-same", "clear"),
+    ).toBe(true);
+    expect(
+      await manager.setAgentSessionId(session.id, "agent-later", "clear"),
+    ).toBe(false);
     expect(manager.get(session.id)?.agentSessionId).toBe("agent-same");
   });
 
@@ -1698,7 +1981,9 @@ describe("SessionManager", () => {
         harness: "claude-code",
       });
       manager.setReady(session.id);
-      expect(await manager.setAgentSessionId(session.id, "agent-before", "startup")).toBe(true);
+      expect(
+        await manager.setAgentSessionId(session.id, "agent-before", "startup"),
+      ).toBe(true);
 
       const submitted = manager.submitInput(session.id, "/resume", true);
       await vi.advanceTimersByTimeAsync(300);
@@ -1709,7 +1994,9 @@ describe("SessionManager", () => {
       // their later trusted selection refreshes it without model authority.
       await vi.advanceTimersByTimeAsync(60_000);
       expect(manager.write(session.id, "\x1b[B\r")).toBe(true);
-      expect(await manager.setAgentSessionId(session.id, "agent-picked", "resume")).toBe(true);
+      expect(
+        await manager.setAgentSessionId(session.id, "agent-picked", "resume"),
+      ).toBe(true);
       expect(manager.get(session.id)?.agentSessionId).toBe("agent-picked");
 
       const direct = manager.submitInput(
@@ -1719,7 +2006,9 @@ describe("SessionManager", () => {
       );
       await vi.advanceTimersByTimeAsync(300);
       expect(await direct).toBe(true);
-      expect(await manager.setAgentSessionId(session.id, "agent-direct", "resume")).toBe(true);
+      expect(
+        await manager.setAgentSessionId(session.id, "agent-direct", "resume"),
+      ).toBe(true);
       expect(manager.get(session.id)?.agentSessionId).toBe("agent-direct");
     } finally {
       vi.useRealTimers();
@@ -1777,14 +2066,22 @@ describe("SessionManager", () => {
       cwd: "/tmp/second",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(first.id, "agent-first", "startup")).toBe(true);
-    expect(await manager.setAgentSessionId(second.id, "agent-second", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(first.id, "agent-first", "startup"),
+    ).toBe(true);
+    expect(
+      await manager.setAgentSessionId(second.id, "agent-second", "startup"),
+    ).toBe(true);
 
     expect(manager.write(first.id, "/clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(first.id, "agent-second", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(first.id, "agent-second", "clear"),
+    ).toBe(false);
     expect(manager.get(first.id)?.agentSessionId).toBe("agent-first");
     // Rejection is still a one-shot use; a unique second target cannot reuse it.
-    expect(await manager.setAgentSessionId(first.id, "agent-third", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(first.id, "agent-third", "clear"),
+    ).toBe(false);
   });
 
   it("rejects another session's owned identity on the initial pin", async () => {
@@ -1797,15 +2094,23 @@ describe("SessionManager", () => {
       cwd: "/tmp/second",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(first.id, "agent-owned", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(first.id, "agent-owned", "startup"),
+    ).toBe(true);
 
-    expect(await manager.setAgentSessionId(second.id, "agent-owned", "startup")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(second.id, "agent-owned", "startup"),
+    ).toBe(false);
     expect(manager.get(second.id)?.agentSessionId).toBeNull();
 
     expect(manager.write(second.id, "/clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(second.id, "agent-owned", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(second.id, "agent-owned", "clear"),
+    ).toBe(false);
     // The owned-target rejection consumes the grant even before an initial pin.
-    expect(await manager.setAgentSessionId(second.id, "agent-unique", "clear")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(second.id, "agent-unique", "clear"),
+    ).toBe(false);
     expect(manager.get(second.id)?.agentSessionId).toBeNull();
   });
 
@@ -1815,15 +2120,21 @@ describe("SessionManager", () => {
       cwd: "/tmp/first",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(first.id, "vendor-old", "startup")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(first.id, "vendor-old", "startup"),
+    ).toBe(true);
     expect(manager.write(first.id, "/clear\r")).toBe(true);
-    expect(await manager.setAgentSessionId(first.id, "vendor-new", "clear")).toBe(true);
+    expect(
+      await manager.setAgentSessionId(first.id, "vendor-new", "clear"),
+    ).toBe(true);
 
     const second = await manager.create({
       cwd: "/tmp/second",
       harness: "claude-code",
     });
-    expect(await manager.setAgentSessionId(second.id, "vendor-old", "startup")).toBe(false);
+    expect(
+      await manager.setAgentSessionId(second.id, "vendor-old", "startup"),
+    ).toBe(false);
 
     const ledgerPath = `${sessionsPath}.agent-session-owners.json`;
     const ledger = await readFile(ledgerPath, "utf8");
@@ -1838,13 +2149,21 @@ describe("SessionManager", () => {
       cwd: "/tmp/third",
       harness: "claude-code",
     });
-    expect(await restarted.setAgentSessionId(third.id, "vendor-old", "startup")).toBe(false);
+    expect(
+      await restarted.setAgentSessionId(third.id, "vendor-old", "startup"),
+    ).toBe(false);
   });
 
   it("serializes concurrent first claims so exactly one session owns a vendor id", async () => {
     const { manager } = makeManager();
-    const first = await manager.create({ cwd: "/tmp/first", harness: "claude-code" });
-    const second = await manager.create({ cwd: "/tmp/second", harness: "claude-code" });
+    const first = await manager.create({
+      cwd: "/tmp/first",
+      harness: "claude-code",
+    });
+    const second = await manager.create({
+      cwd: "/tmp/second",
+      harness: "claude-code",
+    });
 
     const results = await Promise.all([
       manager.setAgentSessionId(first.id, "vendor-race", "startup"),
@@ -1861,13 +2180,22 @@ describe("SessionManager", () => {
 
   it("fails closed across a sidecar-committed registry failure and lets only the reserved owner retry", async () => {
     let rejectRegistry = false;
-    const writeSessionRegistry = vi.fn(async (file: string, serialized: string) => {
-      if (rejectRegistry) throw new Error("injected sessions registry failure");
-      await writeFile(file, serialized, "utf8");
-    });
+    const writeSessionRegistry = vi.fn(
+      async (file: string, serialized: string) => {
+        if (rejectRegistry)
+          throw new Error("injected sessions registry failure");
+        await writeFile(file, serialized, "utf8");
+      },
+    );
     const { manager } = makeManager({ writeSessionRegistry });
-    const owner = await manager.create({ cwd: "/tmp/owner", harness: "claude-code" });
-    const attacker = await manager.create({ cwd: "/tmp/attacker", harness: "claude-code" });
+    const owner = await manager.create({
+      cwd: "/tmp/owner",
+      harness: "claude-code",
+    });
+    const attacker = await manager.create({
+      cwd: "/tmp/attacker",
+      harness: "claude-code",
+    });
 
     rejectRegistry = true;
     await expect(
@@ -1904,9 +2232,16 @@ describe("SessionManager", () => {
     ).toBe(true);
     const { manager: finalRestart } = makeManager();
     await finalRestart.init();
-    const later = await finalRestart.create({ cwd: "/tmp/later", harness: "claude-code" });
+    const later = await finalRestart.create({
+      cwd: "/tmp/later",
+      harness: "claude-code",
+    });
     expect(
-      await finalRestart.setAgentSessionId(later.id, "vendor-partial", "startup"),
+      await finalRestart.setAgentSessionId(
+        later.id,
+        "vendor-partial",
+        "startup",
+      ),
     ).toBe(false);
   });
 
@@ -2098,11 +2433,7 @@ describe("SessionManager", () => {
       harness: "claude-code",
     });
     expect(
-      await restarted.setAgentSessionId(
-        claimant.id,
-        duplicate,
-        "startup",
-      ),
+      await restarted.setAgentSessionId(claimant.id, duplicate, "startup"),
     ).toBe(false);
     expect(restarted.get(claimant.id)?.agentSessionId).toBeNull();
     expect(
@@ -2135,22 +2466,38 @@ describe("SessionManager", () => {
         cwd: "/tmp/proj",
         harness: "claude-code",
       });
-      expect(await manager.setAgentSessionId(session.id, "agent-before", "startup")).toBe(true);
+      expect(
+        await manager.setAgentSessionId(session.id, "agent-before", "startup"),
+      ).toBe(true);
 
       expect(manager.write(session.id, "/clear\r")).toBe(true);
       await vi.advanceTimersByTimeAsync(30_000);
-      expect(await manager.setAgentSessionId(session.id, "agent-expired", "clear")).toBe(false);
+      expect(
+        await manager.setAgentSessionId(session.id, "agent-expired", "clear"),
+      ).toBe(false);
 
       expect(manager.write(session.id, "/resume\r")).toBe(true);
       await vi.advanceTimersByTimeAsync(5 * 60_000);
       // Input at the hard cap cannot revive an indefinitely stale picker.
       expect(manager.write(session.id, "\x1b[B\r")).toBe(true);
-      expect(await manager.setAgentSessionId(session.id, "agent-picker-expired", "resume")).toBe(false);
+      expect(
+        await manager.setAgentSessionId(
+          session.id,
+          "agent-picker-expired",
+          "resume",
+        ),
+      ).toBe(false);
 
       expect(manager.write(session.id, "/resume\r")).toBe(true);
       spawns[0]?.emitExit(0);
       await manager.resume(session.id);
-      expect(await manager.setAgentSessionId(session.id, "agent-after-relaunch", "resume")).toBe(false);
+      expect(
+        await manager.setAgentSessionId(
+          session.id,
+          "agent-after-relaunch",
+          "resume",
+        ),
+      ).toBe(false);
       expect(manager.get(session.id)?.agentSessionId).toBe("agent-before");
     } finally {
       vi.useRealTimers();
@@ -2163,14 +2510,19 @@ describe("SessionManager", () => {
       return { settingsFile: `/generated/${harnessSessionId}/settings.json` };
     });
     const { manager, adapter } = makeManager({ buildLaunchOpts });
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     expect(buildLaunchOpts).toHaveBeenCalledWith(
       session.id,
       expect.objectContaining({ cwd: "/tmp/proj", harness: "claude-code" }),
     );
     expect(adapter.launch).toHaveBeenCalledWith(
-      expect.objectContaining({ settingsFile: `/generated/${session.id}/settings.json` }),
+      expect.objectContaining({
+        settingsFile: `/generated/${session.id}/settings.json`,
+      }),
     );
   });
 
@@ -2205,7 +2557,10 @@ describe("SessionManager", () => {
       mcpConfigFile: `/generated/${harnessSessionId}/mcp-config.json`,
     }));
     const { manager, adapter, spawns } = makeManager({ buildLaunchOpts });
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
     await manager.setAgentSessionId(session.id, "agent-uuid-1");
     spawns[0]?.emitExit(0);
 
@@ -2213,41 +2568,9 @@ describe("SessionManager", () => {
 
     expect(adapter.resume).toHaveBeenLastCalledWith(
       "agent-uuid-1",
-      expect.objectContaining({ mcpConfigFile: `/generated/${session.id}/mcp-config.json` }),
-    );
-  });
-
-  it("derives trusted Agent Map identity for create/resume and revokes it on exit", async () => {
-    const buildLaunchOpts = vi.fn(async () => ({}));
-    const onAgentMapSessionExit = vi.fn();
-    const resolveAgentMapIdentity = vi.fn(async (sessionId: string) => ({
-      projectId: "project-1",
-      userId: "user-1",
-      sessionId,
-    }));
-    const { manager, spawns } = makeManager({
-      buildLaunchOpts,
-      resolveAgentMapIdentity,
-      onAgentMapSessionExit,
-    });
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
-    expect(session.agentMapIdentity).toMatchObject({
-      sessionId: session.id,
-    });
-    expect(buildLaunchOpts).toHaveBeenLastCalledWith(
-      session.id,
-      expect.anything(),
-      expect.objectContaining({ agentMapIdentity: session.agentMapIdentity }),
-    );
-    await manager.setAgentSessionId(session.id, "agent-uuid-map");
-    spawns[0]?.emitExit(0);
-    await manager.flush();
-    expect(onAgentMapSessionExit).toHaveBeenCalledWith(session.id);
-    await manager.resume(session.id);
-    expect(buildLaunchOpts).toHaveBeenLastCalledWith(
-      session.id,
-      expect.anything(),
-      expect.objectContaining({ resume: true, agentMapIdentity: session.agentMapIdentity }),
+      expect.objectContaining({
+        mcpConfigFile: `/generated/${session.id}/mcp-config.json`,
+      }),
     );
   });
 
@@ -2283,24 +2606,6 @@ describe("SessionManager", () => {
     expect(onAgentMapSessionExit).toHaveBeenCalledWith(manager.list()[0]!.id);
   });
 
-  it("rejects a resumed session when its project authority disappears", async () => {
-    let available = true;
-    const resolveAgentMapIdentity = vi.fn(async (sessionId: string) => available
-      ? { projectId: "project-1", userId: "user-1", sessionId }
-      : undefined);
-    const { manager, adapter, spawns } = makeManager({ resolveAgentMapIdentity });
-    const session = await manager.create({ cwd: "/tmp/project", harness: "claude-code" });
-    await manager.setAgentSessionId(session.id, "provider-session");
-    spawns[0]?.emitExit(0);
-    await manager.flush();
-    const before = structuredClone(session);
-    available = false;
-    await expect(manager.resume(session.id)).rejects.toBeInstanceOf(ProjectSessionScopeUnavailableError);
-    expect(manager.get(session.id)).toEqual(before);
-    expect(adapter.resume).not.toHaveBeenCalled();
-    expect(spawns).toHaveLength(1);
-  });
-
   it("registerHistorical() creates an exited placeholder session resumable later", async () => {
     const { manager } = makeManager();
     const session = await manager.registerHistorical({
@@ -2335,11 +2640,15 @@ describe("SessionManager", () => {
     }
 
     it("throws SessionNotResumeableError instead of spawning when the agent no longer holds the conversation", async () => {
-      const adapter = createFakeAdapter({ canResume: vi.fn(async () => false) });
+      const adapter = createFakeAdapter({
+        canResume: vi.fn(async () => false),
+      });
       const { manager, spawns } = makeManager({ adapter });
       const session = await registerPhantom(manager);
 
-      await expect(manager.resume(session.id)).rejects.toThrow(SessionNotResumeableError);
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        SessionNotResumeableError,
+      );
       // The point of the pre-flight: no doomed pty. Previously this spawned
       // `claude --resume <id>`, which exited 1 with "No conversation found".
       expect(spawns).toHaveLength(0);
@@ -2347,7 +2656,9 @@ describe("SessionManager", () => {
     });
 
     it("names the agent and the reason so the 409 tells the user WHY", async () => {
-      const adapter = createFakeAdapter({ canResume: vi.fn(async () => false) });
+      const adapter = createFakeAdapter({
+        canResume: vi.fn(async () => false),
+      });
       const { manager } = makeManager({ adapter });
       const session = await registerPhantom(manager);
 
@@ -2362,7 +2673,9 @@ describe("SessionManager", () => {
 
     it("probes the agent's store with the session's own agentSessionId and cwd", async () => {
       const canResume = vi.fn(async () => true);
-      const { manager } = makeManager({ adapter: createFakeAdapter({ canResume }) });
+      const { manager } = makeManager({
+        adapter: createFakeAdapter({ canResume }),
+      });
       const session = await registerPhantom(manager);
 
       await manager.resume(session.id);
@@ -2371,10 +2684,14 @@ describe("SessionManager", () => {
     });
 
     it("leaves a rejected session's record untouched — still exited, same lastActiveAt", async () => {
-      const { manager } = makeManager({ adapter: createFakeAdapter({ canResume: vi.fn(async () => false) }) });
+      const { manager } = makeManager({
+        adapter: createFakeAdapter({ canResume: vi.fn(async () => false) }),
+      });
       const session = await registerPhantom(manager);
 
-      await expect(manager.resume(session.id)).rejects.toThrow(SessionNotResumeableError);
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        SessionNotResumeableError,
+      );
 
       const after = manager.get(session.id);
       expect(after?.status).toBe("exited");
@@ -2392,7 +2709,9 @@ describe("SessionManager", () => {
       });
       const session = await registerPhantom(manager);
 
-      await expect(manager.resume(session.id)).rejects.toThrow("node-pty exploded");
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        "node-pty exploded",
+      );
 
       const after = manager.get(session.id);
       expect(after?.status).toBe("exited");
@@ -2403,18 +2722,28 @@ describe("SessionManager", () => {
 
     it("still short-circuits on a missing agentSessionId without probing the adapter", async () => {
       const canResume = vi.fn(async () => true);
-      const { manager } = makeManager({ adapter: createFakeAdapter({ canResume }) });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager } = makeManager({
+        adapter: createFakeAdapter({ canResume }),
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       await manager.kill(session.id);
 
-      await expect(manager.resume(session.id)).rejects.toThrow(SessionNotResumeableError);
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        SessionNotResumeableError,
+      );
       expect(canResume).not.toHaveBeenCalled();
     });
   });
 
   it("new sessions start with boundWorkflowPath: null", async () => {
     const { manager } = makeManager();
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
     expect(session.boundWorkflowPath).toBeNull();
     expect(manager.get(session.id)?.boundWorkflowPath).toBeNull();
   });
@@ -2428,7 +2757,10 @@ describe("SessionManager", () => {
       // autoCreateSession call shape (server/index.ts calling
       // sessionManager.create() directly), the entry point that used to skip
       // the write entirely because it lived in the REST handler instead.
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       expect(writeWorkspaceContext).toHaveBeenCalledTimes(1);
       expect(writeWorkspaceContext).toHaveBeenCalledWith(session);
@@ -2461,7 +2793,9 @@ describe("SessionManager", () => {
       });
       const { manager } = makeManager({ writeWorkspaceContext });
 
-      await expect(manager.create({ cwd: "/tmp/proj", harness: "claude-code" })).rejects.toThrow("disk full");
+      await expect(
+        manager.create({ cwd: "/tmp/proj", harness: "claude-code" }),
+      ).rejects.toThrow("disk full");
       // The record was persisted as "starting" before the failing write — it
       // must not stay that way (a non-exited record with no pty behind it
       // renders as a ghost tab forever).
@@ -2484,7 +2818,11 @@ describe("SessionManager", () => {
         void args;
         return createFakePty().pty as unknown as ReturnType<PtySpawnFn>;
       };
-      const { manager } = makeManager({ buildLaunchOpts, prepareWorkspaceContext, spawnPty });
+      const { manager } = makeManager({
+        buildLaunchOpts,
+        prepareWorkspaceContext,
+        spawnPty,
+      });
 
       const session = await manager.registerHistorical({
         agentSessionId: "agent-uuid-9",
@@ -2496,7 +2834,9 @@ describe("SessionManager", () => {
       await manager.resume(session.id);
 
       expect(prepareWorkspaceContext).toHaveBeenCalledTimes(1);
-      expect(prepareWorkspaceContext).toHaveBeenCalledWith(manager.get(session.id));
+      expect(prepareWorkspaceContext).toHaveBeenCalledWith(
+        manager.get(session.id),
+      );
       expect(order).toEqual(["prompt", "prepare", "spawn"]);
     });
 
@@ -2514,7 +2854,9 @@ describe("SessionManager", () => {
         lastActiveAt: "2026-01-01T00:00:00.000Z",
       });
 
-      await expect(manager.resume(session.id)).rejects.toThrow("context path unreadable");
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        "context path unreadable",
+      );
 
       expect(spawns).toHaveLength(0);
       expect(manager.get(session.id)).toMatchObject({
@@ -2531,7 +2873,9 @@ describe("SessionManager", () => {
       // that doesn't exist) or leave a real .sapiom dir behind on the test
       // runner's machine — neither happens, proving both defaults are inert.
       const { manager } = makeManager();
-      await expect(manager.create({ cwd: "/tmp/proj", harness: "claude-code" })).resolves.toBeDefined();
+      await expect(
+        manager.create({ cwd: "/tmp/proj", harness: "claude-code" }),
+      ).resolves.toBeDefined();
 
       const historical = await manager.registerHistorical({
         agentSessionId: "agent-uuid-9",
@@ -2596,7 +2940,9 @@ describe("SessionManager", () => {
 
     it("defaults to a no-op so tests with fake cwds never touch the real filesystem", async () => {
       const { manager } = makeManager();
-      await expect(manager.create({ cwd: "/tmp/proj", harness: "claude-code" })).resolves.toBeDefined();
+      await expect(
+        manager.create({ cwd: "/tmp/proj", harness: "claude-code" }),
+      ).resolves.toBeDefined();
     });
   });
 
@@ -2652,7 +2998,9 @@ describe("SessionManager", () => {
       });
       const { manager } = makeManager({ ensureCanvasTemplate });
 
-      await expect(manager.create({ cwd: "/tmp/proj", harness: "claude-code" })).rejects.toThrow("read-only fs");
+      await expect(
+        manager.create({ cwd: "/tmp/proj", harness: "claude-code" }),
+      ).rejects.toThrow("read-only fs");
       expect(manager.list()[0]?.status).toBe("exited");
     });
 
@@ -2664,16 +3012,18 @@ describe("SessionManager", () => {
       const statuses: string[] = [];
       manager.onStatusChange((s) => statuses.push(s.status));
 
-      await expect(manager.create({ cwd: "/tmp/proj", harness: "claude-code" })).rejects.toThrow(
-        "posix_spawnp failed",
-      );
+      await expect(
+        manager.create({ cwd: "/tmp/proj", harness: "claude-code" }),
+      ).rejects.toThrow("posix_spawnp failed");
       expect(manager.list()[0]?.status).toBe("exited");
       expect(statuses).toContain("exited");
 
       // The reconciliation must be durable, not just in-memory — a persisted
       // "starting" record would still ghost after the SPA refetches state.
       await manager.flush();
-      const raw = JSON.parse(await readFile(sessionsPath, "utf8")) as HarnessSession[];
+      const raw = JSON.parse(
+        await readFile(sessionsPath, "utf8"),
+      ) as HarnessSession[];
       expect(raw[0]?.status).toBe("exited");
     });
 
@@ -2698,7 +3048,10 @@ describe("SessionManager", () => {
 
     it("kill() transitions a stale non-exited record with no pty to exited instead of failing", async () => {
       const { manager, spawns } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       spawns[0]?.emitExit(0);
       // Simulate the ghost state directly (the transitions that used to
       // produce it are all reconciled now): a record stuck non-exited whose
@@ -2723,8 +3076,14 @@ describe("SessionManager", () => {
         // The node-pty missed-exit bug (see kill()'s fallback), but for a
         // process that died on its own — no kill() call means no fallback
         // was ever armed, which is exactly what the sweep exists to catch.
-        const { manager } = makeManager({ fakePid: 4242, isPidAlive: () => false });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager } = makeManager({
+          fakePid: 4242,
+          isPidAlive: () => false,
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         expect(session.status).toBe("running");
 
         const statuses: string[] = [];
@@ -2738,13 +3097,21 @@ describe("SessionManager", () => {
         expect(manager.attach(session.id, () => {})).toBeUndefined();
 
         await manager.flush();
-        const raw = JSON.parse(await readFile(sessionsPath, "utf8")) as HarnessSession[];
+        const raw = JSON.parse(
+          await readFile(sessionsPath, "utf8"),
+        ) as HarnessSession[];
         expect(raw[0]?.status).toBe("exited");
       });
 
       it("leaves sessions whose process is alive untouched", async () => {
-        const { manager } = makeManager({ fakePid: 4242, isPidAlive: () => true });
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const { manager } = makeManager({
+          fakePid: 4242,
+          isPidAlive: () => true,
+        });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
 
         manager.sweepDeadSessions();
 
@@ -2754,7 +3121,10 @@ describe("SessionManager", () => {
       it("never probes a pty without a numeric pid, and never declares it dead", async () => {
         const isPidAlive = vi.fn(() => false);
         const { manager } = makeManager({ isPidAlive }); // fake pty with pid: undefined
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
 
         manager.sweepDeadSessions();
 
@@ -2764,7 +3134,10 @@ describe("SessionManager", () => {
 
       it("reconciles a non-exited record with no pty only after it outlives the grace window", async () => {
         const { manager, spawns } = makeManager();
-        const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+        const session = await manager.create({
+          cwd: "/tmp/proj",
+          harness: "claude-code",
+        });
         spawns[0]?.emitExit(0);
         const record = manager.get(session.id)!;
         record.status = "starting"; // simulate the stale mid-transition ghost
@@ -2786,7 +3159,10 @@ describe("SessionManager", () => {
   describe("setBoundWorkflowPath", () => {
     it("updates the in-memory session, persists it, and notifies status listeners", async () => {
       const { manager } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const statuses: (string | null)[] = [];
       manager.onStatusChange((s) => {
@@ -2799,13 +3175,20 @@ describe("SessionManager", () => {
       expect(manager.get(session.id)?.boundWorkflowPath).toBe("/tmp/leasing");
       expect(statuses).toEqual(["/tmp/leasing"]);
 
-      const raw = JSON.parse(await readFile(sessionsPath, "utf8")) as HarnessSession[];
-      expect(raw.find((s) => s.id === session.id)?.boundWorkflowPath).toBe("/tmp/leasing");
+      const raw = JSON.parse(
+        await readFile(sessionsPath, "utf8"),
+      ) as HarnessSession[];
+      expect(raw.find((s) => s.id === session.id)?.boundWorkflowPath).toBe(
+        "/tmp/leasing",
+      );
     });
 
     it("unbinds with null, persisting and notifying again", async () => {
       const { manager } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setBoundWorkflowPath(session.id, "/tmp/leasing");
 
       const statuses: (string | null)[] = [];
@@ -2825,14 +3208,19 @@ describe("SessionManager", () => {
       const statuses: string[] = [];
       manager.onStatusChange(() => statuses.push("fired"));
 
-      expect(() => manager.setBoundWorkflowPath("does-not-exist", "/tmp/leasing")).not.toThrow();
+      expect(() =>
+        manager.setBoundWorkflowPath("does-not-exist", "/tmp/leasing"),
+      ).not.toThrow();
       await manager.flush();
       expect(statuses).toEqual([]);
     });
 
     it("is a no-op when rebinding to the already-current value (no redundant persist/notify)", async () => {
       const { manager } = makeManager();
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       manager.setBoundWorkflowPath(session.id, "/tmp/leasing");
       await manager.flush();
 
@@ -2855,16 +3243,24 @@ describe("SessionManager", () => {
       return fake.pty as unknown as ReturnType<PtySpawnFn>;
     };
     const { manager } = makeManager({ spawnPty });
-    const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
 
     const env = capturedEnvs[0];
-    expect(env?.["SAPIOM_HARNESS_INGEST_URL"]).toBe("http://127.0.0.1:4100/ingest");
+    expect(env?.["SAPIOM_HARNESS_INGEST_URL"]).toBe(
+      "http://127.0.0.1:4100/ingest",
+    );
     expect(env?.["SAPIOM_HARNESS_INGEST_TOKEN"]).toBe("boot-token");
     expect(env?.["SAPIOM_HARNESS_SESSION_ID"]).toBe(session.id);
   });
 
   it("issues and revokes a capability for the exact spawned session", async () => {
-    const issue = vi.fn((id: string) => ({ token: `token-for:${id}`, runtimeEpoch: `epoch-for:${id}` }));
+    const issue = vi.fn((id: string) => ({
+      token: `token-for:${id}`,
+      runtimeEpoch: `epoch-for:${id}`,
+    }));
     const revoke = vi.fn();
     const { manager, spawns } = makeManager({
       ingestCredentials: { issue, revoke, authenticate: () => null },
@@ -2985,7 +3381,10 @@ describe("SessionManager", () => {
         fakePid: 9999,
         isPidAlive: () => pidAlive,
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
       expect(session.status).toBe("running");
 
       // Confirm the pty exists and won't emit onExit on its own — the exit
@@ -3014,8 +3413,14 @@ describe("SessionManager", () => {
     });
 
     it("kill() resolves immediately via real onExit when node-pty fires before the escalation window", async () => {
-      const { manager, spawns } = makeManager({ fakePid: 8888, isPidAlive: () => false });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const { manager, spawns } = makeManager({
+        fakePid: 8888,
+        isPidAlive: () => false,
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const killPromise = manager.kill(session.id);
       // Drive the real onExit — this fires before the escalation timer.
@@ -3034,7 +3439,10 @@ describe("SessionManager", () => {
         fakePid: 7777,
         isPidAlive: () => pidAlive,
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const killPromise = manager.kill(session.id);
       expect(spawns[0]?.pty.kill).toHaveBeenCalledTimes(1); // initial SIGTERM (no arg)
@@ -3053,7 +3461,10 @@ describe("SessionManager", () => {
     });
 
     it("killAll() resolves once all sessions are confirmed dead, even when exits come at different times", async () => {
-      const { manager, spawns } = makeManager({ fakePid: 6666, isPidAlive: () => false });
+      const { manager, spawns } = makeManager({
+        fakePid: 6666,
+        isPidAlive: () => false,
+      });
       const a = await manager.create({ cwd: "/tmp/a", harness: "claude-code" });
       const b = await manager.create({ cwd: "/tmp/b", harness: "claude-code" });
 
@@ -3085,7 +3496,10 @@ describe("SessionManager", () => {
       // Both ptys swallow their onExit events — killAll() must still resolve
       // via the missed-exit synthesis path within the escalation window.
       let pidAlive = true;
-      const { manager } = makeManager({ fakePid: 5555, isPidAlive: () => pidAlive });
+      const { manager } = makeManager({
+        fakePid: 5555,
+        isPidAlive: () => pidAlive,
+      });
       await manager.create({ cwd: "/tmp/a", harness: "claude-code" });
       await manager.create({ cwd: "/tmp/b", harness: "claude-code" });
 
@@ -3116,7 +3530,10 @@ describe("SessionManager", () => {
         // Always "alive" — simulates an EPERM zombie that survives all probes.
         isPidAlive: () => true,
       });
-      const session = await manager.create({ cwd: "/tmp/proj", harness: "claude-code" });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
 
       const killPromise = manager.kill(session.id);
       // Initial signal sent.
@@ -3160,7 +3577,9 @@ describe("SessionManager", () => {
         lastActiveAt: new Date().toISOString(),
       });
 
-      await expect(manager.resume(session.id)).rejects.toThrow(ExternalHarnessError);
+      await expect(manager.resume(session.id)).rejects.toThrow(
+        ExternalHarnessError,
+      );
     });
 
     it("resume() ExternalHarnessError has code HARNESS_EXTERNAL and names the harness label", async () => {
@@ -3199,7 +3618,9 @@ describe("SessionManager", () => {
         lastActiveAt: new Date().toISOString(),
       });
 
-      await expect(manager.submitInput(session.id, "hello")).rejects.toThrow(ExternalHarnessError);
+      await expect(manager.submitInput(session.id, "hello")).rejects.toThrow(
+        ExternalHarnessError,
+      );
     });
 
     it("submitInput() ExternalHarnessError has code HARNESS_EXTERNAL", async () => {
@@ -4065,4 +4486,443 @@ describe("SessionManager", () => {
       );
     });
 });
+
+
+  it.each([
+    "prepareProjectSession",
+    "promptAppendix",
+    "buildLaunchOpts",
+    "adapter.launch",
+  ] as const)(
+    "releases project launch authority when create setup fails in $stage",
+    async (stage) => {
+      const setupError = new Error(`setup failed in ${stage}`);
+      const cleanupError = new Error("cleanup also failed");
+      let claimedSessionId = "";
+      const resolveAgentMapIdentity = vi.fn(async (sessionId: string) => {
+        claimedSessionId = sessionId;
+        return {
+          projectId: "project-1",
+          userId: "user-1",
+          sessionId,
+        };
+      });
+      const prepareProjectSession = vi.fn(async () => {
+        if (stage === "prepareProjectSession") throw setupError;
+        return {
+          projectBootstrap: {
+            projectId: "project-1",
+            userId: "user-1",
+            targetSessionId: claimedSessionId,
+            bootstrap: { status: "pending" as const },
+            queuedInputIds: [],
+          },
+        };
+      });
+      const buildLaunchOpts = vi.fn(async () => {
+        if (stage === "buildLaunchOpts") throw setupError;
+        return {};
+      });
+      const adapter = createFakeAdapter({
+        launch: vi.fn((opts) => {
+          if (stage === "adapter.launch") throw setupError;
+          return {
+            command: "fake-claude",
+            args: ["--launch"],
+            env: {},
+            cwd: opts.cwd,
+          };
+        }),
+      });
+      const onAgentMapSessionExit = vi.fn(async () => {
+        throw cleanupError;
+      });
+      const { manager, spawns } = makeManager({
+        adapter,
+        resolveAgentMapIdentity,
+        prepareProjectSession,
+        buildLaunchOpts,
+        onAgentMapSessionExit,
+      });
+
+      await expect(
+        manager.create(
+          { cwd: "/tmp/proj", harness: "claude-code" },
+          {
+            promptAppendix: () => {
+              if (stage === "promptAppendix") throw setupError;
+              return "bounded project context";
+            },
+          },
+        ),
+      ).rejects.toBe(setupError);
+
+      expect(onAgentMapSessionExit).toHaveBeenCalledOnce();
+      expect(onAgentMapSessionExit).toHaveBeenCalledWith(claimedSessionId);
+      expect(manager.list()).toEqual([]);
+      expect(spawns).toEqual([]);
+    },
+  );
+
+
+  it.each(["buildLaunchOpts", "adapter.resume"] as const)(
+    "releases project launch authority when resume setup fails in $stage",
+    async (stage) => {
+      const setupError = new Error(`resume setup failed in ${stage}`);
+      const adapter = createFakeAdapter({
+        resume: vi.fn((agentSessionId, opts) => {
+          if (stage === "adapter.resume") throw setupError;
+          return {
+            command: "fake-claude",
+            args: ["--resume", agentSessionId],
+            env: {},
+            cwd: opts.cwd,
+          };
+        }),
+      });
+      const buildLaunchOpts = vi.fn(async () => {
+        if (
+          stage === "buildLaunchOpts" &&
+          buildLaunchOpts.mock.calls.length > 1
+        ) {
+          throw setupError;
+        }
+        return {};
+      });
+      const onAgentMapSessionExit = vi.fn(async () => {
+        throw new Error("cleanup also failed");
+      });
+      const resolveAgentMapIdentity = vi.fn(async (sessionId: string) => ({
+        projectId: "project-1",
+        userId: "user-1",
+        sessionId,
+      }));
+      const { manager, spawns } = makeManager({
+        adapter,
+        buildLaunchOpts,
+        onAgentMapSessionExit,
+        resolveAgentMapIdentity,
+      });
+      const session = await manager.create({
+        cwd: "/tmp/proj",
+        harness: "claude-code",
+      });
+      await manager.setAgentSessionId(session.id, "provider-session");
+      spawns[0]!.emitExit(0);
+      await vi.waitFor(() => {
+        expect(onAgentMapSessionExit).toHaveBeenCalledWith(session.id);
+      });
+      onAgentMapSessionExit.mockClear();
+      const beforeResume = structuredClone(manager.get(session.id));
+
+      await expect(manager.resume(session.id)).rejects.toBe(setupError);
+
+      expect(onAgentMapSessionExit).toHaveBeenCalledOnce();
+      expect(onAgentMapSessionExit).toHaveBeenCalledWith(session.id);
+      expect(manager.get(session.id)).toEqual(beforeResume);
+      expect(spawns).toHaveLength(1);
+    },
+  );
+
+
+  it("derives one neutral project identity for create/resume and revokes it on exit", async () => {
+    const buildLaunchOpts = vi.fn(async () => ({}));
+    const onAgentMapSessionExit = vi.fn();
+    const resolveAgentMapIdentity = vi.fn(async (sessionId: string) => ({
+      projectId: "project-1",
+      userId: "user-1",
+      sessionId,
+    }));
+    const { manager, spawns } = makeManager({
+      buildLaunchOpts,
+      resolveAgentMapIdentity,
+      onAgentMapSessionExit,
+    });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
+    expect(session.agentMapIdentity).toEqual({
+      projectId: "project-1",
+      userId: "user-1",
+      sessionId: session.id,
+    });
+    expect(buildLaunchOpts).toHaveBeenLastCalledWith(
+      session.id,
+      expect.anything(),
+      expect.objectContaining({ agentMapIdentity: session.agentMapIdentity }),
+    );
+    await manager.setAgentSessionId(session.id, "agent-uuid-map");
+    spawns[0]?.emitExit(0);
+    await manager.flush();
+    expect(onAgentMapSessionExit).toHaveBeenCalledWith(session.id);
+    await manager.resume(session.id);
+    expect(buildLaunchOpts).toHaveBeenLastCalledWith(
+      session.id,
+      expect.anything(),
+      expect.objectContaining({
+        resume: true,
+        agentMapIdentity: session.agentMapIdentity,
+      }),
+    );
+  });
+
+
+  it("publishes a claimed first project session before a concurrent ordinary session", async () => {
+    const firstLaunch = deferred<void>();
+    let buildCount = 0;
+    const prepareProjectSession = vi.fn(async (identity) =>
+      prepareProjectSession.mock.calls.length === 1
+        ? {
+            initialTitle: "Plan Agents",
+            projectBootstrap: {
+              projectId: identity.projectId,
+              userId: identity.userId,
+              targetSessionId: identity.sessionId,
+              bootstrap: { status: "pending" as const },
+              queuedInputIds: [],
+            },
+          }
+        : {},
+    );
+    const { manager, adapter } = makeManager({
+      resolveAgentMapIdentity: async (sessionId) => ({
+        projectId: "project-1",
+        userId: "user-1",
+        sessionId,
+      }),
+      prepareProjectSession,
+      buildLaunchOpts: async () => {
+        buildCount += 1;
+        if (buildCount === 1) await firstLaunch.promise;
+        return {};
+      },
+    });
+
+    const automatic = manager.create(
+      { cwd: "/tmp/proj", harness: "claude-code" },
+      { requireProjectBootstrapClaim: true },
+    );
+    await vi.waitFor(() => expect(buildCount).toBe(1));
+    const explicit = manager.create({
+      cwd: "/tmp/proj/packages/worker",
+      harness: "claude-code",
+      initialUserInputPending: true,
+    });
+    await Promise.resolve();
+    expect(prepareProjectSession).toHaveBeenCalledOnce();
+    expect(adapter.launch).not.toHaveBeenCalled();
+
+    firstLaunch.resolve();
+    const [first, second] = await Promise.all([automatic, explicit]);
+
+    expect(first.title).toBe("Plan Agents");
+    expect(first.projectBootstrap?.targetSessionId).toBe(first.id);
+    expect(second.title).toBe("worker");
+    expect(second.projectBootstrap).toBeUndefined();
+    expect(manager.list().map((session) => session.id)).toEqual([
+      first.id,
+      second.id,
+    ]);
+    expect(adapter.launch).toHaveBeenCalledTimes(2);
+  });
+
+
+  it("cancels only an automatic create that loses its bootstrap claim", async () => {
+    const firstLaunch = deferred<void>();
+    let buildCount = 0;
+    const prepareProjectSession = vi.fn(async (identity) =>
+      prepareProjectSession.mock.calls.length === 1
+        ? {
+            initialTitle: "Plan Agents",
+            projectBootstrap: {
+              projectId: identity.projectId,
+              userId: identity.userId,
+              targetSessionId: identity.sessionId,
+              bootstrap: {
+                status: "skipped" as const,
+                reason: "user-proceeded" as const,
+              },
+              queuedInputIds: [],
+            },
+          }
+        : {},
+    );
+    const onAgentMapSessionExit = vi.fn();
+    const { manager, adapter, spawns } = makeManager({
+      resolveAgentMapIdentity: async (sessionId) => ({
+        projectId: "project-1",
+        userId: "user-1",
+        sessionId,
+      }),
+      prepareProjectSession,
+      onAgentMapSessionExit,
+      buildLaunchOpts: async () => {
+        buildCount += 1;
+        if (buildCount === 1) await firstLaunch.promise;
+        return {};
+      },
+    });
+
+    const explicit = manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+      initialUserInputPending: true,
+    });
+    await vi.waitFor(() => expect(buildCount).toBe(1));
+    const automatic = manager.create(
+      { cwd: "/tmp/proj", harness: "claude-code" },
+      { requireProjectBootstrapClaim: true },
+    );
+    firstLaunch.resolve();
+
+    const first = await explicit;
+    await expect(automatic).rejects.toBeInstanceOf(
+      ProjectBootstrapClaimUnavailableError,
+    );
+    expect(first).toMatchObject({
+      title: "Plan Agents",
+      projectBootstrap: {
+        targetSessionId: first.id,
+        bootstrap: { status: "skipped", reason: "user-proceeded" },
+      },
+    });
+    expect(manager.list()).toEqual([first]);
+    expect(adapter.launch).toHaveBeenCalledOnce();
+    expect(spawns).toHaveLength(1);
+    expect(onAgentMapSessionExit).toHaveBeenCalledOnce();
+  });
+
+
+  it("drains project create queues without preparing a waiter after shutdown", async () => {
+    const firstLaunch = deferred<void>();
+    let buildCount = 0;
+    const prepareProjectSession = vi.fn(async () => ({}));
+    const { manager, adapter } = makeManager({
+      resolveAgentMapIdentity: async (sessionId) => ({
+        projectId: "project-1",
+        userId: "user-1",
+        sessionId,
+      }),
+      prepareProjectSession,
+      buildLaunchOpts: async () => {
+        buildCount += 1;
+        if (buildCount === 1) await firstLaunch.promise;
+        return {};
+      },
+    });
+
+    const first = manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
+    await vi.waitFor(() => expect(buildCount).toBe(1));
+    const queued = manager.create({
+      cwd: "/tmp/proj/packages/worker",
+      harness: "claude-code",
+    });
+    manager.beginShutdown();
+    const flushed = manager.flush();
+    let flushSettled = false;
+    void flushed.then(() => {
+      flushSettled = true;
+    });
+    await Promise.resolve();
+    expect(flushSettled).toBe(false);
+
+    firstLaunch.resolve();
+    await expect(first).rejects.toBeInstanceOf(SessionManagerClosingError);
+    await expect(queued).rejects.toBeInstanceOf(SessionManagerClosingError);
+    await flushed;
+
+    expect(prepareProjectSession).toHaveBeenCalledOnce();
+    expect(buildCount).toBe(1);
+    expect(adapter.launch).toHaveBeenCalledOnce();
+    expect(manager.list()).toEqual([
+      expect.objectContaining({ status: "exited" }),
+    ]);
+  });
+
+
+  it("revalidates resumed project scope after launch preparation and before spawning another pty", async () => {
+    const identity = (sessionId: string) => ({
+      projectId: "project-1",
+      userId: "user-1",
+      sessionId,
+    });
+    const resolveAgentMapIdentity = vi
+      .fn()
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockResolvedValueOnce(undefined);
+    const { manager, adapter, spawns } = makeManager({
+      resolveAgentMapIdentity,
+    });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
+    await manager.setAgentSessionId(session.id, "provider-project-session");
+    spawns[0]?.emitExit(0);
+    await manager.flush();
+
+    await expect(manager.resume(session.id)).rejects.toBeInstanceOf(
+      ProjectSessionScopeUnavailableError,
+    );
+
+    expect(adapter.resume).toHaveBeenCalledOnce();
+    expect(spawns).toHaveLength(1);
+    expect(manager.get(session.id)).toMatchObject({
+      id: session.id,
+      agentSessionId: "provider-project-session",
+      status: "exited",
+      agentMapIdentity: identity(session.id),
+    });
+  });
+
+
+  it("fails resume closed when neutral project scope cannot be revalidated and preserves the session identity", async () => {
+    const identity = (sessionId: string) => ({
+      projectId: "project-1",
+      userId: "user-1",
+      sessionId,
+    });
+    const resolveAgentMapIdentity = vi
+      .fn()
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockImplementationOnce(async (sessionId: string) => identity(sessionId))
+      .mockResolvedValueOnce(undefined);
+    const { manager, adapter, spawns } = makeManager({
+      resolveAgentMapIdentity,
+    });
+    const session = await manager.create({
+      cwd: "/tmp/proj",
+      harness: "claude-code",
+    });
+    await manager.setAgentSessionId(session.id, "provider-project-session");
+    spawns[0]?.emitExit(0);
+    await manager.flush();
+    const beforeResume = structuredClone(manager.get(session.id));
+
+    await expect(manager.resume(session.id)).rejects.toBeInstanceOf(
+      ProjectSessionScopeUnavailableError,
+    );
+
+    expect(resolveAgentMapIdentity).toHaveBeenLastCalledWith(
+      session.id,
+      session.cwd,
+      session.agentMapIdentity,
+    );
+    expect(manager.get(session.id)).toEqual(beforeResume);
+    expect(manager.get(session.id)?.agentMapIdentity).toEqual({
+      projectId: "project-1",
+      userId: "user-1",
+      sessionId: session.id,
+    });
+    expect(adapter.resume).not.toHaveBeenCalled();
+    expect(spawns).toHaveLength(1);
+  });
 });
diff --git a/packages/harness/src/core/session-manager.ts b/packages/harness/src/core/session-manager.ts
index 2598bf17c..14b2f31fc 100644
--- a/packages/harness/src/core/session-manager.ts
+++ b/packages/harness/src/core/session-manager.ts
@@ -7,7 +7,13 @@
 
 import { createHash, randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
-import { mkdir, readFile, rename, writeFile, chmod } from "node:fs/promises";
+import {
+  chmod,
+  mkdir,
+  readFile,
+  rename,
+  writeFile,
+} from "node:fs/promises";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { createRequire } from "node:module";
 
@@ -22,11 +28,13 @@ import {
   type SpawnSpec,
 } from "../shared/types.js";
 import type {
-  PlannerSessionMetadata,
-  ProjectBootstrapMetadata,
   ProjectAgentSession,
+  ProjectBootstrapMetadata,
 } from "../shared/agent-map.js";
-import { migratePersistedProjectIdentity } from "./project-session-legacy-migration.js";
+import {
+  migratePersistedProjectIdentity,
+  removeLegacyProjectSessionMetadata,
+} from "./project-session-legacy-migration.js";
 import { expandHome } from "./paths.js";
 import {
   initialBracketedPasteState,
@@ -47,7 +55,10 @@ import {
   UnknownSessionError,
 } from "./errors.js";
 import { listHarnessAdapters } from "./adapters/registry.js";
-import type { IngestCredentialProvider, IssuedIngestCredential } from "./ingest-credentials.js";
+import type {
+  IngestCredentialProvider,
+  IssuedIngestCredential,
+} from "./ingest-credentials.js";
 
 export {
   AdapterNotFoundError,
@@ -77,20 +88,27 @@ export class ProjectSessionScopeUnavailableError extends Error {
   }
 }
 
-function sameProjectAgent(left: ProjectAgentSession, right: ProjectAgentSession): boolean {
-  return left.projectId === right.projectId && left.userId === right.userId && left.sessionId === right.sessionId;
+function sameProjectAgent(
+  left: ProjectAgentSession,
+  right: ProjectAgentSession,
+): boolean {
+  return (
+    left.projectId === right.projectId &&
+    left.userId === right.userId &&
+    left.sessionId === right.sessionId
+  );
 }
 
-const neutralPrincipal = (identity: ProjectAgentSession): ProjectAgentSession => ({
-  projectId: identity.projectId, userId: identity.userId, sessionId: identity.sessionId,
-});
-
 // node-pty is a native module. Load it lazily so a missing/broken prebuild on
 // an unsupported platform surfaces as a spawn-time error instead of crashing
 // the whole server at import time.
 type IPty = import("node-pty").IPty;
 type PtyForkOptions = import("node-pty").IPtyForkOptions;
-export type PtySpawnFn = (file: string, args: string[], options: PtyForkOptions) => IPty;
+export type PtySpawnFn = (
+  file: string,
+  args: string[],
+  options: PtyForkOptions,
+) => IPty;
 
 let defaultSpawn: PtySpawnFn | undefined;
 let defaultSpawnError: Error | undefined;
@@ -109,7 +127,9 @@ let defaultSpawnError: Error | undefined;
 export async function ensureSpawnHelperExecutable(): Promise<void> {
   if (process.platform === "win32") return;
   try {
-    const nodePtyPkgJson = createRequire(import.meta.url).resolve("node-pty/package.json");
+    const nodePtyPkgJson = createRequire(import.meta.url).resolve(
+      "node-pty/package.json",
+    );
     const helperPath = join(
       dirname(nodePtyPkgJson),
       "prebuilds",
@@ -326,7 +346,10 @@ export type SessionActivityListener = (harnessSessionId: string) => void;
  */
 export type LaunchOptsBuilder = (
   harnessSessionId: string,
-  req: Pick<CreateSessionRequest, "cwd" | "harness" | "profile" | "rehydrateFrom" | "theme">,
+  req: Pick<
+    CreateSessionRequest,
+    "cwd" | "harness" | "profile" | "rehydrateFrom" | "theme"
+  >,
   context?: {
     promptAppendix?: string;
     /** Native CLI notice shown before a fresh session's first prompt. */
@@ -336,28 +359,13 @@ export type LaunchOptsBuilder = (
     agentMapMcp?: { url: string; bearerToken: string };
     resume?: boolean;
   },
-) => Omit<LaunchOpts, "harnessSessionId" | "cwd"> | Promise<Omit<LaunchOpts, "harnessSessionId" | "cwd">>;
+) =>
+  | Omit<LaunchOpts, "harnessSessionId" | "cwd">
+  | Promise<Omit<LaunchOpts, "harnessSessionId" | "cwd">>;
 
 const defaultBuildLaunchOpts: LaunchOptsBuilder = () => ({});
 
 export interface SessionManagerOptions {
-  /**
-   * Serializes coordinator ownership before a PTY generation is published.
-   * `null` retracts a prepared epoch when pre-publication setup fails.
-   */
-  onRuntimeEpochTransition?: (
-    session: HarnessSession,
-    runtimeEpoch: string | null,
-  ) => Promise<void> | void;
-
-  /** Synchronous notification before a real terminal write crosses the PTY. */
-  onTerminalInput?: (sessionId: string, context: TerminalInputContext) => void;
-
-  /** Async node-pty loader seam used only when `spawnPty` is absent. Production
-   * uses the module loader; tests use this to prove authorization is checked
-   * after that final await and before PTY admission. */
-  loadSpawnPty?: () => Promise<PtySpawnFn>;
-
   adapters: Partial<Record<HarnessKind, HarnessAdapter>>;
   /** Base URL the harness server is reachable at, e.g. http://127.0.0.1:4100. */
   ingestUrl: string;
@@ -369,6 +377,10 @@ export interface SessionManagerOptions {
   sessionsPath?: string;
   /** Injectable for tests. Defaults to a lazily-loaded node-pty. */
   spawnPty?: PtySpawnFn;
+  /** Async node-pty loader seam used only when `spawnPty` is absent. Production
+   * uses the module loader; tests use this to prove authorization is checked
+   * after that final await and before PTY admission. */
+  loadSpawnPty?: () => Promise<PtySpawnFn>;
   buildLaunchOpts?: LaunchOptsBuilder;
   /** Revalidates cwd containment and current principal before every spawn. */
   resolveAgentMapIdentity?: (
@@ -376,10 +388,35 @@ export interface SessionManagerOptions {
     cwd: string,
     persisted?: ProjectAgentSession,
   ) => Promise<ProjectAgentSession | undefined>;
+  /** Claims new-project lifecycle metadata after trusted scope resolution. */
+  prepareProjectSession?: (
+    identity: ProjectAgentSession,
+    request: CreateSessionRequest,
+  ) => Promise<{
+    initialTitle?: string;
+    projectBootstrap?: ProjectBootstrapMetadata;
+  }>;
+  /** Synchronous notification before a real terminal write crosses the PTY. */
+  onTerminalInput?: (sessionId: string, context: TerminalInputContext) => void;
+  /** Content-free observability for persisted identity normalization. */
   onProjectAgentIdentityMigration?: (event: {
     sessionId: string;
     outcome: "migrated" | "rejected";
   }) => void;
+  /** Registers only sessions that carry a durable bootstrap lifecycle. */
+  onProjectBootstrapSession?: (
+    session: HarnessSession,
+    mode: "created" | "resumed",
+    runtimeEpoch: string,
+  ) => Promise<void> | void;
+  /**
+   * Serializes coordinator ownership before a PTY generation is published.
+   * `null` retracts a prepared epoch when pre-publication setup fails.
+   */
+  onRuntimeEpochTransition?: (
+    session: HarnessSession,
+    runtimeEpoch: string | null,
+  ) => Promise<void> | void;
   /** Revokes launch capabilities/transports after every exit path. */
   onAgentMapSessionExit?: (sessionId: string) => void | Promise<void>;
   now?: () => string;
@@ -436,10 +473,10 @@ export interface SessionManagerOptions {
 }
 
 export interface TrustedSessionCreateOptions {
-  /** Server-authored only. Never populated from CreateSessionRequest. */
-  planning?: (sessionId: string) => PlannerSessionMetadata;
   /** Future E5 seam for a server-authored planned builder assignment. */
   agentMapIdentity?: (sessionId: string) => ProjectAgentSession;
+  /** Server-owned initial title. Generic POST /sessions cannot set it. */
+  initialTitle?: string;
   /** Focused trusted context composed into the existing system prompt. */
   promptAppendix?: (sessionId: string) => string;
   /** Server-authored native CLI orientation for a newly created session. */
@@ -447,20 +484,21 @@ export interface TrustedSessionCreateOptions {
   /** Server-owned coordinator predecessor. This may differ from the older
    * history record used to build the rehydration brief. */
   handoffFromSessionId?: string;
+  /** Internal auto-create guard. Ordinary/user-requested creates omit this and
+   * remain valid even when the project's first-session lifecycle already has
+   * an owner. */
+  requireProjectBootstrapClaim?: boolean;
 }
 
 export interface TrustedSessionResumeOptions {
-  /** Server-authored only. Used to suppress fresh-only lifecycle work. */
-  planning?: PlannerSessionMetadata;
   /** Recomputed focused context for the resumed process. */
   promptAppendix?: string;
 }
 
 interface PtyHandle {
+  pty: IPty;
   /** Server-owned identity for this exact live PTY generation. */
   runtimeEpoch: string;
-
-  pty: IPty;
   buffer: string;
   /** Latest content-bearing terminal repaint used for current-screen checks.
    * Unlike `buffer`, animation-only ANSI churn cannot evict the visible text. */
@@ -861,12 +899,10 @@ export class SessionManager {
   private readonly agentSessionOwnersPath: string;
   private readonly spawnPty: PtySpawnFn | undefined;
   private readonly buildLaunchOpts: LaunchOptsBuilder;
-  private readonly resolveAgentMapIdentity:
-    | SessionManagerOptions["resolveAgentMapIdentity"];
+  private readonly resolveAgentMapIdentity: SessionManagerOptions["resolveAgentMapIdentity"];
   private readonly onProjectAgentIdentityMigration: SessionManagerOptions["onProjectAgentIdentityMigration"];
   private readonly rejectedProjectSessionMetadata = new Set<string>();
-  private readonly onAgentMapSessionExit:
-    | SessionManagerOptions["onAgentMapSessionExit"];
+  private readonly onAgentMapSessionExit: SessionManagerOptions["onAgentMapSessionExit"];
   private readonly now: () => string;
   private readonly generateId: () => string;
   private readonly writeSessionRegistry:
@@ -875,8 +911,12 @@ export class SessionManager {
   private readonly writeAgentSessionOwnerRegistry:
     | ((file: string, serialized: string) => Promise<void>)
     | undefined;
-  private readonly writeWorkspaceContext: (session: HarnessSession) => Promise<void>;
-  private readonly prepareWorkspaceContext: (session: HarnessSession) => Promise<void>;
+  private readonly writeWorkspaceContext: (
+    session: HarnessSession,
+  ) => Promise<void>;
+  private readonly prepareWorkspaceContext: (
+    session: HarnessSession,
+  ) => Promise<void>;
   private readonly ensureCanvasTemplate: (cwd: string) => Promise<void>;
   private readonly isPidAlive: (pid: number) => boolean;
   private readonly platform: NodeJS.Platform;
@@ -909,24 +949,32 @@ export class SessionManager {
     this.revokeIngestToken = (sessionId) =>
       options.ingestCredentials.revoke(sessionId);
     this.collectorUrl = options.collectorUrl;
-    this.sessionsPath = expandHome(options.sessionsPath ?? HARNESS_PATHS.sessions);
+    this.sessionsPath = expandHome(
+      options.sessionsPath ?? HARNESS_PATHS.sessions,
+    );
     this.agentSessionOwnersPath = `${this.sessionsPath}.agent-session-owners.json`;
     this.spawnPty = options.spawnPty;
     this.loadSpawnPty = options.loadSpawnPty ?? loadDefaultSpawn;
-    this.onTerminalInput = options.onTerminalInput ?? (() => {});
-    this.onRuntimeEpochTransition = options.onRuntimeEpochTransition;
     this.buildLaunchOpts = options.buildLaunchOpts ?? defaultBuildLaunchOpts;
     this.resolveAgentMapIdentity = options.resolveAgentMapIdentity;
+    this.prepareProjectSession = options.prepareProjectSession;
     this.onAgentMapSessionExit = options.onAgentMapSessionExit;
-    this.onProjectAgentIdentityMigration = options.onProjectAgentIdentityMigration;
+    this.onTerminalInput = options.onTerminalInput ?? (() => {});
+    this.onProjectAgentIdentityMigration =
+      options.onProjectAgentIdentityMigration;
+    this.onProjectBootstrapSession = options.onProjectBootstrapSession;
+    this.onRuntimeEpochTransition = options.onRuntimeEpochTransition;
     this.now = options.now ?? (() => new Date().toISOString());
     this.generateId = options.generateId ?? randomUUID;
     this.writeSessionRegistry = options.writeSessionRegistry;
     this.writeAgentSessionOwnerRegistry =
       options.writeAgentSessionOwnerRegistry;
-    this.writeWorkspaceContext = options.writeWorkspaceContext ?? (async () => {});
-    this.prepareWorkspaceContext = options.prepareWorkspaceContext ?? (async () => {});
-    this.ensureCanvasTemplate = options.ensureCanvasTemplate ?? (async () => {});
+    this.writeWorkspaceContext =
+      options.writeWorkspaceContext ?? (async () => {});
+    this.prepareWorkspaceContext =
+      options.prepareWorkspaceContext ?? (async () => {});
+    this.ensureCanvasTemplate =
+      options.ensureCanvasTemplate ?? (async () => {});
     this.isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
     this.platform = options.platform ?? process.platform;
     // Many WS clients (terminal + events) can subscribe over a long-running process.
@@ -967,8 +1015,7 @@ export class SessionManager {
         }
         // Planner-era metadata is never live authority after normalization.
         // Its on-disk input queue is migrated by ProjectBootstrapCoordinator.
-        // The retired startup still reads its private lifecycle projection until
-        // bootstrap activation. Its role fields never enter session authority.
+        removeLegacyProjectSessionMetadata(session);
         dirty = true;
       }
       if (migration.outcome !== "unchanged") {
@@ -1056,88 +1103,7 @@ export class SessionManager {
     req: CreateSessionRequest,
     trusted: TrustedSessionCreateOptions = {},
   ): Promise<HarnessSession> {
-    if (this.closing) throw new SessionManagerClosingError();
-    const id = this.generateId();
-    const adapter = this.getAdapter(req.harness);
-    const planning = trusted.planning?.(id);
-    const trustedIdentity = trusted.agentMapIdentity?.(id) ?? planning?.identity;
-    const resolvedIdentity = this.resolveAgentMapIdentity
-      ? await this.resolveAgentMapIdentity(id, req.cwd, trustedIdentity)
-      : trustedIdentity;
-    const agentMapIdentity = resolvedIdentity ? neutralPrincipal(resolvedIdentity) : undefined;
-    const promptAppendix = trusted.promptAppendix?.(id);
-    const sessionStartSystemMessage = trusted.sessionStartSystemMessage?.(id);
-    const launchContext =
-      promptAppendix || sessionStartSystemMessage || agentMapIdentity
-        ? {
-            ...(promptAppendix ? { promptAppendix } : {}),
-            ...(sessionStartSystemMessage ? { sessionStartSystemMessage } : {}),
-            ...(agentMapIdentity ? { agentMapIdentity } : {}),
-          }
-        : undefined;
-    const opts: LaunchOpts = {
-      harnessSessionId: id,
-      cwd: req.cwd,
-      ...(await (launchContext
-        ? this.buildLaunchOpts(id, req, launchContext)
-        : this.buildLaunchOpts(id, req))),
-    };
-    let spec: SpawnSpec;
-    try {
-      spec = adapter.launch(opts);
-    } catch (error) {
-      await Promise.resolve(this.onAgentMapSessionExit?.(id)).catch(() => {});
-      throw error;
-    }
-    const session: HarnessSession = {
-      id,
-      agentSessionId: null,
-      harness: req.harness,
-      cwd: req.cwd,
-      title: basename(req.cwd) || req.cwd,
-      status: "starting",
-      createdAt: this.now(),
-      lastActiveAt: this.now(),
-      exitCode: null,
-      boundWorkflowPath: null,
-      // Ordinary callers record only what the builder actually rehydrated.
-      // A trusted planner replacement records its exact FIFO predecessor even
-      // when the brief came from an older recorded ancestor in that chain.
-      rehydratedFrom:
-        trusted.handoffFromSessionId ?? opts.rehydratedFrom ?? null,
-      // Persisted so resume() regenerates the same ANSI base — otherwise a
-      // resumed session would fall back to the server default and its dim text
-      // could lose contrast against a differently-themed terminal.
-      ...(req.theme ? { theme: req.theme } : {}),
-      ready: false,
-      ...(planning ? { planning } : {}),
-      ...(agentMapIdentity
-        ? { agentMapIdentity: structuredClone(agentMapIdentity) }
-        : {}),
-    };
-    this.sessions.set(id, session);
-    try {
-      await this.persist();
-      // Before spawning, not fire-and-forget: the agent's very first read of
-      // HARNESS_CONTEXT_FILE must never race session creation with an ENOENT,
-      // regardless of which entry point called create() (REST, autoCreateSession).
-      await this.writeWorkspaceContext(session);
-      // Same reasoning: the canvas pane opens immediately once the session is
-      // "running" — it must never show a bare empty iframe because nothing's
-      // been written to .sapiom/canvas/index.html yet.
-      await this.ensureCanvasTemplate(session.cwd);
-      await this.spawn(session, spec, () =>
-        this.revalidateAgentMapIdentity(id, session.cwd, agentMapIdentity),
-      );
-    } catch (err) {
-      // The first persist may itself be the failure, so reconciliation is
-      // best-effort: always repair the in-memory record to "exited", attempt
-      // the durable repair, and preserve the original actionable failure if
-      // that second write also fails.
-      await this.transitionExited(session, null).catch(() => {});
-      throw err;
-    }
-    return session;
+    return this.createWithId(this.generateId(), req, trusted);
   }
 
   /**
@@ -1206,13 +1172,15 @@ export class SessionManager {
     if (this.closing) throw new SessionManagerClosingError();
     const session = this.sessions.get(id);
     if (!session) throw new UnknownSessionError(id);
-    if (this.rejectedProjectSessionMetadata.has(id)) throw new ProjectSessionScopeUnavailableError(id);
     if (!session.agentSessionId) {
       throw new SessionNotResumeableError(id);
     }
     if (this.ptys.has(id)) {
       throw new SessionAlreadyLiveError(id);
     }
+    if (this.rejectedProjectSessionMetadata.has(id)) {
+      throw new ProjectSessionScopeUnavailableError(id);
+    }
     const adapter = this.getAdapter(session.harness);
     // Pre-flight against the agent's OWN store before touching the record.
     // Holding an agentSessionId only means our SessionStart hook fired once;
@@ -1222,28 +1190,22 @@ export class SessionManager {
     // Failing here instead keeps the record exactly as it was — unspawned,
     // and (see below) with its real lastActiveAt intact.
     if (!(await adapter.canResume(session.agentSessionId, session.cwd))) {
-      const label = listHarnessAdapters().find((a) => a.id === session.harness)?.label ?? session.harness;
+      const label =
+        listHarnessAdapters().find((a) => a.id === session.harness)?.label ??
+        session.harness;
       throw new SessionNotResumeableError(
         id,
         `${label} no longer has the conversation for this session (${session.agentSessionId}) in ${session.cwd}. ` +
           `Sessions that ended before their first prompt are never written to the coding agent's history, so there is nothing to resume — start a new session in this directory instead.`,
       );
     }
-    if (trusted.planning) {
-      session.planning = structuredClone(trusted.planning);
-    }
-    const trustedIdentity = trusted.planning?.identity;
-    const priorIdentity = session.agentMapIdentity ?? trustedIdentity;
-    const resolvedIdentity = this.resolveAgentMapIdentity
-      ? await this.resolveAgentMapIdentity(id, session.cwd, priorIdentity)
-      : priorIdentity;
-    if (priorIdentity && (!resolvedIdentity || !sameProjectAgent(priorIdentity, resolvedIdentity))) {
-      throw new ProjectSessionScopeUnavailableError(id);
-    }
-    const agentMapIdentity = resolvedIdentity ? neutralPrincipal(resolvedIdentity) : undefined;
+    const trustedIdentity = session.agentMapIdentity;
+    const agentMapIdentity = this.resolveAgentMapIdentity
+      ? await this.resolveAgentMapIdentity(id, session.cwd, trustedIdentity)
+      : trustedIdentity;
     if (agentMapIdentity)
       session.agentMapIdentity = structuredClone(agentMapIdentity);
-    else delete session.agentMapIdentity;
+    else if (trustedIdentity) throw new ProjectSessionScopeUnavailableError(id);
     // Claim the pre-PTY resume window before generated launch state is built.
     // Exit observers may finish asynchronous bookkeeping after kill() resolves;
     // they must see this lifecycle as starting, not schedule cleanup against
@@ -1314,7 +1276,13 @@ export class SessionManager {
           agentMapIdentity,
         ),
       );
-
+      if (session.projectBootstrap) {
+        const runtimeEpoch = this.getRuntimeEpoch(session.id);
+        if (runtimeEpoch === null) throw new Error("session runtime unavailable");
+        await Promise.resolve(
+          this.onProjectBootstrapSession?.(session, "resumed", runtimeEpoch),
+        ).catch(() => {});
+      }
     } catch (err) {
       // Same best-effort reconciliation as create(): the first persist can be
       // the failure, and a failed repair must not replace that original error.
@@ -2059,7 +2027,9 @@ export class SessionManager {
         const possibleControls = handle.trustedInputPasting
           ? [BRACKETED_PASTE_END]
           : [BRACKETED_PASTE_START, BRACKETED_PASTE_END];
-        if (possibleControls.some((candidate) => candidate.startsWith(control))) {
+        if (
+          possibleControls.some((candidate) => candidate.startsWith(control))
+        ) {
           if (control === BRACKETED_PASTE_START) {
             handle.trustedInputPasting = true;
             handle.trustedInputLine = "";
@@ -2093,7 +2063,9 @@ export class SessionManager {
       }
       if (char === "\r") {
         if (!handle.trustedInputInvalid) {
-          const transition = this.rotationForTrustedLine(handle.trustedInputLine);
+          const transition = this.rotationForTrustedLine(
+            handle.trustedInputLine,
+          );
           if (transition) {
             const now = Date.now();
             handle.agentSessionRotation = {
@@ -2212,24 +2184,6 @@ export class SessionManager {
     this.emitStatus(session);
   }
 
-  async setPlanningMetadata(
-    id: string,
-    metadata: PlannerSessionMetadata,
-  ): Promise<void> {
-    const session = this.sessions.get(id);
-    if (!session) throw new UnknownSessionError(id);
-    session.planning = structuredClone(metadata);
-    session.projectBootstrap = {
-      projectId: metadata.identity.projectId,
-      userId: metadata.identity.userId,
-      targetSessionId: metadata.identity.sessionId,
-      bootstrap: metadata.greeting,
-      queuedInputIds: [...metadata.queuedInputIds],
-    };
-    await this.persist();
-    this.emitStatus(session);
-  }
-
   /**
    * Whether `id` should be treated as ready to receive programmatic input
    * right now. A real/fallback `session.ready` signal normally suffices; an
@@ -2398,7 +2352,10 @@ export class SessionManager {
    * keystrokes) must never wait on this, since a human answering the very
    * prompt this is waiting out is exactly how a session becomes ready.
    */
-  private async waitUntilReady(id: string, timeoutMs: number): Promise<boolean> {
+  private async waitUntilReady(
+    id: string,
+    timeoutMs: number,
+  ): Promise<boolean> {
     const deadline = Date.now() + timeoutMs;
     for (;;) {
       const handle = this.ptys.get(id);
@@ -2413,6 +2370,13 @@ export class SessionManager {
   /** Waits for all in-flight registry writes to settle. Useful before process
    * shutdown (and in tests that assert against the on-disk registry). */
   async flush(): Promise<void> {
+    // Project-session creation owns setup and registry writes that may span
+    // several awaits. Shutdown closes admission first, then waits for every
+    // already-queued publication to settle before considering persistence
+    // drained.
+    while (this.projectCreateQueues.size > 0) {
+      await Promise.all([...this.projectCreateQueues.values()]);
+    }
     await this.agentSessionIdentityQueue;
     await this.writeQueue;
   }
@@ -2627,7 +2591,11 @@ export class SessionManager {
 
     const poll = setInterval(() => {
       const current = this.sessions.get(id);
-      if (!current || this.ptys.get(id) !== handle || current.status !== "running") {
+      if (
+        !current ||
+        this.ptys.get(id) !== handle ||
+        current.status !== "running"
+      ) {
         clearInterval(poll);
         return;
       }
@@ -2658,7 +2626,7 @@ export class SessionManager {
             `(is \`node\` resolvable from the agent's hook shell?).`,
         );
       }
-      this.setReady(id);
+      this.setReady(id, handle.runtimeEpoch);
     }, pollMs);
     // Never the reason the process stays alive; tests with fake timers and
     // the real server both tear down via the exited hook below anyway.
@@ -2816,7 +2784,9 @@ export class SessionManager {
         record.owners === null ||
         Array.isArray(record.owners)
       ) {
-        throw new Error("agent-session owner ledger has an unsupported version");
+        throw new Error(
+          "agent-session owner ledger has an unsupported version",
+        );
       }
       const entries = Object.entries(record.owners as Record<string, unknown>);
       if (entries.length > AGENT_SESSION_OWNER_MAX_ENTRIES) {
@@ -2829,7 +2799,9 @@ export class SessionManager {
           ownerId.length === 0 ||
           ownerId.length > 256
         ) {
-          throw new Error("agent-session owner ledger contains an invalid entry");
+          throw new Error(
+            "agent-session owner ledger contains an invalid entry",
+          );
         }
         this.agentSessionOwners.set(digest, ownerId);
       }
@@ -2959,4 +2931,212 @@ export class SessionManager {
       JSON.stringify(this.list(), null, 2) + "\n",
     );
   }
+
+  private readonly prepareProjectSession: SessionManagerOptions["prepareProjectSession"];
+
+  private readonly onProjectBootstrapSession: SessionManagerOptions["onProjectBootstrapSession"];
+
+  /** Publish project sessions in claim order so the first durable/visible row
+   * is also the one that owns the first-session lifecycle. */
+  private readonly projectCreateQueues = new Map<string, Promise<void>>();
+
+  private readonly pendingCreates = new Map<
+    string,
+    Pick<HarnessSession, "cwd" | "agentMapIdentity">
+  >();
+
+
+  /** Read-only vendor-history probe used before a coordinator claims recovery. */
+  async canResumeSession(id: string): Promise<boolean> {
+    const session = this.sessions.get(id);
+    if (!session?.agentSessionId) return false;
+    return this.getAdapter(session.harness).canResume(
+      session.agentSessionId,
+      session.cwd,
+    );
+  }
+
+
+  private serializeProjectCreate<T>(
+    projectId: string,
+    operation: () => Promise<T>,
+  ): Promise<T> {
+    const prior = this.projectCreateQueues.get(projectId) ?? Promise.resolve();
+    const next = prior.catch(() => {}).then(operation);
+    const settled = next.then(
+      () => {},
+      () => {},
+    );
+    this.projectCreateQueues.set(projectId, settled);
+    void settled.then(() => {
+      if (this.projectCreateQueues.get(projectId) === settled) {
+        this.projectCreateQueues.delete(projectId);
+      }
+    });
+    return next;
+  }
+
+
+  /** Keep ordinary project roots discoverable during asynchronous launch
+   * preparation, before their session rows can be published. Server-only. */
+  listPendingCreates(): Pick<HarnessSession, "cwd" | "agentMapIdentity">[] {
+    return [...this.pendingCreates.values()];
+  }
+
+
+  private async createWithId(
+    id: string,
+    req: CreateSessionRequest,
+    trusted: TrustedSessionCreateOptions,
+  ): Promise<HarnessSession> {
+    if (this.closing) throw new SessionManagerClosingError();
+    const adapter = this.getAdapter(req.harness);
+    const trustedIdentity = trusted.agentMapIdentity?.(id);
+    const agentMapIdentity = this.resolveAgentMapIdentity
+      ? await this.resolveAgentMapIdentity(id, req.cwd, trustedIdentity)
+      : trustedIdentity;
+    const createResolved = async (): Promise<HarnessSession> => {
+      // A project create may have been waiting behind another publication
+      // when shutdown closed admission. Refuse it before claiming bootstrap,
+      // issuing capabilities, or writing generated session state.
+      if (this.closing) throw new SessionManagerClosingError();
+      let preparedProjectSession:
+        | Awaited<
+            ReturnType<
+              NonNullable<SessionManagerOptions["prepareProjectSession"]>
+            >
+          >
+        | undefined;
+      let opts: LaunchOpts;
+      let spec: SpawnSpec;
+      try {
+        preparedProjectSession =
+          agentMapIdentity && this.prepareProjectSession
+            ? await this.prepareProjectSession(agentMapIdentity, req)
+            : undefined;
+        if (
+          trusted.requireProjectBootstrapClaim &&
+          !preparedProjectSession?.projectBootstrap
+        ) {
+          throw new ProjectBootstrapClaimUnavailableError();
+        }
+        // Retain only AFTER claiming first-session ownership. Advertising the
+        // root earlier could start an automatic session ahead of this request.
+        this.pendingCreates.set(id, { cwd: req.cwd, agentMapIdentity });
+        const promptAppendix = trusted.promptAppendix?.(id);
+        const sessionStartSystemMessage =
+          trusted.sessionStartSystemMessage?.(id);
+        const launchContext =
+          promptAppendix || sessionStartSystemMessage || agentMapIdentity
+            ? {
+                ...(promptAppendix ? { promptAppendix } : {}),
+                ...(sessionStartSystemMessage
+                  ? { sessionStartSystemMessage }
+                  : {}),
+                ...(agentMapIdentity ? { agentMapIdentity } : {}),
+              }
+            : undefined;
+        opts = {
+          harnessSessionId: id,
+          cwd: req.cwd,
+          ...(await (launchContext
+            ? this.buildLaunchOpts(id, req, launchContext)
+            : this.buildLaunchOpts(id, req))),
+        };
+        spec = adapter.launch(opts);
+      } catch (error) {
+        // Scope resolution may already have claimed bootstrap ownership, and
+        // launch preparation may already have issued a capability. Revoke both
+        // for every setup failure, including prompt composition/config writes,
+        // while preserving the original actionable error.
+        await Promise.resolve(this.onAgentMapSessionExit?.(id)).catch(() => {});
+        throw error;
+      }
+      const projectBootstrap = preparedProjectSession?.projectBootstrap;
+      const session: HarnessSession = {
+        id,
+        agentSessionId: null,
+        harness: req.harness,
+        cwd: req.cwd,
+        title:
+          trusted.initialTitle ??
+          preparedProjectSession?.initialTitle ??
+          (basename(req.cwd) || req.cwd),
+        status: "starting",
+        createdAt: this.now(),
+        lastActiveAt: this.now(),
+        exitCode: null,
+        boundWorkflowPath: null,
+        // Ordinary callers record only what the builder actually rehydrated.
+        // A trusted planner replacement records its exact FIFO predecessor even
+        // when the brief came from an older recorded ancestor in that chain.
+        rehydratedFrom:
+          trusted.handoffFromSessionId ?? opts.rehydratedFrom ?? null,
+        // Persisted so resume() regenerates the same ANSI base — otherwise a
+        // resumed session would fall back to the server default and its dim text
+        // could lose contrast against a differently-themed terminal.
+        ...(req.theme ? { theme: req.theme } : {}),
+        ready: false,
+        ...(projectBootstrap
+          ? { projectBootstrap: structuredClone(projectBootstrap) }
+          : {}),
+        ...(agentMapIdentity
+          ? { agentMapIdentity: structuredClone(agentMapIdentity) }
+          : {}),
+      };
+      this.sessions.set(id, session);
+      try {
+        await this.persist();
+        // Before spawning, not fire-and-forget: the agent's very first read of
+        // HARNESS_CONTEXT_FILE must never race session creation with an ENOENT,
+        // regardless of which entry point called create() (REST, autoCreateSession).
+        await this.writeWorkspaceContext(session);
+        // Same reasoning: the canvas pane opens immediately once the session is
+        // "running" — it must never show a bare empty iframe because nothing's
+        // been written to .sapiom/canvas/index.html yet.
+        await this.ensureCanvasTemplate(session.cwd);
+        await this.spawn(session, spec, () =>
+          this.revalidateAgentMapIdentity(
+            session.id,
+            session.cwd,
+            agentMapIdentity,
+          ),
+        );
+        if (session.projectBootstrap) {
+          const runtimeEpoch = this.getRuntimeEpoch(session.id);
+          if (runtimeEpoch === null) throw new Error("session runtime unavailable");
+          await Promise.resolve(
+            this.onProjectBootstrapSession?.(session, "created", runtimeEpoch),
+          ).catch(() => {});
+        }
+      } catch (err) {
+        // The first persist may itself be the failure, so reconciliation is
+        // best-effort: always repair the in-memory record to "exited", attempt
+        // the durable repair, and preserve the original actionable failure if
+        // that second write also fails.
+        await this.transitionExited(session, null).catch(() => {});
+        throw err;
+      }
+      return session;
+    };
+    try {
+      return await (agentMapIdentity
+        ? this.serializeProjectCreate(agentMapIdentity.projectId, createResolved)
+        : createResolved());
+    } finally {
+      this.pendingCreates.delete(id);
+    }
+  }
+}
+
+
+
+/** An automatic first-session create lost the project bootstrap claim. */
+export class ProjectBootstrapClaimUnavailableError extends Error {
+  readonly code = "PROJECT_BOOTSTRAP_CLAIM_UNAVAILABLE";
+
+  constructor() {
+    super("the project bootstrap claim is already owned by another session");
+    this.name = "ProjectBootstrapClaimUnavailableError";
+  }
 }
diff --git a/packages/harness/src/profiles/agent-map-planner.ts b/packages/harness/src/profiles/agent-map-planner.ts
deleted file mode 100644
index 032039b30..000000000
--- a/packages/harness/src/profiles/agent-map-planner.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * Standalone launch profile for the project-scoped Agent Map planner.
- *
- * Planner sessions still run in the real Claude Code or Codex CLI, but they
- * must not inherit the ordinary Studio authoring profile: that profile tells
- * the model to scaffold, run, and deploy code. Focused project data is appended
- * separately by PlanningSessionService for each trusted session.
- */
-export const AGENT_MAP_PLANNER_SYSTEM_PROMPT = `
-You are the project planning agent running in Agent Studio.
-
-Work with the user at the architecture level: plan agents, subagents,
-responsibilities, data flow, resources, connectors, artifacts, and the
-relationships between them. Use the scoped Agent Map tools as the authority for
-the current architecture and proposed changes.
-
-Do not act as a coding or implementation agent. Do not scaffold agents, edit
-application source code, run implementation tasks, or deploy software.
-`.trim();
-
-/**
- * User-facing orientation shown by Claude Code's native SessionStart hook.
- * This is deliberately static UI copy, not a synthetic model/user turn.
- */
-/** Transitional startup notice until the legacy lifecycle is removed. */
-export const AGENT_MAP_PLANNER_SESSION_START_MESSAGE = [
-  "Studio project session",
-  "Plan and build in this conversation. The Agent Map is shared project context; clear implementation requests can proceed directly.",
-].join("\n");
diff --git a/packages/harness/src/server/agent-map-auth-wiring.test.ts b/packages/harness/src/server/agent-map-auth-wiring.test.ts
index f32a580dd..303b6fedd 100644
--- a/packages/harness/src/server/agent-map-auth-wiring.test.ts
+++ b/packages/harness/src/server/agent-map-auth-wiring.test.ts
@@ -133,20 +133,7 @@ describe("coding-agent authorization boundary", () => {
     });
     expect(mutation.status).toBe(401);
 
-    const forgedPlanner = await fetch(
-      `${baseUrl}/api/projects/forged-project/planner-sessions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Harness-Token": ingestToken,
-        },
-        body: JSON.stringify({ mode: "fresh" }),
-      },
-    );
-    expect(forgedPlanner.status).toBe(401);
-
-    const forgedGenericRole = await fetch(`${baseUrl}/api/sessions`, {
+    const forgedGenericAuthority = await fetch(`${baseUrl}/api/sessions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -155,17 +142,14 @@ describe("coding-agent authorization boundary", () => {
       body: JSON.stringify({
         cwd: projectRoot,
         harness: "claude-code",
-        planning: {
-          identity: {
-            projectId: "forged-project",
-            sessionId: "forged-session",
-            userId: "forged-user",
-            role: "map-planner",
-          },
+        projectAuthority: {
+          projectId: "forged-project",
+          sessionId: "forged-session",
+          userId: "forged-user",
         },
       }),
     });
-    expect(forgedGenericRole.status).toBe(401);
+    expect(forgedGenericAuthority.status).toBe(401);
 
     const legitimateLaunch = await fetch(
       `${baseUrl}/?uiToken=${encodeURIComponent(server.uiToken)}`,
diff --git a/packages/harness/src/server/agent-map-mcp-wiring.test.ts b/packages/harness/src/server/agent-map-mcp-wiring.test.ts
index 50633498c..82b8062d4 100644
--- a/packages/harness/src/server/agent-map-mcp-wiring.test.ts
+++ b/packages/harness/src/server/agent-map-mcp-wiring.test.ts
@@ -12,7 +12,7 @@ import type {
   LaunchOpts,
   SpawnSpec,
 } from "../shared/types.js";
-import { AGENT_MAP_PLANNER_SESSION_START_MESSAGE } from "../profiles/agent-map-planner.js";
+import { PROJECT_AGENT_PROMPT_APPENDIX } from "../profiles/project-agent.js";
 import { StudioProjectCatalog } from "../core/studio-project-catalog.js";
 import { startServer, type HarnessServer } from "./index.js";
 
@@ -21,6 +21,14 @@ let projectRoot: string;
 let projectId: string;
 let server: HarnessServer | undefined;
 
+function deferred(): { promise: Promise<void>; resolve: () => void } {
+  let resolve!: () => void;
+  const promise = new Promise<void>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+
 beforeEach(async () => {
   root = await fs.mkdtemp(path.join(os.tmpdir(), "agent-map-mcp-wiring-"));
   projectRoot = path.join(root, "project");
@@ -138,7 +146,133 @@ it("uses the actual ephemeral port and revokes private MCP launch authority on e
   expect(rejected.status).toBe(401);
 });
 
-it("gives a signed-out local planner its scoped Agent Map tools", async () => {
+it("keeps an evicted descendant session resumable in its durable canonical project after restart", async () => {
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch: (opts) => ({ command: "bash", args: [], env: {}, cwd: opts.cwd }),
+    resume: (_id, opts) => ({
+      command: "bash",
+      args: [],
+      env: {},
+      cwd: opts.cwd,
+    }),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  const descendant = path.join(projectRoot, "packages", "worker");
+  await Promise.all([
+    fs.mkdir(webDir),
+    fs.mkdir(descendant, { recursive: true }),
+  ]);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    autoCreateSession: false,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+  });
+
+  const created = await server.sessionManager.create({
+    cwd: descendant,
+    harness: "claude-code",
+  });
+  expect(created).toMatchObject({
+    cwd: descendant,
+    title: "worker",
+    agentMapIdentity: {
+      projectId,
+      sessionId: created.id,
+      userId: "local:machine-1",
+    },
+  });
+
+  const repeatedOpen = await fetch(
+    `http://127.0.0.1:${server.port}/api/settings`,
+    {
+      method: "PATCH",
+      headers: {
+        "content-type": "application/json",
+        "x-harness-token": "boot-token",
+      },
+      body: JSON.stringify({ recentDirs: [projectRoot] }),
+    },
+  );
+  expect(repeatedOpen.status).toBe(200);
+  expect(server.sessionManager.list()).toHaveLength(1);
+  const catalog = new StudioProjectCatalog(
+    path.join(root, "studio-projects.json"),
+  );
+  expect(await catalog.list()).toHaveLength(1);
+  await expect(
+    catalog.resolveIdentityForPath(descendant),
+  ).resolves.toMatchObject({ projectId });
+
+  await server.sessionManager.setAgentSessionId(
+    created.id,
+    "provider-descendant-session",
+  );
+  await server.sessionManager.kill(created.id);
+  const evicted = await fetch(`http://127.0.0.1:${server.port}/api/settings`, {
+    method: "PATCH",
+    headers: {
+      "content-type": "application/json",
+      "x-harness-token": "boot-token",
+    },
+    body: JSON.stringify({ recentDirs: [] }),
+  });
+  expect(evicted.status).toBe(200);
+  const reconciledState = await fetch(
+    `http://127.0.0.1:${server.port}/api/state`,
+    { headers: { "x-harness-token": "boot-token" } },
+  );
+  expect(reconciledState.status).toBe(200);
+  await server.close();
+  server = undefined;
+
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    autoCreateSession: false,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+  });
+  const restartedCatalog = new StudioProjectCatalog(
+    path.join(root, "studio-projects.json"),
+  );
+  await expect(
+    restartedCatalog.resolveIdentityForPath(descendant),
+  ).resolves.toMatchObject({ projectId });
+  await expect(
+    restartedCatalog.resolveIdentity(projectId),
+  ).resolves.toMatchObject({
+    rootBindings: [expect.objectContaining({ status: "active" })],
+  });
+  const resumed = await server.sessionManager.resume(created.id);
+  expect(resumed).toMatchObject({
+    id: created.id,
+    agentSessionId: "provider-descendant-session",
+    status: "running",
+    agentMapIdentity: { projectId },
+  });
+});
+
+it("gives every signed-out project session the same coding prompt and Agent Map tools", async () => {
   const codingPrompt =
     "You are the coding agent running in Agent Studio. Follow the scaffold, run, and deploy authoring loop.";
   const loadSystemPrompt = vi.fn(async () => codingPrompt);
@@ -173,39 +307,16 @@ it("gives a signed-out local planner its scoped Agent Map tools", async () => {
     loadSystemPrompt,
   });
 
-  const response = await fetch(
-    `http://127.0.0.1:${server.port}/api/projects/${projectId}/planner-sessions`,
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-harness-token": "boot-token",
-      },
-      body: JSON.stringify({ mode: "fresh", harness: "claude-code" }),
-    },
-  );
-  expect(response.status).toBe(201);
-  const created = (await response.json()) as {
-    session: {
-      id: string;
-      planning: {
-        identity: { role: string; userId: string };
-        greeting: { status: string; reason?: string };
-      };
-      agentMapIdentity?: { role: string; userId: string };
-    };
-  };
-  expect(created.session.planning.identity).toMatchObject({
-    role: "map-planner",
-    userId: "local:machine-1",
+  const created = await server.sessionManager.create({
+    cwd: projectRoot,
+    harness: "claude-code",
   });
-  expect(created.session.agentMapIdentity).toEqual(
-    expect.objectContaining({ userId: "local:machine-1" }),
-  );
-  expect(created.session.planning.greeting).toEqual({
-    status: "skipped",
-    reason: "user-proceeded",
+  expect(created.agentMapIdentity).toEqual({
+    projectId,
+    sessionId: created.id,
+    userId: "local:machine-1",
   });
+  expect(created.projectBootstrap).toBeUndefined();
 
   const launchOpts = launches[0]!;
   const metadata = launchOpts.agentMapMcp;
@@ -218,17 +329,23 @@ it("gives a signed-out local planner its scoped Agent Map tools", async () => {
     `Bearer ${metadata!.bearerToken}`,
   );
   const systemPrompt = await fs.readFile(launchOpts!.systemPromptFile!, "utf8");
-  expect(systemPrompt).toContain("<studio-project-context>");
-  expect(systemPrompt).toContain("<studio-project-agent>");
   expect(systemPrompt).toContain(codingPrompt);
-  expect(systemPrompt).not.toContain("Do not act as a coding or implementation agent");
-  expect(loadSystemPrompt).toHaveBeenCalled();
-  const plannerEmitter = await fs.readFile(
+  expect(systemPrompt).toContain(PROJECT_AGENT_PROMPT_APPENDIX);
+  expect(systemPrompt).toContain("plan and implement in the same session");
+  expect(systemPrompt).toContain("Proceed directly");
+  expect(systemPrompt).not.toMatch(/map[-]planner/u);
+  expect(systemPrompt).not.toContain("not to implement it yet");
+  expect(systemPrompt).not.toContain("stop before implementation");
+  expect(systemPrompt).not.toContain(
+    "This is a private Agent Studio control turn",
+  );
+  expect(loadSystemPrompt).toHaveBeenCalledTimes(1);
+  const compatibilityEmitter = await fs.readFile(
     path.join(path.dirname(launchOpts.settingsFile!), "emit.cjs"),
     "utf8",
   );
-  expect(plannerEmitter).toContain(
-    `const sessionStartSystemMessage = ${JSON.stringify(AGENT_MAP_PLANNER_SESSION_START_MESSAGE)};`,
+  expect(compatibilityEmitter).toContain(
+    "const sessionStartSystemMessage = null;",
   );
 
   const client = new Client({ name: "signed-out-planner-test", version: "1" });
@@ -304,22 +421,23 @@ it("gives a signed-out local planner its scoped Agent Map tools", async () => {
     cwd: projectRoot,
     harness: "claude-code",
   });
-  expect(ordinary.agentMapIdentity).toMatchObject({
+  expect(ordinary.agentMapIdentity).toEqual({
+    projectId,
+    sessionId: ordinary.id,
     userId: "local:machine-1",
   });
   const ordinaryLaunch = launches[1]!;
   expect(ordinaryLaunch.agentMapMcp).toBeDefined();
-  expect(await fs.readFile(ordinaryLaunch.systemPromptFile!, "utf8")).toContain(
-    codingPrompt,
+  const ordinaryPrompt = await fs.readFile(
+    ordinaryLaunch.systemPromptFile!,
+    "utf8",
   );
+  expect(ordinaryPrompt).toBe(systemPrompt);
   const ordinaryEmitter = await fs.readFile(
     path.join(path.dirname(ordinaryLaunch.settingsFile!), "emit.cjs"),
     "utf8",
   );
   expect(ordinaryEmitter).toContain("const sessionStartSystemMessage = null;");
-  expect(ordinaryEmitter).not.toContain(
-    JSON.stringify(AGENT_MAP_PLANNER_SESSION_START_MESSAGE),
-  );
   expect(loadSystemPrompt).toHaveBeenCalledTimes(2);
   const ordinaryConfig = JSON.parse(
     await fs.readFile(ordinaryLaunch.mcpConfigFile!, "utf8"),
@@ -328,3 +446,669 @@ it("gives a signed-out local planner its scoped Agent Map tools", async () => {
     `Bearer ${ordinaryLaunch.agentMapMcp!.bearerToken}`,
   );
 });
+
+it("creates one ordinary Plan Agents session for a newly opened project and never from a map read", async () => {
+  const launches: LaunchOpts[] = [];
+  const launch = (opts: LaunchOpts): SpawnSpec => {
+    launches.push(opts);
+    return { command: "bash", args: [], env: {}, cwd: opts.cwd };
+  };
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch,
+    resume: (_id, opts) => launch(opts),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  await fs.mkdir(webDir);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    autoCreateSession: false,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+  });
+  const request = (pathname: string, init?: RequestInit) =>
+    fetch(`http://127.0.0.1:${server!.port}/api${pathname}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        "x-harness-token": "boot-token",
+        ...init?.headers,
+      },
+    });
+  const freshRoot = path.join(root, "fresh-project");
+  await fs.mkdir(freshRoot);
+  expect(server.sessionManager.list()).toEqual([]);
+  expect(launches).toEqual([]);
+
+  const firstOpen = await request("/settings", {
+    method: "PATCH",
+    body: JSON.stringify({ recentDirs: [freshRoot, projectRoot] }),
+  });
+  expect(firstOpen.status).toBe(200);
+  await vi.waitFor(() => expect(server!.sessionManager.list()).toHaveLength(1));
+  expect(launches).toHaveLength(1);
+  const [firstSession] = server.sessionManager.list();
+  const freshProjectId = firstSession!.agentMapIdentity!.projectId;
+  expect(firstSession).toMatchObject({
+    title: "Plan Agents",
+    cwd: freshRoot,
+    agentMapIdentity: {
+      projectId: freshProjectId,
+      sessionId: firstSession!.id,
+      userId: "local:machine-1",
+    },
+    projectBootstrap: {
+      projectId: freshProjectId,
+      targetSessionId: firstSession!.id,
+      userId: "local:machine-1",
+    },
+  });
+  expect(firstSession).not.toHaveProperty("planning");
+
+  const queuedUserInput = await request(`/sessions/${firstSession!.id}/input`, {
+    method: "POST",
+    body: JSON.stringify({
+      text: "Implement the requested feature directly",
+      submit: true,
+    }),
+  });
+  expect(queuedUserInput.status).toBe(200);
+  expect(firstSession!.projectBootstrap).toMatchObject({
+    bootstrap: { status: "skipped", reason: "user-proceeded" },
+    queuedInputIds: [expect.any(String)],
+  });
+
+  const repeatedOpen = await request("/settings", {
+    method: "PATCH",
+    body: JSON.stringify({ recentDirs: [freshRoot, projectRoot] }),
+  });
+  expect(repeatedOpen.status).toBe(200);
+  expect(server.sessionManager.list()).toHaveLength(1);
+  expect(launches).toHaveLength(1);
+
+  const mapRead = await request(
+    `/projects/${freshProjectId}/agent-map/workspace`,
+  );
+  expect(mapRead.status).toBe(200);
+  expect(server.sessionManager.list()).toHaveLength(1);
+  expect(launches).toHaveLength(1);
+});
+
+it("does not spawn an automatic duplicate when an explicit first session wins the bootstrap claim", async () => {
+  const launches: LaunchOpts[] = [];
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch: (opts) => {
+      launches.push(opts);
+      return { command: "bash", args: [], env: {}, cwd: opts.cwd };
+    },
+    resume: (_id, opts) => ({
+      command: "bash",
+      args: [],
+      env: {},
+      cwd: opts.cwd,
+    }),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  const freshRoot = path.join(root, "explicit-first-project");
+  await Promise.all([fs.mkdir(webDir), fs.mkdir(freshRoot)]);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+  const needed = deferred();
+  const releaseAutomaticCreate = deferred();
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    autoCreateSession: false,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+    projectBootstrapTestHooks: {
+      afterProjectSessionNeeded: async () => {
+        needed.resolve();
+        await releaseAutomaticCreate.promise;
+      },
+    },
+  });
+  const request = (pathname: string, init?: RequestInit) =>
+    fetch(`http://127.0.0.1:${server!.port}/api${pathname}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        "x-harness-token": "boot-token",
+        ...init?.headers,
+      },
+    });
+
+  const opening = request("/settings", {
+    method: "PATCH",
+    body: JSON.stringify({ recentDirs: [freshRoot, projectRoot] }),
+  });
+  await needed.promise;
+  const explicitResponse = await request("/sessions", {
+    method: "POST",
+    body: JSON.stringify({
+      cwd: freshRoot,
+      harness: "claude-code",
+      initialUserInputPending: true,
+    }),
+  });
+  expect(explicitResponse.status).toBe(201);
+  const explicit = (await explicitResponse.json()) as {
+    id: string;
+    title: string;
+    projectBootstrap?: { bootstrap: { status: string; reason?: string } };
+  };
+  releaseAutomaticCreate.resolve();
+  expect((await opening).status).toBe(200);
+
+  expect(server.sessionManager.list()).toHaveLength(1);
+  expect(server.sessionManager.list()[0]).toMatchObject({
+    id: explicit.id,
+    title: "Plan Agents",
+    projectBootstrap: {
+      bootstrap: { status: "skipped", reason: "user-proceeded" },
+    },
+  });
+  expect(explicit.title).toBe("Plan Agents");
+  expect(launches).toHaveLength(1);
+});
+
+it("automatically seeds one durable map through the real E2 tools without replaying after duplicate readiness or restart", async () => {
+  const launches: LaunchOpts[] = [];
+  const tokenPathFor = (sessionId: string) =>
+    path.join(root, `${sessionId}.ingest.json`);
+  const inputPathFor = (sessionId: string) =>
+    path.join(root, `${sessionId}.pty-input`);
+  const launch = (opts: LaunchOpts): SpawnSpec => {
+    launches.push(opts);
+    return {
+      command: "bash",
+      args: [
+        "-c",
+        'printf \'{"ingestToken":"%s"}\' "$SAPIOM_HARNESS_INGEST_TOKEN" > "$SAPIOM_TEST_INGEST_TOKEN_PATH"; while IFS= read -r line; do printf "%s\\n" "$line" >> "$SAPIOM_TEST_INPUT_PATH"; done',
+      ],
+      env: {
+        SAPIOM_TEST_INGEST_TOKEN_PATH: tokenPathFor(opts.harnessSessionId),
+        SAPIOM_TEST_INPUT_PATH: inputPathFor(opts.harnessSessionId),
+      },
+      cwd: opts.cwd,
+    };
+  };
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch,
+    resume: (_id, opts) => launch(opts),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  const freshRoot = path.join(root, "automatic-bootstrap-project");
+  await Promise.all([fs.mkdir(webDir), fs.mkdir(freshRoot)]);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+
+  const boot = () =>
+    startServer({
+      port: 0,
+      bootToken: "boot-token",
+      telemetryOptIn: false,
+      identity: null,
+      machineId: "machine-1",
+      adapters: { "claude-code": adapter },
+      stateRoot: root,
+      launchDir: projectRoot,
+      webDir,
+      autoCreateSession: false,
+      loadSystemPrompt: async () => "ordinary coding prompt",
+    });
+  const request = (pathname: string, init?: RequestInit) =>
+    fetch(`http://127.0.0.1:${server!.port}/api${pathname}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        "x-harness-token": "boot-token",
+        ...init?.headers,
+      },
+    });
+  const readIngestToken = async (sessionId: string): Promise<string> => {
+    let token = "";
+    await vi.waitFor(async () => {
+      const parsed = JSON.parse(
+        await fs.readFile(tokenPathFor(sessionId), "utf8"),
+      ) as { ingestToken?: string };
+      token = parsed.ingestToken ?? "";
+      expect(token).not.toBe("");
+    });
+    return token;
+  };
+  const postHook = async (
+    sessionId: string,
+    token: string,
+    hookEvent: "SessionStart" | "UserPromptSubmit" | "Stop",
+    payload: Record<string, unknown>,
+  ): Promise<void> => {
+    const response = await fetch(`http://127.0.0.1:${server!.port}/ingest`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ hookEvent, harnessSessionId: sessionId, payload }),
+    });
+    expect(response.status).toBe(200);
+  };
+  const capturedInputs = async (sessionId: string): Promise<string[]> => {
+    const text = await fs.readFile(inputPathFor(sessionId), "utf8");
+    return text.trimEnd().split("\n");
+  };
+  const connect = async (opts: LaunchOpts): Promise<Client> => {
+    const metadata = opts.agentMapMcp!;
+    const client = new Client({
+      name: "automatic-bootstrap-script",
+      version: "1",
+    });
+    await client.connect(
+      new StreamableHTTPClientTransport(new URL(metadata.url), {
+        requestInit: {
+          headers: { Authorization: `Bearer ${metadata.bearerToken}` },
+        },
+      }),
+    );
+    return client;
+  };
+
+  server = await boot();
+  const opened = await request("/settings", {
+    method: "PATCH",
+    body: JSON.stringify({ recentDirs: [freshRoot, projectRoot] }),
+  });
+  expect(opened.status).toBe(200);
+  await vi.waitFor(() => expect(server!.sessionManager.list()).toHaveLength(1));
+  const [session] = server.sessionManager.list();
+  expect(session).toMatchObject({
+    cwd: freshRoot,
+    title: "Plan Agents",
+    projectBootstrap: {
+      bootstrap: { status: "pending" },
+    },
+  });
+  const automaticProjectId = session!.agentMapIdentity!.projectId;
+  const providerSessionId = "provider-automatic-bootstrap";
+  const firstIngestToken = await readIngestToken(session!.id);
+
+  await postHook(session!.id, firstIngestToken, "SessionStart", {
+    session_id: providerSessionId,
+    source: "startup",
+    cwd: freshRoot,
+  });
+  await postHook(session!.id, firstIngestToken, "SessionStart", {
+    session_id: providerSessionId,
+    source: "startup",
+    cwd: freshRoot,
+  });
+  let bootstrapPrompt = "";
+  await vi.waitFor(async () => {
+    const inputs = await capturedInputs(session!.id);
+    expect(inputs).toHaveLength(1);
+    bootstrapPrompt = inputs[0]!;
+    expect(bootstrapPrompt).toContain("Agent Studio project bootstrap");
+    expect(bootstrapPrompt).toContain("Read the current Agent Map first");
+  });
+  await postHook(session!.id, firstIngestToken, "UserPromptSubmit", {
+    session_id: providerSessionId,
+    prompt: bootstrapPrompt,
+  });
+
+  const batch = {
+    schemaVersion: 1,
+    proposalId: null,
+    expectedVersion: 0,
+    requestId: "automatic-bootstrap-seed-v1",
+    operations: [
+      {
+        kind: "add-node",
+        draftRef: "market-research",
+        node: {
+          kind: "agent",
+          name: "Market Research",
+          purpose: "Research the top ten stocks trading today",
+          ownerAgent: null,
+          contractRefs: ["ResearchReport"],
+        },
+      },
+    ],
+  };
+  const firstClient = await connect(launches[0]!);
+  let firstProposal: Awaited<ReturnType<Client["callTool"]>>;
+  try {
+    const initial = await firstClient.callTool({
+      name: "agent_map_read",
+      arguments: {},
+    });
+    expect(initial.isError).not.toBe(true);
+    expect(initial.structuredContent).toMatchObject({ proposal: null });
+    const validated = await firstClient.callTool({
+      name: "agent_map_validate",
+      arguments: batch,
+    });
+    expect(validated.isError).not.toBe(true);
+    expect(validated.structuredContent).toMatchObject({ currentVersion: 0 });
+    firstProposal = await firstClient.callTool({
+      name: "agent_map_propose",
+      arguments: batch,
+    });
+    expect(firstProposal.isError).not.toBe(true);
+    expect(firstProposal.structuredContent).toMatchObject({ version: 1 });
+  } finally {
+    await firstClient.close();
+  }
+
+  await postHook(session!.id, firstIngestToken, "Stop", {
+    session_id: providerSessionId,
+    last_assistant_message: "Seeded the evidence-supported initial Agent Map.",
+  });
+  await postHook(session!.id, firstIngestToken, "Stop", {
+    session_id: providerSessionId,
+    last_assistant_message: "Duplicate lifecycle signal.",
+  });
+  await vi.waitFor(() => {
+    expect(
+      server!.sessionManager.get(session!.id)?.projectBootstrap,
+    ).toMatchObject({ bootstrap: { status: "delivered" } });
+  });
+
+  const durableFile = path.join(
+    root,
+    "agent-map",
+    "projects",
+    automaticProjectId,
+    "workspace.json",
+  );
+  const durableBeforeRestart = JSON.parse(
+    await fs.readFile(durableFile, "utf8"),
+  ) as {
+    storageSchemaVersion: number;
+    proposal: { version: number; nodes: unknown[]; history: unknown[] };
+    receipts: unknown[];
+  };
+  expect(durableBeforeRestart.storageSchemaVersion).toBe(1);
+  expect(durableBeforeRestart.proposal).toMatchObject({
+    version: 1,
+    nodes: [expect.any(Object)],
+  });
+  expect(durableBeforeRestart.proposal.history).toHaveLength(1);
+  expect(durableBeforeRestart.receipts).toHaveLength(1);
+  expect(await capturedInputs(session!.id)).toHaveLength(1);
+
+  await server.close();
+  server = undefined;
+  server = await boot();
+  expect(launches).toHaveLength(1);
+  expect(server.sessionManager.get(session!.id)).toMatchObject({
+    id: session!.id,
+    agentSessionId: providerSessionId,
+    status: "exited",
+    projectBootstrap: { bootstrap: { status: "delivered" } },
+  });
+
+  await fs.rm(tokenPathFor(session!.id), { force: true });
+  await server.sessionManager.resume(session!.id);
+  expect(launches).toHaveLength(2);
+  const resumedIngestToken = await readIngestToken(session!.id);
+  expect(resumedIngestToken).not.toBe(firstIngestToken);
+  await postHook(session!.id, resumedIngestToken, "SessionStart", {
+    session_id: providerSessionId,
+    source: "resume",
+    cwd: freshRoot,
+  });
+  await postHook(session!.id, resumedIngestToken, "SessionStart", {
+    session_id: providerSessionId,
+    source: "resume",
+    cwd: freshRoot,
+  });
+  await vi.waitFor(() => {
+    expect(server!.sessionManager.get(session!.id)?.ready).toBe(true);
+  });
+
+  const resumedClient = await connect(launches[1]!);
+  try {
+    const restored = await resumedClient.callTool({
+      name: "agent_map_read",
+      arguments: {},
+    });
+    expect(restored.structuredContent).toMatchObject({
+      proposal: {
+        version: 1,
+        nodes: [expect.objectContaining({ name: "Market Research" })],
+        history: [expect.objectContaining({ requestId: batch.requestId })],
+      },
+    });
+    const replayed = await resumedClient.callTool({
+      name: "agent_map_propose",
+      arguments: batch,
+    });
+    expect(replayed.structuredContent).toEqual(
+      firstProposal!.structuredContent,
+    );
+  } finally {
+    await resumedClient.close();
+  }
+  expect(await capturedInputs(session!.id)).toHaveLength(1);
+  const durableAfterRestart = JSON.parse(
+    await fs.readFile(durableFile, "utf8"),
+  ) as {
+    proposal: { version: number; nodes: unknown[]; history: unknown[] };
+    receipts: unknown[];
+  };
+  expect(durableAfterRestart.proposal).toMatchObject({ version: 1 });
+  expect(durableAfterRestart.proposal.nodes).toHaveLength(1);
+  expect(durableAfterRestart.proposal.history).toHaveLength(1);
+  expect(durableAfterRestart.receipts).toHaveLength(1);
+});
+
+it("initializes every newly opened root once when one settings update creates multiple projects", async () => {
+  const launches: LaunchOpts[] = [];
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch: (opts) => {
+      launches.push(opts);
+      return { command: "bash", args: [], env: {}, cwd: opts.cwd };
+    },
+    resume: (_id, opts) => ({
+      command: "bash",
+      args: [],
+      env: {},
+      cwd: opts.cwd,
+    }),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  const firstRoot = path.join(root, "first-project");
+  const secondRoot = path.join(root, "second-project");
+  await Promise.all([
+    fs.mkdir(webDir),
+    fs.mkdir(firstRoot),
+    fs.mkdir(secondRoot),
+  ]);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    autoCreateSession: false,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+  });
+
+  const response = await fetch(`http://127.0.0.1:${server.port}/api/settings`, {
+    method: "PATCH",
+    headers: {
+      "content-type": "application/json",
+      "x-harness-token": "boot-token",
+    },
+    body: JSON.stringify({
+      recentDirs: [firstRoot, secondRoot, projectRoot],
+    }),
+  });
+
+  expect(response.status).toBe(200);
+  await vi.waitFor(() => expect(server!.sessionManager.list()).toHaveLength(2));
+  const sessions = server.sessionManager.list();
+  expect(sessions).toHaveLength(2);
+  expect(
+    sessions
+      .map((session) => ({
+        cwd: session.cwd,
+        title: session.title,
+        projectId: session.agentMapIdentity?.projectId,
+      }))
+      .sort((left, right) => left.cwd.localeCompare(right.cwd)),
+  ).toEqual([
+    { cwd: firstRoot, title: "Plan Agents", projectId: expect.any(String) },
+    { cwd: secondRoot, title: "Plan Agents", projectId: expect.any(String) },
+  ]);
+  expect(
+    new Set(sessions.map((session) => session.agentMapIdentity?.projectId))
+      .size,
+  ).toBe(2);
+  expect(launches).toHaveLength(2);
+
+  const repeated = await fetch(`http://127.0.0.1:${server.port}/api/settings`, {
+    method: "PATCH",
+    headers: {
+      "content-type": "application/json",
+      "x-harness-token": "boot-token",
+    },
+    body: JSON.stringify({
+      recentDirs: [firstRoot, secondRoot, projectRoot],
+    }),
+  });
+  expect(repeated.status).toBe(200);
+  expect(server.sessionManager.list()).toHaveLength(2);
+  expect(launches).toHaveLength(2);
+});
+
+it("recovers a durable scheduled project intent at server boot", async () => {
+  const nestedRoot = path.join(projectRoot, "nested-binding");
+  await fs.mkdir(nestedRoot);
+  const catalog = new StudioProjectCatalog(
+    path.join(root, "studio-projects.json"),
+  );
+  const identity = await catalog.resolveIdentity(projectId);
+  await catalog.moveRootBinding(
+    projectId,
+    identity!.rootBindings[0]!.id,
+    nestedRoot,
+  );
+  // Keep the narrower binding first in persisted array order. Recovery must
+  // still choose the canonical outermost root rather than UUID/array order.
+  await catalog.addRootBinding(projectId, projectRoot);
+  await fs.writeFile(
+    path.join(root, "settings.json"),
+    JSON.stringify({ recentDirs: [nestedRoot, projectRoot] }),
+  );
+  const intentDirectory = path.join(
+    root,
+    "agent-map",
+    "project-bootstrap",
+    "projects",
+  );
+  await fs.mkdir(intentDirectory, { recursive: true });
+  await fs.writeFile(
+    path.join(intentDirectory, `${projectId}.json`),
+    `${JSON.stringify({
+      schemaVersion: 1,
+      projectId,
+      userId: "local:machine-1",
+      targetSessionId: null,
+      status: "scheduled",
+      createdAt: "2026-09-01T00:00:00.000Z",
+      updatedAt: "2026-09-01T00:00:00.000Z",
+    })}\n`,
+  );
+  const launches: LaunchOpts[] = [];
+  const launch = (opts: LaunchOpts): SpawnSpec => {
+    launches.push(opts);
+    return { command: "bash", args: [], env: {}, cwd: opts.cwd };
+  };
+  const adapter: HarnessAdapter = {
+    id: "claude-code",
+    eventSource: "hooks",
+    doctor: async () => [],
+    launch,
+    resume: (_id, opts) => launch(opts),
+    listPastSessions: async () => [],
+    canResume: async () => true,
+  };
+  const webDir = path.join(root, "web");
+  await fs.mkdir(webDir);
+  await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+
+  server = await startServer({
+    port: 0,
+    bootToken: "boot-token",
+    telemetryOptIn: false,
+    identity: null,
+    machineId: "machine-1",
+    adapters: { "claude-code": adapter },
+    stateRoot: root,
+    launchDir: projectRoot,
+    webDir,
+    loadSystemPrompt: async () => "ordinary coding prompt",
+  });
+
+  // Default auto-create is intentionally enabled. Give its detached create
+  // path enough time to expose a duplicate if recovery failed to suppress it.
+  await new Promise<void>((resolve) => setTimeout(resolve, 100));
+  expect(launches).toHaveLength(1);
+  expect(server.sessionManager.list()).toEqual([
+    expect.objectContaining({
+      title: "Plan Agents",
+      cwd: projectRoot,
+      agentMapIdentity: expect.objectContaining({ projectId }),
+      projectBootstrap: expect.objectContaining({
+        projectId,
+        userId: "local:machine-1",
+      }),
+    }),
+  ]);
+  const recovered = JSON.parse(
+    await fs.readFile(path.join(intentDirectory, `${projectId}.json`), "utf8"),
+  ) as { status: string; targetSessionId: string | null };
+  expect(recovered).toEqual(
+    expect.objectContaining({
+      status: "claimed",
+      targetSessionId: server.sessionManager.list()[0]!.id,
+    }),
+  );
+});
diff --git a/packages/harness/src/server/agent-map.test.ts b/packages/harness/src/server/agent-map.test.ts
index 2e1a75771..7d2d9ddb0 100644
--- a/packages/harness/src/server/agent-map.test.ts
+++ b/packages/harness/src/server/agent-map.test.ts
@@ -8,16 +8,10 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { AgentMapWorkspaceStore } from "../core/agent-map-workspace-store.js";
 import { StudioProjectCatalog } from "../core/studio-project-catalog.js";
 import { StudioWorkspacePreferenceStore } from "../core/studio-workspace-preferences.js";
-import {
-  PlannerGreetingRetryUnavailableError,
-  type PlannerGreetingCoordinator,
-} from "../core/planner-greeting.js";
-import {
-  PlanningSessionError,
-  type PlanningSessionService,
-} from "../core/planning-session.js";
-import type { AgentMapWorkspaceResponse } from "../shared/agent-map.js";
-import type { HarnessSession } from "../shared/types.js";
+import type {
+  AgentMapWorkspaceResponse,
+  StudioProjectSummary,
+} from "../shared/agent-map.js";
 import { createBootTokenMiddleware } from "./auth.js";
 import { createAgentMapRouter } from "./agent-map.js";
 
@@ -36,9 +30,12 @@ describe("createAgentMapRouter", () => {
     );
   });
 
-  async function start(planner?: {
-    planningSessions: PlanningSessionService;
-    plannerGreeting: PlannerGreetingCoordinator;
+  async function start(projectLifecycle?: {
+    onProjectCreated?: (project: StudioProjectSummary) => Promise<void> | void;
+    onRootBound?: (
+      project: StudioProjectSummary,
+      root: string,
+    ) => Promise<void> | void;
   }) {
     const stateRoot = await fs.mkdtemp(
       path.join(os.tmpdir(), "agent-map-router-"),
@@ -83,7 +80,7 @@ describe("createAgentMapRouter", () => {
         ],
         isWorkflowScanComplete: () => true,
         listWorkspaceScopes,
-        ...planner,
+        ...projectLifecycle,
       }),
     );
     server = app.listen(0);
@@ -142,7 +139,9 @@ describe("createAgentMapRouter", () => {
     expect(publicJson).not.toContain(fixture.privateRoot);
     expect(publicJson).not.toContain("workspace-private-alias");
     expect(fixture.onEvent).toHaveBeenCalledTimes(1);
-    expect(fixture.listWorkspaceScopes).toHaveBeenCalledTimes(2);
+    // Rendering durable map state is not a project-discovery boundary and
+    // therefore cannot create/schedule another project lifecycle.
+    expect(fixture.listWorkspaceScopes).not.toHaveBeenCalled();
   });
 
   it("creates a zero-binding project without eagerly creating map state", async () => {
@@ -174,6 +173,35 @@ describe("createAgentMapRouter", () => {
     ).rejects.toMatchObject({ code: "ENOENT" });
   });
 
+  it("acknowledges a committed project identity when lifecycle scheduling must retry", async () => {
+    const onProjectCreated = vi.fn(async () => {
+      throw new Error("transient coordinator failure");
+    });
+    const fixture = await start({ onProjectCreated });
+
+    const response = await fetch(`${fixture.baseUrl}/api/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Harness-Token": "test-token",
+      },
+      body: JSON.stringify({ displayName: "Durably created" }),
+    });
+    const created = (await response.json()) as StudioProjectSummary;
+
+    expect(response.status).toBe(202);
+    expect(response.headers.get("X-Sapiom-Project-Initialization")).toBe(
+      "pending",
+    );
+    expect(created.displayName).toBe("Durably created");
+    expect(onProjectCreated).toHaveBeenCalledOnce();
+    expect(
+      (await fixture.catalog.list()).filter(
+        (project) => project.projectId === created.projectId,
+      ),
+    ).toHaveLength(1);
+  });
+
   it("preserves identity when the authenticated boundary moves and adds root bindings", async () => {
     const fixture = await start();
     const movedRoot = path.join(fixture.stateRoot, "moved-market-research");
@@ -237,6 +265,86 @@ describe("createAgentMapRouter", () => {
     expect(restarted.projects[0]?.bindings).toHaveLength(2);
   });
 
+  it("matches a Windows allowlisted root across drive, case, and separator variants", async () => {
+    const fixture = await start();
+    fixture.scopes.splice(0, fixture.scopes.length, {
+      workspaceKey: "workspace-windows-project",
+      cwd: "C:\\Users\\Alice\\Project",
+    });
+
+    const response = await fetch(
+      `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/root-bindings`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Harness-Token": "test-token",
+        },
+        body: JSON.stringify({ root: "c:/users/alice/project/" }),
+      },
+    );
+
+    expect(response.status).toBe(201);
+    expect((await response.json()).projectId).toBe(fixture.project.projectId);
+  });
+
+  it("acknowledges durable root mutations and converges lifecycle retries without duplicate bindings", async () => {
+    const onRootBound = vi
+      .fn<(project: StudioProjectSummary, root: string) => Promise<void>>()
+      .mockRejectedValueOnce(new Error("transient add failure"))
+      .mockResolvedValueOnce()
+      .mockRejectedValueOnce(new Error("transient move failure"))
+      .mockResolvedValueOnce();
+    const fixture = await start({ onRootBound });
+    const addedRoot = path.join(fixture.stateRoot, "publisher-repository");
+    const movedRoot = path.join(fixture.stateRoot, "moved-market-research");
+    await Promise.all([fs.mkdir(addedRoot), fs.mkdir(movedRoot)]);
+    fixture.scopes.splice(
+      0,
+      fixture.scopes.length,
+      { workspaceKey: "workspace-publisher", cwd: addedRoot },
+      { workspaceKey: "workspace-moved", cwd: movedRoot },
+    );
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Harness-Token": "test-token",
+    };
+    const addRoute = `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/root-bindings`;
+    const add = () =>
+      fetch(addRoute, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ root: addedRoot }),
+      });
+
+    const pendingAdd = await add();
+    expect(pendingAdd.status).toBe(202);
+    expect(pendingAdd.headers.get("X-Sapiom-Project-Initialization")).toBe(
+      "pending",
+    );
+    expect((await add()).status).toBe(201);
+
+    const moveRoute = `${addRoute}/${fixture.project.bindings[0]!.id}`;
+    const move = () =>
+      fetch(moveRoute, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ root: movedRoot }),
+      });
+    const pendingMove = await move();
+    expect(pendingMove.status).toBe(202);
+    expect(pendingMove.headers.get("X-Sapiom-Project-Initialization")).toBe(
+      "pending",
+    );
+    expect((await move()).status).toBe(200);
+
+    expect(onRootBound).toHaveBeenCalledTimes(4);
+    const persisted = await fixture.catalog.resolve(fixture.project.projectId);
+    expect(persisted?.bindings).toHaveLength(2);
+    expect(JSON.stringify(persisted)).not.toContain(addedRoot);
+    expect(JSON.stringify(persisted)).not.toContain(movedRoot);
+  });
+
   it("does not expose root association without the boot token or allow list", async () => {
     const fixture = await start();
     const unknownRoot = path.join(fixture.stateRoot, "not-opened");
@@ -442,206 +550,4 @@ describe("createAgentMapRouter", () => {
     expect(await fs.readFile(workspacePath, "utf8")).toBe("{bad-json");
   });
 
-  it("protects planner routes and accepts only project-scoped intent", async () => {
-    let fixtureProjectId = "";
-    const plannerSession = {
-      id: "planner-session-1",
-      agentSessionId: null,
-      harness: "codex",
-      cwd: "/server/private/project",
-      title: "project",
-      status: "running",
-      createdAt: "2026-09-01T00:00:00.000Z",
-      lastActiveAt: "2026-09-01T00:00:00.000Z",
-      exitCode: null,
-      boundWorkflowPath: null,
-      ready: false,
-    } as HarnessSession;
-    const open = vi.fn(async () => ({
-      session: plannerSession,
-      resolution: "created" as const,
-    }));
-    const requireOwned = vi.fn(() => plannerSession);
-    const enqueue = vi.fn(async () => ({
-      identity: {
-        projectId: fixtureProjectId,
-        sessionId: plannerSession.id,
-        userId: "user-1",
-        role: "map-planner" as const,
-      },
-      greeting: { status: "pending" as const },
-      queuedInputIds: ["input-1"],
-    }));
-    const retry = vi.fn(async () => {
-      if (!plannerSession.planning) throw new Error("missing planner metadata");
-      plannerSession.planning = {
-        ...plannerSession.planning,
-        greeting: { status: "generating", attemptId: "attempt-2" },
-      };
-    });
-    const fixture = await start({
-      planningSessions: {
-        open,
-        requireOwned,
-      } as unknown as PlanningSessionService,
-      plannerGreeting: {
-        enqueue,
-        retry,
-      } as unknown as PlannerGreetingCoordinator,
-    });
-    fixtureProjectId = fixture.project.projectId;
-    plannerSession.planning = {
-      identity: {
-        projectId: fixtureProjectId,
-        sessionId: plannerSession.id,
-        userId: "user-1",
-        role: "map-planner",
-      },
-      greeting: {
-        status: "failed",
-        retryable: true,
-        errorCode: "model_turn_failed",
-      },
-      queuedInputIds: [],
-    };
-    const route = `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/planner-sessions`;
-
-    expect(
-      (
-        await fetch(route, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ mode: "fresh" }),
-        })
-      ).status,
-    ).toBe(401);
-    const forged = await fetch(route, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "X-Harness-Token": "test-token",
-      },
-      body: JSON.stringify({
-        mode: "fresh",
-        role: "map-planner",
-        projectId: fixture.project.projectId,
-      }),
-    });
-    expect(forged.status).toBe(400);
-    expect(open).not.toHaveBeenCalled();
-
-    const valid = await fetch(route, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "X-Harness-Token": "test-token",
-      },
-      body: JSON.stringify({ mode: "fresh", harness: "codex" }),
-    });
-    expect(valid.status).toBe(201);
-    expect(open).toHaveBeenCalledWith(fixture.project.projectId, {
-      mode: "fresh",
-      harness: "codex",
-    });
-
-    const message = await fetch(`${route}/${plannerSession.id}/messages`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "X-Harness-Token": "test-token",
-      },
-      body: JSON.stringify({ text: "Build a support triage system" }),
-    });
-    expect(message.status).toBe(202);
-    expect(await message.json()).toEqual({
-      metadata: {
-        identity: {
-          projectId: fixture.project.projectId,
-          sessionId: plannerSession.id,
-          userId: "user-1",
-          role: "map-planner",
-        },
-        greeting: { status: "pending" },
-        queuedInputIds: ["input-1"],
-      },
-    });
-    expect(requireOwned).toHaveBeenCalledWith(
-      fixture.project.projectId,
-      plannerSession.id,
-    );
-    expect(enqueue).toHaveBeenCalledWith(
-      plannerSession.id,
-      "Build a support triage system",
-    );
-
-    const retryResponse = await fetch(
-      `${route}/${plannerSession.id}/greeting/retry`,
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "X-Harness-Token": "test-token",
-        },
-        body: "{}",
-      },
-    );
-    expect(retryResponse.status).toBe(202);
-    expect(await retryResponse.json()).toEqual({
-      metadata: {
-        ...plannerSession.planning,
-        greeting: { status: "generating", attemptId: "attempt-2" },
-      },
-    });
-    expect(retry).toHaveBeenCalledWith(plannerSession.id);
-  });
-
-  it("rejects foreign planner messages and bounds unavailable retries", async () => {
-    const requireOwned = vi.fn<() => Promise<HarnessSession>>(async () => {
-      throw new PlanningSessionError("forbidden");
-    });
-    const enqueue = vi.fn(async () => ({}) as never);
-    const retry = vi.fn(async () => {
-      throw new PlannerGreetingRetryUnavailableError();
-    });
-    const fixture = await start({
-      planningSessions: {
-        open: vi.fn(),
-        requireOwned,
-      } as unknown as PlanningSessionService,
-      plannerGreeting: {
-        enqueue,
-        retry,
-      } as unknown as PlannerGreetingCoordinator,
-    });
-    const headers = {
-      "content-type": "application/json",
-      "X-Harness-Token": "test-token",
-    };
-    const message = await fetch(
-      `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/planner-sessions/foreign/messages`,
-      { method: "POST", headers, body: JSON.stringify({ text: "hello" }) },
-    );
-    expect(message.status).toBe(403);
-    expect(await message.json()).toMatchObject({ code: "forbidden" });
-    expect(enqueue).not.toHaveBeenCalled();
-
-    const forbiddenRetry = await fetch(
-      `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/planner-sessions/foreign/greeting/retry`,
-      { method: "POST", headers, body: "{}" },
-    );
-    expect(forbiddenRetry.status).toBe(403);
-    expect(await forbiddenRetry.json()).toMatchObject({ code: "forbidden" });
-    expect(retry).not.toHaveBeenCalled();
-
-    requireOwned.mockResolvedValue({ id: "owned" } as HarnessSession);
-    const retryResponse = await fetch(
-      `${fixture.baseUrl}/api/projects/${fixture.project.projectId}/planner-sessions/owned/greeting/retry`,
-      { method: "POST", headers, body: "{}" },
-    );
-    expect(retryResponse.status).toBe(409);
-    expect(await retryResponse.json()).toEqual({
-      code: "greeting_retry_unavailable",
-      error: "greeting retry is not available",
-    });
-  });
 });
diff --git a/packages/harness/src/server/agent-map.ts b/packages/harness/src/server/agent-map.ts
index cf83faa24..cb17497e7 100644
--- a/packages/harness/src/server/agent-map.ts
+++ b/packages/harness/src/server/agent-map.ts
@@ -1,16 +1,15 @@
 import { Router } from "express";
 import { z } from "zod";
-
 import {
   type AgentMapErrorCode,
   type AgentMapErrorResponse,
   type AgentMapWorkspaceResponse,
-  type PlannerMessageRequest,
-  type PlannerSessionRequest,
+  type StudioProjectSummary,
   type StudioWorkspaceSelection,
 } from "../shared/agent-map.js";
-import { SPAWNABLE_HARNESS_KINDS, type WorkflowInfo } from "../shared/types.js";
+import type { WorkflowInfo } from "../shared/types.js";
 import type { WorkspaceScopeSummary } from "../shared/system-graph.js";
+import { samePath } from "../shared/paths.js";
 import {
   AgentMapWorkspaceStore,
   AgentMapWorkspaceStoreError,
@@ -24,15 +23,6 @@ import {
   StudioWorkspacePreferenceStore,
   StudioWorkspacePreferenceStoreError,
 } from "../core/studio-workspace-preferences.js";
-import {
-  PlanningSessionError,
-  type PlanningSessionService,
-} from "../core/planning-session.js";
-import {
-  PlannerDispatchForbiddenError,
-  PlannerGreetingRetryUnavailableError,
-  type PlannerGreetingCoordinator,
-} from "../core/planner-greeting.js";
 
 export interface AgentMapRouterOptions {
   catalog: StudioProjectCatalog;
@@ -50,39 +40,12 @@ export interface AgentMapRouterOptions {
   listWorkspaceScopes: () =>
     | readonly WorkspaceScopeSummary[]
     | Promise<readonly WorkspaceScopeSummary[]>;
-  planningSessions?: PlanningSessionService;
-  plannerGreeting?: PlannerGreetingCoordinator;
-}
-
-const plannerSessionSchema = z
-  .object({
-    mode: z.enum(["resume-or-create", "fresh"]),
-    harness: z.enum(SPAWNABLE_HARNESS_KINDS).optional(),
-    theme: z.enum(["light", "dark"]).optional(),
-  })
-  .strict() satisfies z.ZodType<PlannerSessionRequest>;
-
-const plannerMessageSchema = z
-  .object({ text: z.string().min(1).max(100_000) })
-  .strict() satisfies z.ZodType<PlannerMessageRequest>;
-
-function sendPlanningError(
-  res: import("express").Response,
-  error: unknown,
-): boolean {
-  if (error instanceof PlannerDispatchForbiddenError) {
-    res.status(403).json({ code: error.code, error: error.message });
-    return true;
-  }
-  if (!(error instanceof PlanningSessionError)) return false;
-  const status =
-    error.code === "project_not_found" || error.code === "session_not_found"
-      ? 404
-      : error.code === "forbidden"
-        ? 403
-        : 409;
-  res.status(status).json({ code: error.code, error: error.message });
-  return true;
+  /** New-project lifecycle hooks; never called by Agent Map reads. */
+  onProjectCreated?: (project: StudioProjectSummary) => Promise<void> | void;
+  onRootBound?: (
+    project: StudioProjectSummary,
+    root: string,
+  ) => Promise<void> | void;
 }
 
 const ERROR_MESSAGES: Record<AgentMapErrorCode, string> = {
@@ -142,7 +105,7 @@ async function allowlistedScope(
   }
   for (const scope of await options.listWorkspaceScopes()) {
     try {
-      if (canonicalGraphPath(scope.cwd) === requested) return scope;
+      if (samePath(canonicalGraphPath(scope.cwd), requested)) return scope;
     } catch {
       // One malformed live scope cannot authorize or poison another root.
     }
@@ -160,9 +123,9 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
       res.status(400).json(errorBody("malformed_state"));
       return;
     }
+    let project: StudioProjectSummary;
     try {
-      const project = await options.catalog.create(parsed.data.displayName);
-      res.status(201).setHeader("Cache-Control", "no-store").json(project);
+      project = await options.catalog.create(parsed.data.displayName);
     } catch (error) {
       const bounded =
         error instanceof StudioProjectCatalogError
@@ -171,6 +134,21 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
       res
         .status(bounded === "storage_unavailable" ? 503 : 400)
         .json(errorBody(bounded));
+      return;
+    }
+    try {
+      await options.onProjectCreated?.(project);
+      res.status(201).setHeader("Cache-Control", "no-store").json(project);
+    } catch {
+      // The catalog commit already won. Report that stable identity instead of
+      // a 503 that invites a non-idempotent retry and creates a second project;
+      // lifecycle scheduling is project-keyed and may converge on root bind or
+      // startup recovery.
+      res
+        .status(202)
+        .setHeader("Cache-Control", "no-store")
+        .setHeader("X-Sapiom-Project-Initialization", "pending")
+        .json(project);
     }
   });
 
@@ -184,6 +162,8 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
       res.status(400).json(errorBody("malformed_state"));
       return;
     }
+    let updated: StudioProjectSummary;
+    let root: string;
     try {
       const project = await options.catalog.resolve(req.params.projectId);
       if (!project) {
@@ -195,12 +175,10 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
         res.status(404).json(errorBody("project_not_found"));
         return;
       }
-      const updated = await options.catalog.addRootBinding(
-        project.projectId,
-        scope.cwd,
-        { legacyWorkspaceKey: scope.workspaceKey },
-      );
-      res.status(201).setHeader("Cache-Control", "no-store").json(updated);
+      root = scope.cwd;
+      updated = await options.catalog.addRootBinding(project.projectId, root, {
+        legacyWorkspaceKey: scope.workspaceKey,
+      });
     } catch (error) {
       const bounded =
         error instanceof StudioProjectCatalogError
@@ -209,6 +187,20 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
       res
         .status(bounded === "storage_unavailable" ? 503 : 400)
         .json(errorBody(bounded));
+      return;
+    }
+    try {
+      await options.onRootBound?.(updated, root);
+      res.status(201).setHeader("Cache-Control", "no-store").json(updated);
+    } catch {
+      // The binding commit is already durable and idempotent. Preserve its
+      // stable identity while telling the client only that lifecycle work is
+      // pending; retrying this same association cannot append another binding.
+      res
+        .status(202)
+        .setHeader("Cache-Control", "no-store")
+        .setHeader("X-Sapiom-Project-Initialization", "pending")
+        .json(updated);
     }
   });
 
@@ -220,6 +212,8 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
         res.status(400).json(errorBody("malformed_state"));
         return;
       }
+      let updated: StudioProjectSummary;
+      let root: string;
       try {
         const project = await options.catalog.resolve(req.params.projectId);
         if (!project) {
@@ -231,13 +225,13 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
           res.status(404).json(errorBody("project_not_found"));
           return;
         }
-        const updated = await options.catalog.moveRootBinding(
+        root = scope.cwd;
+        updated = await options.catalog.moveRootBinding(
           project.projectId,
           req.params.bindingId,
-          scope.cwd,
+          root,
           scope.workspaceKey,
         );
-        res.status(200).setHeader("Cache-Control", "no-store").json(updated);
       } catch (error) {
         const bounded =
           error instanceof StudioProjectCatalogError
@@ -246,25 +240,34 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
         res
           .status(bounded === "storage_unavailable" ? 503 : 400)
           .json(errorBody(bounded));
+        return;
+      }
+      try {
+        await options.onRootBound?.(updated, root);
+        res.status(200).setHeader("Cache-Control", "no-store").json(updated);
+      } catch {
+        res
+          .status(202)
+          .setHeader("Cache-Control", "no-store")
+          .setHeader("X-Sapiom-Project-Initialization", "pending")
+          .json(updated);
       }
     },
   );
   const projectContext = async (projectId: string) => {
-    const reconciled = await options.catalog.reconcile(
-      await options.listWorkspaceScopes(),
-    );
     const project = await options.catalog.resolve(projectId);
     if (!project) return null;
+    const identity = await options.catalog.resolveIdentity(project.projectId);
+    if (!identity) return null;
     return {
       project,
-      roots: reconciled.workspaceScopes
-        .filter((scope) => scope.projectId === project.projectId)
-        .map((scope) => scope.cwd),
+      roots: identity.rootBindings
+        .filter((binding) => binding.status === "active")
+        .map((binding) => binding.localRootRef),
     };
   };
   router.get("/projects/:projectId/agent-map/workspace", async (req, res) => {
     try {
-      await options.catalog.reconcile(await options.listWorkspaceScopes());
       const project = await options.catalog.resolve(req.params.projectId);
       if (!project) {
         res.status(404).json(errorBody("project_not_found"));
@@ -358,86 +361,5 @@ export function createAgentMapRouter(options: AgentMapRouterOptions): Router {
     }
   });
 
-  router.post(
-    "/projects/:projectId/planner-sessions",
-    async (req, res, next) => {
-      if (!options.planningSessions || !options.plannerGreeting) {
-        res.status(501).json({ error: "Planner sessions are unavailable" });
-        return;
-      }
-      const parsed = plannerSessionSchema.safeParse(req.body);
-      if (!parsed.success) {
-        res.status(400).json({ error: "Invalid planner session request" });
-        return;
-      }
-      try {
-        await options.catalog.reconcile(await options.listWorkspaceScopes());
-        const result = await options.planningSessions.open(
-          req.params.projectId,
-          parsed.data,
-        );
-        res.status(result.resolution === "created" ? 201 : 200).json(result);
-      } catch (error) {
-        if (!sendPlanningError(res, error)) next(error);
-      }
-    },
-  );
-
-  router.post(
-    "/projects/:projectId/planner-sessions/:sessionId/messages",
-    async (req, res, next) => {
-      if (!options.planningSessions || !options.plannerGreeting) {
-        res.status(501).json({ error: "Planner sessions are unavailable" });
-        return;
-      }
-      const parsed = plannerMessageSchema.safeParse(req.body);
-      if (!parsed.success) {
-        res.status(400).json({ error: "Invalid planner message" });
-        return;
-      }
-      try {
-        await options.planningSessions.requireOwned(
-          req.params.projectId,
-          req.params.sessionId,
-        );
-        const metadata = await options.plannerGreeting.enqueue(
-          req.params.sessionId,
-          parsed.data.text,
-        );
-        res.status(202).json({ metadata });
-      } catch (error) {
-        if (!sendPlanningError(res, error)) next(error);
-      }
-    },
-  );
-
-  /** @deprecated Compatibility-only for sessions created before synthetic greeting removal. */
-  router.post(
-    "/projects/:projectId/planner-sessions/:sessionId/greeting/retry",
-    async (req, res, next) => {
-      if (!options.planningSessions || !options.plannerGreeting) {
-        res.status(501).json({ error: "Planner sessions are unavailable" });
-        return;
-      }
-      if (Object.keys((req.body ?? {}) as object).length > 0) {
-        res.status(400).json({ error: "Invalid greeting retry request" });
-        return;
-      }
-      try {
-        const session = await options.planningSessions.requireOwned(
-          req.params.projectId,
-          req.params.sessionId,
-        );
-        await options.plannerGreeting.retry(req.params.sessionId);
-        res.status(202).json({
-          metadata: session.planning,
-        });
-      } catch (error) {
-        if (error instanceof PlannerGreetingRetryUnavailableError) {
-          res.status(409).json({ code: error.code, error: error.message });
-        } else if (!sendPlanningError(res, error)) next(error);
-      }
-    },
-  );
   return router;
 }
diff --git a/packages/harness/src/server/auth-routes.ts b/packages/harness/src/server/auth-routes.ts
index 7c737c4ef..3705d13a1 100644
--- a/packages/harness/src/server/auth-routes.ts
+++ b/packages/harness/src/server/auth-routes.ts
@@ -118,6 +118,8 @@ export interface AuthRoutesOptions {
   performBrowserAuthImpl?: typeof performBrowserAuth;
   /** Server-private identity projection for authorization consumers. It is
    * intentionally not added to AuthState or any browser response. */
+  onProjectUserChanged?: (userId: string | null) => void;
+  /** @deprecated Use onProjectUserChanged; remove in SAP-3152. */
   onPlanningUserChanged?: (userId: string | null) => void;
 }
 
@@ -136,8 +138,11 @@ export function createAuthRouter(opts: AuthRoutesOptions): Router {
     authEnabled = true,
     environment,
     performBrowserAuthImpl = performBrowserAuth,
+    onProjectUserChanged,
     onPlanningUserChanged,
   } = opts;
+  const notifyProjectUserChanged =
+    onProjectUserChanged ?? onPlanningUserChanged;
 
   // Track any in-flight start() call so a second concurrent POST /api/auth/start
   // returns a clear error rather than racing two browser-open flows.
@@ -215,7 +220,7 @@ export function createAuthRouter(opts: AuthRoutesOptions): Router {
         // CLI identity uses tenantId as HarnessIdentity.userId. Update the
         // private live principal in the same committed transition as auth;
         // never expose it in the public auth status payload.
-        onPlanningUserChanged?.(result.tenantId);
+        notifyProjectUserChanged?.(result.tenantId);
         bus.publish({
           type: "auth.changed",
           authenticated: true,
@@ -270,7 +275,7 @@ export function createAuthRouter(opts: AuthRoutesOptions): Router {
       apiKeyProvider.clear();
 
       authState.set({ authenticated: false, organizationName: null });
-      onPlanningUserChanged?.(null);
+      notifyProjectUserChanged?.(null);
       bus.publish({
         type: "auth.changed",
         authenticated: false,
diff --git a/packages/harness/src/server/index.ts b/packages/harness/src/server/index.ts
index 1fde5b7d9..d4cb25a4a 100644
--- a/packages/harness/src/server/index.ts
+++ b/packages/harness/src/server/index.ts
@@ -1,5 +1,3 @@
-import { projectRoots, projectSessionRoot } from "../shared/project-roots.js";
-import { samePath } from "../shared/paths.js";
 /**
  * Harness server — integration point for every workstream.
  *
@@ -28,16 +26,32 @@ import type {
   HarnessAdapter,
   HarnessKind,
   HarnessSession,
+  SessionInputSubmissionResult,
   SessionRecord,
   SystemPromptDelivery,
   WorkflowInfo,
 } from "../shared/types.js";
 import { JSON_BODY_LIMIT_BYTES } from "../shared/types.js";
-import type { PlannerLifecycleEvent } from "../shared/agent-map.js";
+import type {
+  ProjectBootstrapLifecycleEvent,
+  ProjectAgentSession,
+  StudioProjectSummary,
+} from "../shared/agent-map.js";
+import {
+  preferredProjectRoot,
+  projectRoots,
+  projectSessionRoot,
+} from "../shared/project-roots.js";
+import { samePath } from "../shared/paths.js";
 import { unhandledRequestErrorHandler } from "./error-handler.js";
 import { expandHome, resolveStatePaths } from "../core/paths.js";
 import {
+  AdapterNotFoundError,
+  ExternalHarnessError,
+  ProjectBootstrapClaimUnavailableError,
+  ProjectSessionScopeUnavailableError,
   SessionManager,
+  SessionManagerClosingError,
   type LaunchOptsBuilder,
 } from "../core/session-manager.js";
 import { TaskManager } from "../core/task-manager.js";
@@ -80,11 +94,7 @@ import { migrateHarnessIdentity } from "../core/collector/identity-migration.js"
 import { normalizeHookEvent } from "../core/collector/normalizer.js";
 import { enrichTurnCompleted } from "../core/collector/transcript.js";
 import { createSeqCounter } from "../core/collector/seq.js";
-import {
-  findRolloutFile,
-  tailCodexRollout,
-  type CodexTailerHandle,
-} from "../core/collector/codex-tailer.js";
+import { findRolloutFile, tailCodexRollout, type CodexTailerHandle } from "../core/collector/codex-tailer.js";
 import { getOrCreateMachineId } from "../cli/machine-id.js";
 import { loadSettings, pruneDeadRecentDirs } from "../cli/settings.js";
 import type { HarnessIdentity } from "../cli/auth.js";
@@ -101,8 +111,6 @@ import {
 } from "../core/inject/retention.js";
 import { DEFAULT_SYSTEM_PROMPT } from "../profiles/default.js";
 import { projectAgentPromptAppendix } from "../profiles/project-agent.js";
-import { ProjectSessionScopeUnavailableError, SessionNotReadyError } from "../core/session-manager.js";
-import { localProjectPrincipal } from "../core/project-session.js";
 import { fetchSystemPromptForActiveEnvironment } from "../profiles/system-prompt-fetch.js";
 import { agentCoreTemplatesDir } from "../core/agent-core-templates.js";
 import { CanvasWatcherManager } from "../core/canvas-watcher.js";
@@ -166,7 +174,11 @@ import {
   AgentMapCapabilityRegistry,
   type AgentMapCapabilityEvent,
 } from "../core/agent-map-capability-registry.js";
-import { StudioProjectCatalog } from "../core/studio-project-catalog.js";
+import {
+  StudioProjectCatalog,
+  type ReconciledStudioProjects,
+} from "../core/studio-project-catalog.js";
+import { ProjectBootstrapOutbox } from "../core/project-bootstrap-outbox.js";
 import {
   createAgentMapMcpRouter,
   type AgentMapMcpRouter,
@@ -174,11 +186,14 @@ import {
 import { AgentMapMcpProjectUnavailableError } from "./agent-map-mcp-tools.js";
 import { StudioWorkspacePreferenceStore } from "../core/studio-workspace-preferences.js";
 import {
-  isPlannerDispatchAuthorized,
-  localPlanningPrincipal,
-  PlanningSessionService,
-} from "../core/planning-session.js";
-import { PlannerDispatchForbiddenError, PlannerGreetingCoordinator } from "../core/planner-greeting.js";
+  isProjectSessionDispatchAuthorized,
+  localProjectPrincipal,
+} from "../core/project-session.js";
+import { legacyProjectSessionStateRoot } from "../core/project-session-legacy-migration.js";
+import {
+  ProjectBootstrapCoordinator,
+  ProjectBootstrapCoordinatorClosedError,
+} from "../core/project-bootstrap.js";
 import { IngestCredentialRegistry } from "../core/ingest-credentials.js";
 import { createStaticRouter } from "./static.js";
 import { createTerminalWebSocketHandler } from "./terminal-ws.js";
@@ -365,6 +380,12 @@ export interface HarnessServerOptions {
       workflowPath: string,
     ) => void | Promise<void>;
   };
+  /** Internal deterministic seam for project/bootstrap crash-window tests. */
+  projectBootstrapTestHooks?: {
+    beforeSchedule?: (projectId: string) => void | Promise<void>;
+    afterProjectSessionNeeded?: (projectId: string) => void | Promise<void>;
+    afterListenBeforeRecovery?: (port: number) => void | Promise<void>;
+  };
 }
 
 export interface HarnessServer {
@@ -662,10 +683,29 @@ export const startServer = async (
     organizationName: identity?.organizationName ?? null,
   });
   const statePaths = resolveStatePaths(options.stateRoot);
+  const projectBootstrapOutbox = new ProjectBootstrapOutbox(
+    join(statePaths.projectBootstrap, "project-outbox"),
+  );
+  let afterStudioProjectsCreatedCommit = async (
+    _projects: readonly StudioProjectSummary[],
+  ): Promise<void> => {};
+  let convergeReconciledProjectLifecycle = async (
+    _reconciled: ReconciledStudioProjects,
+  ): Promise<void> => {};
   const studioProjectCatalog = new StudioProjectCatalog(
     statePaths.studioProjects,
+    undefined,
+    undefined,
+    {
+      beforeProjectsCreatedCommit: (projects) =>
+        projectBootstrapOutbox.stage(projects),
+      afterProjectsCreatedCommit: (projects) =>
+        afterStudioProjectsCreatedCommit(projects),
+    },
   );
-  let emitAgentMapCapabilityEvent = (_event: AgentMapCapabilityEvent): void => {};
+  let emitAgentMapCapabilityEvent = (
+    _event: AgentMapCapabilityEvent,
+  ): void => {};
   const agentMapCapabilities = new AgentMapCapabilityRegistry({
     onEvent: (event) => emitAgentMapCapabilityEvent(event),
   });
@@ -676,7 +716,7 @@ export const startServer = async (
   // Authentication may change in-app without restarting Studio. Keep the
   // planning principal live and server-private; browser auth DTOs expose only
   // their existing boolean/organization fields.
-  let planningUserId = identity?.userId ?? null;
+  let projectUserId = identity?.userId ?? null;
 
   // One-way identity migration: seed ~/.sapiom/analytics.json from the
   // legacy harness machine-id so existing installs keep the same anonymous_id
@@ -821,14 +861,28 @@ export const startServer = async (
     console.error("[harness] recent-dirs prune failed:", err);
   }
   let workflowsCache: RegistryWorkflowInfo[] = await workflowRegistry.list();
-  // Assigned after constructing callbacks which need the live manager.
+  // Assigned once after callback construction; those callbacks need the live
+  // binding before SessionManager itself can be instantiated.
   // eslint-disable-next-line prefer-const
   let sessionManager!: SessionManager;
+  let projectBootstrap: ProjectBootstrapCoordinator | null = null;
   const pendingProjectCwds = new Set<string>();
-  const workspaceScopeCatalog = new LocalWorkspaceScopeCatalog(async () => [
-    ...(await loadSettings(statePaths.settings)).recentDirs,
-    ...(sessionManager ? sessionManager.list().map((session) => session.cwd) : []),
-  ]);
+  const rawProjectRoots = async (): Promise<string[]> => {
+    const settings = await loadSettings(statePaths.settings);
+    return [
+      ...pendingProjectCwds,
+      ...(sessionManager ? sessionManager.listPendingCreates().map((session) => session.cwd) : []),
+      ...settings.recentDirs,
+      ...(sessionManager
+        ? sessionManager.list().map((session) => session.cwd)
+        : []),
+    ];
+  };
+  // Legacy System Graph routes retain every explicitly known root. Studio's
+  // durable project catalog uses the canonical derivation below; keeping the
+  // two catalogs separate avoids changing the existing graph authority while
+  // project/session identity converges on one server/client contract.
+  const workspaceScopeCatalog = new LocalWorkspaceScopeCatalog(rawProjectRoots);
   const studioWorkspaceScopeCatalog = new LocalWorkspaceScopeCatalog(
     async () => {
       const settings = await loadSettings(statePaths.settings);
@@ -854,7 +908,17 @@ export const startServer = async (
       const retainedProjectSessionRoots = new Set<string>();
       // Pending launches contribute their trusted PROJECT root just like live
       // sessions, not a descendant cwd that would mint a competing project.
-      const pendingCwds = [...pendingProjectCwds];
+      const pendingCwds = [
+        ...pendingProjectCwds,
+        ...(sessionManager ? sessionManager.listPendingCreates() : []).flatMap((session) => {
+          if (!session.agentMapIdentity) return [session.cwd];
+          const root = projectSessionRoot(
+            { cwd: session.cwd, projectId: session.agentMapIdentity.projectId },
+            durableRootCandidates,
+          );
+          return root ? [root] : [];
+        }),
+      ];
       const sessions = sessionManager
         ? sessionManager.list().flatMap((session) => {
             if (!session.agentMapIdentity) {
@@ -935,7 +999,6 @@ export const startServer = async (
       ];
     },
   );
-
   const initialInventorySnapshot =
     await workflowRegistry.inventorySnapshot(launchDir);
   type AcceptedCanonicalWorkflowRoot = {
@@ -1119,6 +1182,7 @@ export const startServer = async (
   // manager, because the "exited" handler archives through it.
   const recordsRoot = options.recordsRoot ?? statePaths.records;
   const recordArchive = createRecordArchive({ root: recordsRoot });
+  const pendingRecordArchives = new Set<Promise<void>>();
 
   // Past-session transcripts, rebuilt from the events above rather than from
   // any vendor's history file — the same code path for claude-code and codex.
@@ -1154,9 +1218,14 @@ export const startServer = async (
     await recordArchive.sweep();
   };
   const archiveSessionRecordDetached = (harnessSessionId: string): void => {
-    void archiveSessionRecord(harnessSessionId).catch((err: unknown) => {
-      console.error("[harness] session record archive failed:", err);
-    });
+    const operation = archiveSessionRecord(harnessSessionId)
+      .catch((err: unknown) => {
+        console.error("[harness] session record archive failed:", err);
+      })
+      .finally(() => {
+        pendingRecordArchives.delete(operation);
+      });
+    pendingRecordArchives.add(operation);
   };
 
   // Exit-time deletion of generated/<id> (see the onStatusChange handler
@@ -1277,6 +1346,51 @@ export const startServer = async (
     }
   };
 
+  const projectIdentityMigrationEvents: Array<{
+    sessionId: string;
+    outcome: "migrated" | "rejected";
+  }> = [];
+  let projectScopeResolutionQueue: Promise<void> = Promise.resolve();
+  const serializeProjectScopeResolution = <T>(
+    operation: () => Promise<T>,
+  ): Promise<T> => {
+    const result = projectScopeResolutionQueue.catch(() => {}).then(operation);
+    projectScopeResolutionQueue = result.then(
+      () => {},
+      () => {},
+    );
+    return result;
+  };
+  // A catalog mutation is durable before its lifecycle callback runs. Retain
+  // any not-yet-scheduled project IDs in memory so a retry can converge on the
+  // same project instead of creating another one after a transient failure.
+  const projectsAwaitingBootstrapSchedule = new Set<string>();
+  const scheduleBootstrapProjects = async (
+    projectIds: Iterable<string>,
+    userId: string,
+    scopeSessionId: string,
+  ): Promise<void> => {
+    const ids = [...new Set(projectIds)].sort();
+    for (const projectId of ids) {
+      projectsAwaitingBootstrapSchedule.add(projectId);
+    }
+    for (const projectId of ids) {
+      if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+        throw new ProjectSessionScopeUnavailableError(scopeSessionId);
+      }
+      if (!projectBootstrap) {
+        throw new Error("project bootstrap coordinator is unavailable");
+      }
+      await options.projectBootstrapTestHooks?.beforeSchedule?.(projectId);
+      await projectBootstrap.scheduleProject(projectId, userId);
+      await projectBootstrapOutbox.complete(projectId);
+      if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+        throw new ProjectSessionScopeUnavailableError(scopeSessionId);
+      }
+      projectsAwaitingBootstrapSchedule.delete(projectId);
+    }
+  };
+
   sessionManager = new SessionManager({
     adapters,
     ingestUrl: `http://${host}:${options.port}`,
@@ -1285,38 +1399,120 @@ export const startServer = async (
     sessionsPath: options.sessionsPath ?? statePaths.sessions,
     buildLaunchOpts,
     resolveAgentMapIdentity: async (sessionId, cwd, persisted) => {
-      const userId = localProjectPrincipal(planningUserId, machineId);
-      const assertPrincipal = (): void => {
-        if (localProjectPrincipal(planningUserId, machineId) !== userId) {
+      const userId = localProjectPrincipal(projectUserId, machineId);
+      return serializeProjectScopeResolution(async () => {
+        const assertPrincipal = (): void => {
+          if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+            throw new ProjectSessionScopeUnavailableError(sessionId);
+          }
+        };
+        const identityFor = (projectId: string): ProjectAgentSession => ({
+          projectId,
+          sessionId,
+          userId,
+        });
+        assertPrincipal();
+        if (
+          persisted &&
+          (persisted.sessionId !== sessionId || persisted.userId !== userId)
+        ) {
           throw new ProjectSessionScopeUnavailableError(sessionId);
         }
-      };
-      if (persisted && (persisted.sessionId !== sessionId || persisted.userId !== userId)) {
-        throw new ProjectSessionScopeUnavailableError(sessionId);
-      }
-      let project = await studioProjectCatalog.resolveIdentityForPath(cwd);
-      assertPrincipal();
-      if (persisted) {
-        if (!project || project.projectId !== persisted.projectId) throw new ProjectSessionScopeUnavailableError(sessionId);
-      } else if (!project) {
-        await studioProjectCatalog.reconcile(await studioWorkspaceScopeCatalog.list());
+
+        // Resume/final-spawn validation is read-only. In particular, never add
+        // a descendant cwd as a candidate root before proving that the current
+        // durable project still owns it.
+        let project = await studioProjectCatalog.resolveIdentityForPath(cwd);
+        assertPrincipal();
+        if (persisted) {
+          if (!project || project.projectId !== persisted.projectId) {
+            throw new ProjectSessionScopeUnavailableError(sessionId);
+          }
+          return identityFor(project.projectId);
+        }
+
+        if (project) {
+          if (projectsAwaitingBootstrapSchedule.has(project.projectId)) {
+            await scheduleBootstrapProjects(
+              [project.projectId],
+              userId,
+              sessionId,
+            );
+          }
+          return identityFor(project.projectId);
+        }
+
+        const before = new Set(
+          (await studioProjectCatalog.list()).map(
+            (candidate) => candidate.projectId,
+          ),
+        );
+        assertPrincipal();
+        let reconciled = await studioProjectCatalog.reconcile(
+          await studioWorkspaceScopeCatalog.list(),
+        );
         assertPrincipal();
         project = await studioProjectCatalog.resolveIdentityForPath(cwd);
+
         if (!project) {
           pendingProjectCwds.add(cwd);
           try {
-            await studioProjectCatalog.reconcile(await studioWorkspaceScopeCatalog.list());
+            reconciled = await studioProjectCatalog.reconcile(
+              await studioWorkspaceScopeCatalog.list(),
+            );
             assertPrincipal();
             project = await studioProjectCatalog.resolveIdentityForPath(cwd);
-          } finally { pendingProjectCwds.delete(cwd); }
+          } finally {
+            pendingProjectCwds.delete(cwd);
+          }
         }
+        assertPrincipal();
+        const createdProjectIds = reconciled.projects
+          .map((candidate) => candidate.projectId)
+          .filter((projectId) => !before.has(projectId));
+        await scheduleBootstrapProjects(createdProjectIds, userId, sessionId);
+        if (!project) return undefined;
+        return identityFor(project.projectId);
+      });
+    },
+    prepareProjectSession: async (identity, request) => {
+      if (localProjectPrincipal(projectUserId, machineId) !== identity.userId) {
+        throw new ProjectSessionScopeUnavailableError(identity.sessionId);
+      }
+      const metadata = await projectBootstrap?.claimProject(
+        identity,
+        request.initialUserInputPending === true ||
+          Boolean(request.rehydrateFrom),
+      );
+      if (localProjectPrincipal(projectUserId, machineId) !== identity.userId) {
+        throw new ProjectSessionScopeUnavailableError(identity.sessionId);
+      }
+      return metadata
+        ? { initialTitle: "Plan Agents", projectBootstrap: metadata }
+        : {};
+    },
+    onTerminalInput: (sessionId, context) =>
+      projectBootstrap?.onTerminalInput(sessionId, context),
+    onRuntimeEpochTransition: async (session, runtimeEpoch) => {
+      if (!session.projectBootstrap) return;
+      if (!projectBootstrap) {
+        throw new Error("project bootstrap coordinator unavailable");
       }
-      assertPrincipal();
-      return project ? { projectId: project.projectId, sessionId, userId } : undefined;
+      await projectBootstrap.transitionRuntimeEpoch(session, runtimeEpoch);
+    },
+    onProjectAgentIdentityMigration: (event) => {
+      projectIdentityMigrationEvents.push(event);
+    },
+    onProjectBootstrapSession: async (session, mode, runtimeEpoch) => {
+      await projectBootstrap?.register(session, {
+        emptyProject: true,
+        mode,
+      }, runtimeEpoch);
     },
     onAgentMapSessionExit: async (sessionId) => {
       agentMapCapabilities.revokeSession(sessionId);
       await agentMapMcp?.revokeSession(sessionId);
+      await projectBootstrap?.releaseSessionClaim(sessionId);
     },
     // Every session gets its initial harness-context.json regardless of
     // entry point (REST, autoCreateSession) — see SessionManager.create().
@@ -2502,7 +2698,9 @@ export const startServer = async (
     let scopes = await workspaceScopeCatalog.list();
     try {
       const studioScopes = await studioWorkspaceScopeCatalog.list();
-      const reconciled = (await studioProjectCatalog.reconcile(studioScopes)).workspaceScopes;
+      const reconciliation = await studioProjectCatalog.reconcile(studioScopes);
+      await convergeReconciledProjectLifecycle(reconciliation);
+      const reconciled = reconciliation.workspaceScopes;
       // Both catalogs key canonical filesystem roots. Cwd retains its display
       // spelling and can be a symlink alias; prefer reconciled project metadata.
       const byWorkspaceKey = new Map(
@@ -2695,7 +2893,7 @@ export const startServer = async (
   // Fire-and-forget: boot must not wait on it. The cost is one full index build
   // (~130 ms against a 50 MB log), which the first history open would have paid
   // anyway.
-  void backfillSessionRecords({
+  const recordBackfill = backfillSessionRecords({
     conversationIds: () => sessionRecordReader.conversationIds(),
     readFromEvents: (id) => sessionRecordReader.readFromEvents(id),
     archive: recordArchive,
@@ -2750,7 +2948,9 @@ export const startServer = async (
   // and createIngestRouter) so the uiTrack closure can reference it lazily.
   const seqCounter = createSeqCounter();
 
-  const emitPlannerLifecycle = (event: PlannerLifecycleEvent): void => {
+  const emitProjectBootstrapLifecycle = (
+    event: ProjectBootstrapLifecycleEvent,
+  ): void => {
     const session = sessionManager.get(event.sessionId);
     const analyticsEvent: AnalyticsEvent = {
       eventId: randomUUID(),
@@ -2760,42 +2960,65 @@ export const startServer = async (
       tenantId: identity?.tenantId ?? null,
       machineId,
       harnessSessionId: event.sessionId,
-      // Planner lifecycle correlation uses the server-owned harness session.
+      // Bootstrap lifecycle correlation uses the server-owned harness session.
       // Provider session identity is unnecessary and may originate in a hook.
       agentSessionId: null,
       harness: session?.harness ?? "claude-code",
       type: event.name,
       payload: {
         project_id: event.projectId,
-        ...("resolution" in event
-          ? { resolution: event.resolution }
-          : {
+        ...("queueDepth" in event
+          ? {
               queue_depth: Math.max(0, Math.min(10_000, event.queueDepth)),
-              ...("attemptId" in event && event.attemptId
-                ? { attempt_id: event.attemptId }
-                : {}),
-              ...(event.name === "planner_greeting.failed"
-                ? {
-                    error_code: event.errorCode,
-                    retryable: event.retryable,
-                  }
-                : {}),
-              ...(event.name === "planner_greeting.skipped"
-                ? { reason: event.reason }
-                : {}),
-              ...(event.name === "planner_session.input_delivery_uncertain"
-                ? {
-                    input_id: event.inputId,
-                    error_code: event.errorCode,
-                  }
-                : {}),
-            }),
+            }
+          : {}),
+        ...("attemptId" in event && event.attemptId
+          ? { attempt_id: event.attemptId }
+          : {}),
+        ...("retryOrdinal" in event
+          ? { retry_ordinal: event.retryOrdinal }
+          : {}),
+        ...("retryable" in event
+          ? {
+              error_code: event.errorCode,
+              retryable: event.retryable,
+            }
+          : {}),
+        ...("reason" in event ? { reason: event.reason } : {}),
+        ...("inputId" in event
+          ? {
+              input_id: event.inputId,
+              error_code: event.errorCode,
+            }
+          : {}),
       },
     };
     void eventStore.append(analyticsEvent).catch(() => {});
     batcher.enqueue(analyticsEvent);
   };
 
+  for (const migration of projectIdentityMigrationEvents.splice(0)) {
+    const migrationEvent: AnalyticsEvent = {
+      eventId: randomUUID(),
+      seq: seqCounter.next(migration.sessionId),
+      ts: new Date().toISOString(),
+      userId: identity?.userId ?? null,
+      tenantId: identity?.tenantId ?? null,
+      machineId,
+      harnessSessionId: migration.sessionId,
+      agentSessionId: null,
+      harness:
+        sessionManager.get(migration.sessionId)?.harness ?? "claude-code",
+      type:
+        migration.outcome === "migrated"
+          ? "project_agent.identity_migrated"
+          : "project_agent.identity_rejected",
+      payload: { outcome: migration.outcome },
+    };
+    void eventStore.append(migrationEvent).catch(() => {});
+    batcher.enqueue(migrationEvent);
+  }
+
   const agentMapWorkspaceStore = new AgentMapWorkspaceStore(
     statePaths.agentMap,
     {
@@ -2909,6 +3132,7 @@ export const startServer = async (
   ): Promise<RegistryWorkflowInfo[]> => {
     const scopes = await studioWorkspaceScopeCatalog.list();
     const reconciled = await studioProjectCatalog.reconcile(scopes);
+    await convergeReconciledProjectLifecycle(reconciled);
     const projects = reconciled.projects;
     const annotations = new Map<
       string,
@@ -2944,95 +3168,282 @@ export const startServer = async (
     });
   };
 
-  const plannerGreeting = new PlannerGreetingCoordinator({
-    root: statePaths.plannerSessions,
+  const isMeaningfullyEmptyProject = async (
+    projectId: string,
+  ): Promise<boolean> => {
+    const snapshot = await agentMapProposalService.read(projectId);
+    return (
+      snapshot.workspace.confirmedRevisionId === null &&
+      snapshot.workspace.projectBuildPlanId === null &&
+      (snapshot.proposal === null ||
+        (snapshot.proposal.nodes.length === 0 &&
+          snapshot.proposal.relationships.length === 0))
+    );
+  };
+  projectBootstrap = new ProjectBootstrapCoordinator({
+    root: statePaths.projectBootstrap,
+    legacyStateRoot: legacyProjectSessionStateRoot(statePaths.root),
     sessionManager,
     canDispatch: (session) =>
-      isPlannerDispatchAuthorized({
+      isProjectSessionDispatchAuthorized({
         session,
-        currentPrincipal: () =>
-          localPlanningPrincipal(planningUserId, machineId),
+        currentPrincipal: () => localProjectPrincipal(projectUserId, machineId),
         resolveProject: (projectId) =>
           studioProjectCatalog.resolveIdentity(projectId),
       }),
-    onEvent: emitPlannerLifecycle,
+    isMeaningfullyEmpty: isMeaningfullyEmptyProject,
+    onEvent: emitProjectBootstrapLifecycle,
   });
+  afterStudioProjectsCreatedCommit = async (projects) => {
+    try {
+      await scheduleBootstrapProjects(
+        projects.map((project) => project.projectId),
+        localProjectPrincipal(projectUserId, machineId),
+        "unclaimed",
+      );
+    } catch {
+      // The catalog and its write-ahead markers are already durable. Do not
+      // turn a successfully allocated project into an apparent create failure;
+      // every reconciliation boundary retries the project-keyed schedule.
+      console.error("[harness] project bootstrap scheduling deferred");
+    }
+  };
+  try {
+    const pending = await projectBootstrapOutbox.pending();
+    const recoverableProjectIds: string[] = [];
+    for (const entry of pending) {
+      if (await studioProjectCatalog.resolve(entry.projectId)) {
+        recoverableProjectIds.push(entry.projectId);
+      } else {
+        // A write-ahead marker whose catalog transaction never committed is
+        // an expected crash artifact, not a project to recreate implicitly.
+        await projectBootstrapOutbox.complete(entry.projectId);
+      }
+    }
+    await scheduleBootstrapProjects(
+      recoverableProjectIds,
+      localProjectPrincipal(projectUserId, machineId),
+      "unclaimed",
+    );
+  } catch {
+    // Leave every unresolved marker durable for the next boot. Logging uses a
+    // fixed classification because entries and storage paths are private.
+    console.error("[harness] project bootstrap outbox recovery failed");
+  }
   for (const session of sessionManager.list()) {
-    if (!session.planning) continue;
+    if (!session.projectBootstrap) continue;
     let emptyProject = true;
     try {
-      const workspace = await agentMapWorkspaceStore.readOrCreate(
-        session.planning.identity.projectId,
+      emptyProject = await isMeaningfullyEmptyProject(
+        session.projectBootstrap.projectId,
       );
-      emptyProject =
-        workspace.confirmedRevisionId === null &&
-        workspace.activeProposalId === null &&
-        workspace.projectBuildPlanId === null;
     } catch {
       // Registration still recovers generating state and preserves its FIFO;
       // the project route will surface any unavailable workspace later.
     }
-    await plannerGreeting
-      .register(session, { emptyProject, mode: "boot" })
-      .catch((error: unknown) => {
-        console.error(
-          `[harness] planner registration failed for ${session.id}:`,
-          error instanceof Error ? error.message : "unknown error",
-        );
+    await projectBootstrap
+      .register(session, { emptyProject, mode: "boot" }, null)
+      .catch(() => {
+        // Session IDs and storage/provider errors stay out of logs. The
+        // coordinator emits its bounded lifecycle classification separately.
+        console.error("[harness] project bootstrap registration failed");
       });
   }
-  const planningSessions = new PlanningSessionService({
-    catalog: studioProjectCatalog,
-    workspaceStore: agentMapWorkspaceStore,
-    sessionManager,
-    readRecord: (id) => sessionRecordReader.read(id),
-    userId: identity?.userId ?? null,
-    currentUserId: () => planningUserId,
-    machineId,
-    defaultHarness: options.defaultHarnessKind ?? "claude-code",
-    // E1 owns the durable workspace pointers, but not the later revision,
-    // proposal, or build-plan detail records. Wire that shipped source
-    // explicitly so the focused-context contract emits honest null/empty
-    // detail slots today and has one allowlisted adapter boundary when those
-    // stores land; it must never fall back to scanning project files.
-    readFocusedContext: async (_projectId, workspace) => ({
-      confirmedRevision:
-        workspace.confirmedRevisionId === null
-          ? null
-          : { digest: null, summaries: [] },
-      activeProposal:
-        workspace.activeProposalId === null
-          ? null
-          : { status: null, summary: null },
-      projectBuildPlan:
-        workspace.projectBuildPlanId === null
-          ? null
-          : { status: null, summary: null },
-      warnings: [],
-    }),
-    onPlannerSession: (session, context) =>
-      plannerGreeting.register(session, context),
-    onEvent: emitPlannerLifecycle,
-  });
-  sessionManager.onStatusChange((session) => {
-    void plannerGreeting.onSessionStatus(session).catch((error: unknown) => {
-      console.error(
-        "[harness] planner greeting status transition failed:",
-        error,
-      );
+  sessionManager.onStatusChange((session, { runtimeEpoch }) => {
+    void projectBootstrap!.onSessionStatus(session, runtimeEpoch).catch(() => {
+      console.error("[harness] project bootstrap status transition failed");
     });
   });
+  const projectFirstSessionStarts = new Map<string, Promise<void>>();
+  const ensureProjectFirstSession = (
+    projectId: string,
+    root: string,
+  ): Promise<void> => {
+    const existing = projectFirstSessionStarts.get(projectId);
+    if (existing) return existing;
+    const operation = (async () => {
+      const userId = localProjectPrincipal(projectUserId, machineId);
+      if (!(await projectBootstrap!.needsProjectSession(projectId, userId))) {
+        return;
+      }
+      await options.projectBootstrapTestHooks?.afterProjectSessionNeeded?.(
+        projectId,
+      );
+      try {
+        await sessionManager.create(
+          {
+            cwd: root,
+            harness: options.defaultHarnessKind ?? "claude-code",
+          },
+          { requireProjectBootstrapClaim: true },
+        );
+      } catch (error) {
+        // An explicit ordinary create may have claimed and published the first
+        // session after needsProjectSession() returned. That is successful
+        // convergence, not a reason to spawn an unrequested second session.
+        if (error instanceof ProjectBootstrapClaimUnavailableError) return;
+        // Embedded/test hosts may intentionally register no local adapter, and
+        // an external-only adapter cannot own a Studio PTY. Keep the durable
+        // project bootstrap intent unclaimed so a later boot with an available
+        // ordinary adapter can converge it. Generic user-created sessions still
+        // surface these errors through their existing request path.
+        if (
+          error instanceof AdapterNotFoundError ||
+          error instanceof ExternalHarnessError
+        ) {
+          console.error(
+            "[harness] project bootstrap session start deferred: adapter_unavailable",
+          );
+          return;
+        }
+        // Shutdown can race a queued reconciliation callback. The coordinator
+        // and outbox are already durable, so there is no work to resurrect in
+        // a server that is closing.
+        if (error instanceof SessionManagerClosingError) return;
+        throw error;
+      }
+      if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+        throw new ProjectSessionScopeUnavailableError("unclaimed");
+      }
+    })();
+    projectFirstSessionStarts.set(projectId, operation);
+    void operation.then(
+      () => {
+        if (projectFirstSessionStarts.get(projectId) === operation) {
+          projectFirstSessionStarts.delete(projectId);
+        }
+      },
+      () => {
+        if (projectFirstSessionStarts.get(projectId) === operation) {
+          projectFirstSessionStarts.delete(projectId);
+        }
+      },
+    );
+    return operation;
+  };
+
+  convergeReconciledProjectLifecycle = async (reconciled) => {
+    const userId = localProjectPrincipal(projectUserId, machineId);
+    // A prior post-commit attempt may have failed after its marker was
+    // durable. Reconciliation is an idempotent opportunity to finish those
+    // exact new-project lifecycles; projects without an intent remain inert.
+    await scheduleBootstrapProjects(
+      projectsAwaitingBootstrapSchedule,
+      userId,
+      "unclaimed",
+    );
+    if (!agentMapMcpUrl) return;
+    for (const project of reconciled.projects) {
+      const launchRoot = preferredProjectRoot(
+        reconciled.workspaceScopes
+          .filter((scope) => scope.projectId === project.projectId)
+          .map((scope) => scope.cwd),
+      );
+      if (launchRoot) {
+        await ensureProjectFirstSession(project.projectId, launchRoot);
+      }
+    }
+  };
+
+  const initializeOpenedProject = async (
+    requestedRoot: string,
+  ): Promise<void> => {
+    const userId = localProjectPrincipal(projectUserId, machineId);
+    pendingProjectCwds.add(requestedRoot);
+    let starts: Array<{ projectId: string; launchRoot: string }> = [];
+    try {
+      starts = await serializeProjectScopeResolution(async () => {
+        const before = new Set(
+          (await studioProjectCatalog.list()).map(
+            (project) => project.projectId,
+          ),
+        );
+        if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+          throw new ProjectSessionScopeUnavailableError("unclaimed");
+        }
+        const reconciled = await studioProjectCatalog.reconcile(
+          await studioWorkspaceScopeCatalog.list(),
+        );
+        const requestedProject =
+          await studioProjectCatalog.resolveIdentityForPath(requestedRoot);
+        if (localProjectPrincipal(projectUserId, machineId) !== userId) {
+          throw new ProjectSessionScopeUnavailableError("unclaimed");
+        }
+        const createdProjectIds = reconciled.projects
+          .map((project) => project.projectId)
+          .filter((projectId) => !before.has(projectId));
+        const scheduledProjectIds = [
+          ...new Set([
+            ...createdProjectIds,
+            ...projectsAwaitingBootstrapSchedule,
+          ]),
+        ];
+        await scheduleBootstrapProjects(
+          scheduledProjectIds,
+          userId,
+          "unclaimed",
+        );
+
+        const projectsToStart = new Set(createdProjectIds);
+        if (requestedProject) projectsToStart.add(requestedProject.projectId);
+        for (const projectId of scheduledProjectIds) {
+          projectsToStart.add(projectId);
+        }
+        return [...projectsToStart].sort().flatMap((projectId) => {
+          const launchRoot = preferredProjectRoot(
+            reconciled.workspaceScopes
+              .filter((scope) => scope.projectId === projectId)
+              .map((scope) => scope.cwd),
+          );
+          return launchRoot ? [{ projectId, launchRoot }] : [];
+        });
+      });
+    } finally {
+      pendingProjectCwds.delete(requestedRoot);
+    }
+    for (const start of starts) {
+      await ensureProjectFirstSession(start.projectId, start.launchRoot);
+    }
+  };
+
+  // One ordinary-session input authority serves the canonical REST endpoint
+  // and its bounded planner-era compatibility alias. Bootstrap FIFO ownership
+  // stays behind this boundary so neither transport can invent eligibility,
+  // preemption, or dispatch semantics of its own.
+  const submitSessionInput = async (
+    sessionId: string,
+    text: string,
+    submit: boolean,
+    requestId?: string,
+  ): Promise<SessionInputSubmissionResult> => {
+    const bootstrapCoordinator = projectBootstrap;
+    if (bootstrapCoordinator?.ownsInput(sessionId, requestId)) {
+      if (submit) {
+        const result = await bootstrapCoordinator.enqueueWithReceipt(
+          sessionId,
+          text,
+          requestId,
+        );
+        return { ok: true, receipt: result.receipt };
+      }
+      // A user-owned draft must also win over automatic bootstrap, but it
+      // must remain editable rather than entering the durable submit FIFO.
+      // Retire lifecycle ownership and clear any background text staged
+      // before Enter, then preserve ordinary submit:false semantics.
+      const runtimeEpoch = sessionManager.getRuntimeEpoch(sessionId);
+      if (runtimeEpoch !== null) {
+        bootstrapCoordinator.onTerminalInput(sessionId, {
+          runtimeEpoch,
+          blockingPrompt: false,
+        });
+      }
+      sessionManager.preemptBackgroundInput(sessionId);
+    }
+    return { ok: await sessionManager.submitInput(sessionId, text, submit) };
+  };
 
   const app: Express = express();
   app.disable("x-powered-by");
-
-  // Everything under /api requires the boot token; mounted as middleware
-  // (not a router) so it also gates the workflows/macros routers below,
-  // which declare their own absolute /api/* paths.
-  // JSON limit raised above express's 100 KiB default so the image-attach route
-  // (base64 data URLs, up to ~13 MiB encoded) can be parsed — see
-  // JSON_BODY_LIMIT_BYTES. This is the parser that actually gates every /api
-  // route; the rest router mounts its own with the same limit for standalone use.
   app.use(
     "/api",
     createBootTokenMiddleware(options.bootToken),
@@ -3069,37 +3480,8 @@ export const startServer = async (
         workflowsCache.find((w) => w.path === workflowPath) ?? null,
       writeWorkspaceContext: writeSessionContext,
       renderCanvas,
-      // Private compatibility boundary: migrated sessions use the ordinary
-      // HTTP endpoint while their persisted startup FIFO remains authoritative.
-      // The project bootstrap cutover replaces this coordinator in one place.
-      submitSessionInput: async (sessionId, text, submit) => {
-        const session = sessionManager.get(sessionId);
-        if (session?.planning) {
-          if (!(await isPlannerDispatchAuthorized({
-            session,
-            currentPrincipal: () => localPlanningPrincipal(planningUserId, machineId),
-            resolveProject: (projectId) => studioProjectCatalog.resolveIdentity(projectId),
-          }))) throw new ProjectSessionScopeUnavailableError(sessionId);
-          if (submit) {
-            try {
-              await plannerGreeting.enqueue(sessionId, text);
-            } catch (error) {
-              if (error instanceof PlannerDispatchForbiddenError) {
-                throw new ProjectSessionScopeUnavailableError(sessionId);
-              }
-              throw error;
-            }
-            return true;
-          }
-          // Draft text cannot interleave with a pending automatic greeting.
-          if (session.planning.greeting.status === "pending" ||
-              session.planning.greeting.status === "generating") {
-            throw new SessionNotReadyError(sessionId);
-          }
-        }
-        return sessionManager.submitInput(sessionId, text, submit);
-      },
       onTelemetryOptInChange: (optIn) => batcher.setTelemetryOptIn(optIn),
+      onRecentDirAdded: initializeOpenedProject,
       onSessionCreated: (cwd, harnessSessionId) => {
         scanWorkflowsAndBroadcast(cwd, "session-create", { dirty: true })
           .then(({ found }) => {
@@ -3118,6 +3500,7 @@ export const startServer = async (
             );
           });
       },
+      submitSessionInput,
       launchDir,
       defaultProjectRoot,
       agentsBaseUrl: resolveAgentsBaseUrl(),
@@ -3144,12 +3527,42 @@ export const startServer = async (
       catalog: studioProjectCatalog,
       store: agentMapWorkspaceStore,
       preferences: studioWorkspacePreferences,
-      currentUserId: () => localPlanningPrincipal(planningUserId, machineId),
+      currentUserId: () => localProjectPrincipal(projectUserId, machineId),
       listWorkflows: () => workflowsCache,
       isWorkflowScanComplete,
       listWorkspaceScopes: () => studioWorkspaceScopeCatalog.list(),
-      planningSessions,
-      plannerGreeting,
+      onProjectCreated: async (project) => {
+        const userId = localProjectPrincipal(projectUserId, machineId);
+        await scheduleBootstrapProjects(
+          [project.projectId],
+          userId,
+          "unclaimed",
+        );
+      },
+      onRootBound: async (project, root) => {
+        const userId = localProjectPrincipal(projectUserId, machineId);
+        // Recover a project whose durable create committed just before its
+        // lifecycle callback failed, without enrolling an older project merely
+        // because one of its bindings changed.
+        if (projectsAwaitingBootstrapSchedule.has(project.projectId)) {
+          await scheduleBootstrapProjects(
+            [project.projectId],
+            userId,
+            "unclaimed",
+          );
+        }
+        const identity = await studioProjectCatalog.resolveIdentity(
+          project.projectId,
+        );
+        const launchRoot = identity
+          ? preferredProjectRoot(
+              identity.rootBindings
+                .filter((binding) => binding.status === "active")
+                .map((binding) => binding.localRootRef),
+            )
+          : null;
+        await ensureProjectFirstSession(project.projectId, launchRoot ?? root);
+      },
     }),
   );
   app.use(
@@ -3542,8 +3955,8 @@ export const startServer = async (
       bus,
       authEnabled,
       environment: process.env.SAPIOM_ENVIRONMENT,
-      onPlanningUserChanged: (userId) => {
-        planningUserId = userId;
+      onProjectUserChanged: (userId) => {
+        projectUserId = userId;
         for (const session of sessionManager.list()) {
           agentMapCapabilities.revokeSession(session.id);
           void agentMapMcp?.revokeSession(session.id);
@@ -3561,7 +3974,12 @@ export const startServer = async (
       sessionManager.acceptsIngestRuntimeEpoch(sessionId, runtimeEpoch),
     normalize: normalizeHookEvent,
     resolveSession: resolveIngestSession,
-    onAgentSessionResolved: (harnessSessionId, agentSessionId, source, runtimeEpoch) => {
+    onAgentSessionResolved: (
+      harnessSessionId,
+      agentSessionId,
+      source,
+      runtimeEpoch,
+    ) => {
       // Record the agent session id — used by session-manager for resume
       // (agentSessionId feeds the --resume flag) and by the codex tailer for
       // exact-match rollout discovery.
@@ -3578,8 +3996,10 @@ export const startServer = async (
     store: eventStore,
     batcher,
     enrichFromTranscript: enrichTurnCompleted,
-    decorateEvent: (event) => plannerGreeting.decorateLocalEvent(event),
-    projectTelemetryEvent: (event) => plannerGreeting.redactForTelemetry(event),
+    decorateEvent: (event, runtimeEpoch) =>
+      projectBootstrap!.decorateLocalEvent(event, runtimeEpoch),
+    projectTelemetryEvent: (event) =>
+      projectBootstrap!.redactForTelemetry(event),
     onNormalizedEvent: (event: AnalyticsEvent) => {
       // Synchronous and total — it counts turns and detaches any fold it
       // decides to start, so the ingest path never waits on a summary.
@@ -3606,9 +4026,9 @@ export const startServer = async (
         executionDetector.flush(event.harnessSessionId);
       }
     },
-    onEventPersisted: (event: AnalyticsEvent) => {
-      void plannerGreeting.onEventPersisted(event).catch((error: unknown) => {
-        console.error("[harness] planner greeting completion failed:", error);
+    onEventPersisted: (event: AnalyticsEvent, runtimeEpoch) => {
+      void projectBootstrap!.onEventPersisted(event, runtimeEpoch).catch(() => {
+        console.error("[harness] project bootstrap completion failed");
       });
       const recordChanged = sessionRecordChangedMessage(event);
       if (recordChanged) bus.publish(recordChanged);
@@ -3778,105 +4198,98 @@ export const startServer = async (
     },
   ]);
 
-  await new Promise<void>((resolve, reject) => {
-    httpServer.once("error", reject);
-    httpServer.listen(options.port, host, () => {
-      httpServer.removeListener("error", reject);
-      resolve();
-    });
-  });
-
-  const address = httpServer.address();
-  const actualPort =
-    typeof address === "object" && address ? address.port : options.port;
-  agentMapMcpUrl = `http://${host}:${actualPort}/mcp/agent-map`;
-  // Covers the ephemeral `port: 0` case where only the bound address is real.
-  portDetector.addExcludedPort(actualPort);
-
-  // The app otherwise opens to an empty terminal pane — not fire-and-forget
-  // because a spawn failure here (e.g. claude not on PATH) is worth
-  // surfacing loudly, but also not awaited before returning: startServer()
-  // resolving shouldn't wait on a real pty spawn.
-  if (options.autoCreateSession ?? true) {
-    const harness = options.defaultHarnessKind ?? "claude-code";
-    sessionManager
-      .create({ cwd: launchDir, harness })
-      .then(async (session) => {
-        // Reuses the scan already kicked off above rather than scanning
-        // launchDir twice — only renders when it actually found something,
-        // same "discoverable" gate as the REST onSessionCreated path.
-        const { found } = await initialWorkflowScan;
-        if (found.length > 0) await autoRenderCanvas(session);
-      })
-      .catch((err: unknown) => {
-        console.error("[harness] auto-create boot session failed:", err);
-      });
-  }
+  let serverClose: Promise<void> | null = null;
+  const closeServer = (): Promise<void> => {
+    if (serverClose) return serverClose;
+    serverClose = (async () => {
+      const settle = async (
+        operation: () => void | Promise<void>,
+      ): Promise<void> => {
+        try {
+          await operation();
+        } catch {
+          // Shutdown is best-effort across independent resources. Keep this
+          // content-free so provider errors and private paths never leak.
+          console.error("[harness] server shutdown step failed");
+        }
+      };
 
-  return {
-    port: actualPort,
-    uiToken,
-    sessionManager,
-    close: async () => {
+      await settle(() => sessionManager.beginShutdown());
+      const bootstrapClosing = settle(() => projectBootstrap?.close());
       coordinatorActive = false;
       coordinatorEpoch += 1;
-      await workflowRegistry.retirePendingDiscovery();
-      rejectPublication(new Error("Agent discovery coordinator is closed"));
       clearInterval(sessionSweepTimer);
       clearInterval(ndjsonRetentionTimer);
-      canvasWatcher.stopAll();
-      workspaceWatcher.stopAll();
-      systemGraphWatcher.stopAll();
+      await settle(() => workflowRegistry.retirePendingDiscovery());
+      await settle(() =>
+        rejectPublication(new Error("Agent discovery coordinator is closed")),
+      );
+      await settle(() => canvasWatcher.stopAll());
+      await settle(() => workspaceWatcher.stopAll());
+      await settle(() => systemGraphWatcher.stopAll());
       activeSystemGraphScopes.clear();
-      systemGraphInvocations.clear();
-      systemGraphInventory.clear();
-      systemGraphStore.clear();
-      installWatcher.stopAll();
-      for (const tailer of codexTailers.values()) tailer.stop();
+      await settle(() => systemGraphInvocations.clear());
+      await settle(() => systemGraphInventory.clear());
+      await settle(() => systemGraphStore.clear());
+      await settle(() => installWatcher.stopAll());
+      for (const tailer of codexTailers.values()) {
+        await settle(() => tailer.stop());
+      }
       codexTailers.clear();
-      // Closing the HTTP/WS server doesn't touch unrelated child processes
-      // on its own — without this, every live claude/codex pty outlives
-      // the harness server itself (e.g. after Ctrl+C or in a script that
-      // expects the process to actually exit once close() resolves).
-      // Await kills with a bounded timeout so shutdown never hangs: if a
-      // process somehow survives both SIGTERM and SIGKILL within the
-      // escalation window (shouldn't happen), we still resolve and let the
-      // HTTP server close proceed. The SIGKILL escalation inside each kill()
-      // itself is bounded (KILL_ESCALATION_MS + KILL_ESCALATION_CONFIRM_MS
-      // = 2500ms); the outer timeout here is a final safety net above that.
+
+      // Closing the HTTP/WS server doesn't touch unrelated child processes.
+      // Bound the process cleanup so shutdown cannot strand the listening
+      // socket if an adapter misses its own exit acknowledgement.
       const SHUTDOWN_KILL_TIMEOUT_MS = 5_000;
-      sessionManager.beginShutdown();
       const killsSettled = Promise.all([
-        sessionManager.killAll(),
-        taskManager.killAll(),
-      ]);
+        settle(() => sessionManager.killAll()),
+        settle(() => taskManager.killAll()),
+      ]).then(() => {});
       let shutdownTimerHandle: ReturnType<typeof setTimeout> | undefined;
       const shutdownTimeout = new Promise<void>((resolve) => {
         shutdownTimerHandle = setTimeout(resolve, SHUTDOWN_KILL_TIMEOUT_MS);
-        // Unref so the timer never keeps the event loop alive when the kill
-        // path wins — mirrors SessionManager.kill()'s escalation timer pattern.
         shutdownTimerHandle.unref();
       });
       await Promise.race([killsSettled, shutdownTimeout]);
-      await agentMapMcp?.close();
-      // Clear the timer when the kill path wins (common case) so it doesn't
-      // linger ref'd in the background after shutdown completes.
       if (shutdownTimerHandle !== undefined) clearTimeout(shutdownTimerHandle);
-      void batcher.close();
-      // wss.close() stops NEW upgrades but never terminates the connections
-      // already open — and httpServer.close() then waits indefinitely for those
-      // sockets to drain. The main window's live /ws/events and /ws/terminal
-      // connections (plus any keep-alive HTTP socket) would therefore hang
-      // close() forever, so Electron's before-quit never reaches app.quit() and
-      // the process lingers as a zombie still holding the single-instance lock —
-      // which blocks the next launch (it hangs on "Starting Sapiom…"). Force
-      // each client shut, drop keep-alive HTTP conns, and bound the final wait
-      // so shutdown always completes.
-      for (const client of terminalWss.clients) client.terminate();
-      for (const client of eventsWss.clients) client.terminate();
-      terminalWss.close();
-      eventsWss.close();
-      httpServer.closeAllConnections?.();
+      // Admission and runtime fences are already closed. Let durability and
+      // telemetry drains finish in order, but do not hold the listening socket
+      // indefinitely if a store or transport never settles. Timing out this
+      // wait leaves the existing writes intact; it never reopens admission.
+      const drainsSettled = (async () => {
+        await bootstrapClosing;
+        await settle(() => sessionManager.flush());
+        await settle(async () => {
+          await recordBackfill;
+          while (pendingRecordArchives.size > 0) {
+            await Promise.all([...pendingRecordArchives]);
+          }
+        });
+        await settle(() => agentMapMcp?.close());
+        await settle(() => batcher.close());
+      })();
+      const SHUTDOWN_DRAIN_TIMEOUT_MS = 5_000;
+      let drainTimerHandle: ReturnType<typeof setTimeout> | undefined;
+      const drainTimeout = new Promise<void>((resolve) => {
+        drainTimerHandle = setTimeout(resolve, SHUTDOWN_DRAIN_TIMEOUT_MS);
+        drainTimerHandle.unref();
+      });
+      await Promise.race([drainsSettled, drainTimeout]);
+      if (drainTimerHandle !== undefined) clearTimeout(drainTimerHandle);
+
+      // Existing clients and keep-alive sockets otherwise make close() wait
+      // forever. Terminate them before releasing the listener, and make the
+      // final wait bounded just like child-process cleanup above.
+      for (const client of terminalWss.clients) {
+        await settle(() => client.terminate());
+      }
+      for (const client of eventsWss.clients) {
+        await settle(() => client.terminate());
+      }
+      await settle(() => terminalWss.close());
+      await settle(() => eventsWss.close());
+      await settle(() => httpServer.closeAllConnections?.());
+      if (!httpServer.listening) return;
       const HTTP_CLOSE_TIMEOUT_MS = 3_000;
       await new Promise<void>((resolve) => {
         let httpCloseTimer: ReturnType<typeof setTimeout> | undefined =
@@ -3885,12 +4298,107 @@ export const startServer = async (
             resolve();
           }, HTTP_CLOSE_TIMEOUT_MS);
         httpCloseTimer.unref?.();
-        httpServer.close((err) => {
-          if (err) console.error("[harness] httpServer.close error:", err);
+        httpServer.close((error) => {
+          if (error) console.error("[harness] http server shutdown failed");
           if (httpCloseTimer !== undefined) clearTimeout(httpCloseTimer);
           resolve();
         });
       });
-    },
+    })();
+    return serverClose;
+  };
+
+  let actualPort = options.port;
+  try {
+    await new Promise<void>((resolve, reject) => {
+      httpServer.once("error", reject);
+      httpServer.listen(options.port, host, () => {
+        httpServer.removeListener("error", reject);
+        resolve();
+      });
+    });
+
+    const address = httpServer.address();
+    actualPort =
+      typeof address === "object" && address ? address.port : options.port;
+    agentMapMcpUrl = `http://${host}:${actualPort}/mcp/agent-map`;
+    // Covers the ephemeral `port: 0` case where only the bound address is real.
+    portDetector.addExcludedPort(actualPort);
+    await options.projectBootstrapTestHooks?.afterListenBeforeRecovery?.(
+      actualPort,
+    );
+
+    // A project intent is persisted before its first PTY is created. Reconcile
+    // that crash window only after the MCP endpoint is bound: every ordinary
+    // project session receives its capability during launch preparation, so an
+    // earlier recovery attempt would fail before spawning and leave a tombstone.
+    for (const summary of await studioProjectCatalog.list()) {
+      const project = await studioProjectCatalog.resolveIdentity(
+        summary.projectId,
+      );
+      const root = project
+        ? preferredProjectRoot(
+            project.rootBindings
+              .filter((binding) => binding.status === "active")
+              .map((binding) => binding.localRootRef),
+          )
+        : null;
+      if (!project || !root) continue;
+      await ensureProjectFirstSession(summary.projectId, root).catch(
+        (error: unknown) => {
+          console.error(
+            `[harness] project bootstrap session recovery failed: ${
+              error instanceof ProjectBootstrapCoordinatorClosedError
+                ? "coordinator_closed"
+                : error instanceof ProjectSessionScopeUnavailableError
+                  ? "scope_unavailable"
+                  : "session_start_failed"
+            }`,
+          );
+        },
+      );
+    }
+
+    // The app otherwise opens to an empty terminal pane — not fire-and-forget
+    // because a spawn failure here (e.g. claude not on PATH) is worth
+    // surfacing loudly, but also not awaited before returning: startServer()
+    // resolving shouldn't wait on a real pty spawn.
+    const launchProject =
+      await studioProjectCatalog.resolveIdentityForPath(launchDir);
+    const recoveredLaunchProjectSession = Boolean(
+      launchProject &&
+      sessionManager
+        .list()
+        .some(
+          (session) =>
+            session.status !== "exited" &&
+            session.agentMapIdentity?.projectId === launchProject.projectId,
+        ),
+    );
+    if ((options.autoCreateSession ?? true) && !recoveredLaunchProjectSession) {
+      const harness = options.defaultHarnessKind ?? "claude-code";
+      sessionManager
+        .create({ cwd: launchDir, harness })
+        .then(async (session) => {
+          // Reuses the scan already kicked off above rather than scanning
+          // launchDir twice — only renders when it actually found something,
+          // same "discoverable" gate as the REST onSessionCreated path.
+          const { found } = await initialWorkflowScan;
+          if (found.length > 0) await autoRenderCanvas(session);
+        })
+        .catch((err: unknown) => {
+          console.error("[harness] auto-create boot session failed:", err);
+        });
+    }
+  } catch (error) {
+    await closeServer();
+    throw error;
+  }
+
+  return {
+    port: actualPort,
+    uiToken,
+    sessionManager,
+    close: closeServer,
   };
 };
diff --git a/packages/harness/src/server/ingest.test.ts b/packages/harness/src/server/ingest.test.ts
index 00316e040..60fb89373 100644
--- a/packages/harness/src/server/ingest.test.ts
+++ b/packages/harness/src/server/ingest.test.ts
@@ -9,7 +9,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { normalizeHookEvent } from "../core/collector/normalizer.js";
 import { createSeqCounter } from "../core/collector/seq.js";
 import { createEventStore } from "../core/collector/store.js";
-import { PlannerGreetingCoordinator } from "../core/planner-greeting.js";
+import { ProjectBootstrapCoordinator } from "../core/project-bootstrap.js";
 import { createSessionRecordReader } from "../core/session-record.js";
 import type { SessionManager } from "../core/session-manager.js";
 import type { AnalyticsEvent, HarnessSession } from "../shared/types.js";
@@ -833,22 +833,21 @@ describe("createIngestRouter", () => {
     expect(JSON.stringify(enqueued[0])).not.toContain("private control prompt");
   });
 
-  it("bounds hostile planner source, model, and usage before batching", async () => {
-    const planningSession = {
+  it("bounds hostile bootstrap source, model, and usage before batching", async () => {
+    const bootstrapSession = {
       agentSessionId: "agent-1",
-      planning: {
-        identity: {
-          projectId: "project-1",
-          sessionId: "session-1",
-          userId: "user-1",
-          role: "map-planner",
-        },
+      projectBootstrap: {
+        projectId: "project-1",
+        userId: "user-1",
+        targetSessionId: "session-1",
+        bootstrap: { status: "generating", attemptId: "attempt-1" },
+        queuedInputIds: [],
       },
     } as unknown as HarnessSession;
-    const privacy = new PlannerGreetingCoordinator({
+    const privacy = new ProjectBootstrapCoordinator({
       root: "/unused",
       sessionManager: {
-        get: () => planningSession,
+        get: () => bootstrapSession,
       } as unknown as SessionManager,
     });
     start({
@@ -895,10 +894,10 @@ describe("createIngestRouter", () => {
 
     await vi.waitFor(() => expect(enqueued).toHaveLength(3));
     expect(enqueued.map((event) => event.payload)).toEqual([
-      { planner: true, source: "unknown" },
-      { planner: true, origin: "user" },
+      { projectBootstrap: true, source: "unknown" },
+      { projectBootstrap: true, origin: "user" },
       {
-        planner: true,
+        projectBootstrap: true,
         hasAssistantText: true,
         modelReported: true,
         usage: { inputTokens: 1_000_000_000_000, outputTokens: null },
diff --git a/packages/harness/src/server/project-bootstrap-outbox.test.ts b/packages/harness/src/server/project-bootstrap-outbox.test.ts
new file mode 100644
index 000000000..49cfee169
--- /dev/null
+++ b/packages/harness/src/server/project-bootstrap-outbox.test.ts
@@ -0,0 +1,547 @@
+import { createServer as createHttpServer } from "node:http";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { StudioProjectCatalog } from "../core/studio-project-catalog.js";
+import { ProjectBootstrapCoordinator } from "../core/project-bootstrap.js";
+import { SessionManagerClosingError } from "../core/session-manager.js";
+import type { HarnessAdapter, LaunchOpts, SpawnSpec } from "../shared/types.js";
+import { startServer, type HarnessServer } from "./index.js";
+
+describe("new-project bootstrap outbox recovery", () => {
+  let stateRoot: string;
+  let existingRoot: string;
+  let newRoot: string;
+  let webDir: string;
+  let existingProjectId: string;
+  let server: HarnessServer | undefined;
+  let launches: LaunchOpts[];
+
+  beforeEach(async () => {
+    stateRoot = await fs.mkdtemp(
+      path.join(os.tmpdir(), "project-bootstrap-server-outbox-"),
+    );
+    existingRoot = path.join(stateRoot, "existing-project");
+    newRoot = path.join(stateRoot, "new-project");
+    webDir = path.join(stateRoot, "web");
+    await Promise.all([
+      fs.mkdir(existingRoot),
+      fs.mkdir(newRoot),
+      fs.mkdir(webDir),
+    ]);
+    await fs.writeFile(path.join(webDir, "index.html"), "<html></html>");
+    const reconciled = await new StudioProjectCatalog(
+      path.join(stateRoot, "studio-projects.json"),
+    ).reconcile([{ workspaceKey: "existing", cwd: existingRoot }]);
+    existingProjectId = reconciled.projects[0]!.projectId;
+    await fs.writeFile(
+      path.join(stateRoot, "settings.json"),
+      JSON.stringify({ recentDirs: [existingRoot] }),
+    );
+    launches = [];
+  });
+
+  afterEach(async () => {
+    await server?.close();
+    vi.restoreAllMocks();
+    await fs.rm(stateRoot, { recursive: true, force: true, maxRetries: 5 });
+  });
+
+  const markerFile = (projectId: string) =>
+    path.join(
+      stateRoot,
+      "agent-map",
+      "project-bootstrap",
+      "project-outbox",
+      `${projectId}.json`,
+    );
+
+  const intentFile = (projectId: string) =>
+    path.join(
+      stateRoot,
+      "agent-map",
+      "project-bootstrap",
+      "projects",
+      `${projectId}.json`,
+    );
+
+  async function exists(file: string): Promise<boolean> {
+    try {
+      await fs.stat(file);
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+      throw error;
+    }
+  }
+
+  function adapter(): HarnessAdapter {
+    const launch = (options: LaunchOpts): SpawnSpec => {
+      launches.push(options);
+      return { command: "bash", args: [], env: {}, cwd: options.cwd };
+    };
+    return {
+      id: "claude-code",
+      eventSource: "hooks",
+      doctor: async () => [],
+      launch,
+      resume: (_agentSessionId, options) => launch(options),
+      listPastSessions: async () => [],
+      canResume: async () => true,
+    };
+  }
+
+  async function boot(
+    failBeforeSchedule = false,
+    selectedAdapter: HarnessAdapter = adapter(),
+  ): Promise<HarnessServer> {
+    return startServer({
+      port: 0,
+      bootToken: "boot-token",
+      telemetryOptIn: false,
+      identity: null,
+      machineId: "machine-1",
+      adapters: { "claude-code": selectedAdapter },
+      stateRoot,
+      launchDir: existingRoot,
+      webDir,
+      autoCreateSession: false,
+      loadSystemPrompt: async () => "ordinary coding prompt",
+      ...(failBeforeSchedule
+        ? {
+            projectBootstrapTestHooks: {
+              beforeSchedule: async () => {
+                throw new Error("simulated crash before intent commit");
+              },
+            },
+          }
+        : {}),
+    });
+  }
+
+  async function request(
+    active: HarnessServer,
+    pathname: string,
+    init: RequestInit,
+  ): Promise<Response> {
+    return fetch(`http://127.0.0.1:${active.port}/api${pathname}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        "x-harness-token": "boot-token",
+        ...init.headers,
+      },
+    });
+  }
+
+  it("recovers an explicit project committed before its bootstrap intent", async () => {
+    server = await boot(true);
+    const response = await request(server, "/projects", {
+      method: "POST",
+      body: JSON.stringify({ displayName: "Explicit project" }),
+    });
+    expect(response.status).toBe(202);
+    const project = (await response.json()) as { projectId: string };
+    expect(await exists(markerFile(project.projectId))).toBe(true);
+    expect(await exists(intentFile(project.projectId))).toBe(false);
+
+    await server.close();
+    server = undefined;
+    await new StudioProjectCatalog(
+      path.join(stateRoot, "studio-projects.json"),
+    ).addRootBinding(project.projectId, newRoot, {
+      legacyWorkspaceKey: "explicit-project-root",
+    });
+
+    server = await boot();
+
+    expect(launches).toHaveLength(1);
+    expect(server.sessionManager.list()).toEqual([
+      expect.objectContaining({
+        title: "Plan Agents",
+        cwd: newRoot,
+        agentMapIdentity: expect.objectContaining({
+          projectId: project.projectId,
+          userId: "local:machine-1",
+        }),
+        projectBootstrap: expect.objectContaining({
+          projectId: project.projectId,
+          userId: "local:machine-1",
+        }),
+      }),
+    ]);
+    expect(await exists(markerFile(project.projectId))).toBe(false);
+    expect(await exists(intentFile(project.projectId))).toBe(true);
+    expect(
+      server.sessionManager
+        .list()
+        .some(
+          (session) =>
+            session.agentMapIdentity?.projectId === existingProjectId,
+        ),
+    ).toBe(false);
+  });
+
+  it("recovers a reconcile-created project without enrolling an older project", async () => {
+    server = await boot(true);
+    const committed = await request(server, "/settings", {
+      method: "PATCH",
+      body: JSON.stringify({ recentDirs: [newRoot, existingRoot] }),
+    });
+    expect(committed.status).toBe(200);
+    const created = await vi.waitFor(async () => {
+      const project = await new StudioProjectCatalog(
+        path.join(stateRoot, "studio-projects.json"),
+      ).resolveIdentityForPath(newRoot);
+      expect(project).not.toBeNull();
+      expect(await exists(markerFile(project!.projectId))).toBe(true);
+      return project!;
+    });
+    expect(created!.projectId).not.toBe(existingProjectId);
+    expect(await exists(markerFile(created!.projectId))).toBe(true);
+    expect(await exists(intentFile(created!.projectId))).toBe(false);
+
+    await server.close();
+    server = undefined;
+    server = await boot();
+
+    expect(launches).toHaveLength(1);
+    const sessions = server.sessionManager.list();
+    expect(sessions).toEqual([
+      expect.objectContaining({
+        title: "Plan Agents",
+        cwd: newRoot,
+        agentMapIdentity: expect.objectContaining({
+          projectId: created!.projectId,
+          userId: "local:machine-1",
+        }),
+        projectBootstrap: expect.objectContaining({
+          projectId: created!.projectId,
+        }),
+      }),
+    ]);
+    expect(
+      sessions.some(
+        (session) => session.agentMapIdentity?.projectId === existingProjectId,
+      ),
+    ).toBe(false);
+    expect(await exists(markerFile(created!.projectId))).toBe(false);
+    expect(await exists(intentFile(created!.projectId))).toBe(true);
+
+    const repeated = await request(server, "/settings", {
+      method: "PATCH",
+      body: JSON.stringify({ recentDirs: [newRoot, existingRoot] }),
+    });
+    expect(repeated.status).toBe(200);
+    expect(launches).toHaveLength(1);
+  });
+
+  it("converges a project created by an unowned reconciliation without a restart", async () => {
+    server = await boot();
+    await fs.writeFile(
+      path.join(stateRoot, "settings.json"),
+      JSON.stringify({ recentDirs: [newRoot, existingRoot] }),
+    );
+
+    const mapRead = await request(
+      server,
+      `/projects/${existingProjectId}/agent-map/workspace`,
+      { method: "GET" },
+    );
+    expect(mapRead.status).toBe(200);
+    expect(server.sessionManager.list()).toEqual([]);
+    expect(launches).toEqual([]);
+    await expect(
+      new StudioProjectCatalog(
+        path.join(stateRoot, "studio-projects.json"),
+      ).resolveIdentityForPath(newRoot),
+    ).resolves.toBeNull();
+
+    const state = await request(server, "/state", { method: "GET" });
+    expect(state.status).toBe(200);
+    const created = await new StudioProjectCatalog(
+      path.join(stateRoot, "studio-projects.json"),
+    ).resolveIdentityForPath(newRoot);
+    expect(created).not.toBeNull();
+    expect(launches).toHaveLength(1);
+    expect(server.sessionManager.list()).toEqual([
+      expect.objectContaining({
+        title: "Plan Agents",
+        cwd: newRoot,
+        agentMapIdentity: expect.objectContaining({
+          projectId: created!.projectId,
+        }),
+        projectBootstrap: expect.objectContaining({
+          projectId: created!.projectId,
+        }),
+      }),
+    ]);
+    expect(await exists(markerFile(created!.projectId))).toBe(false);
+    expect(await exists(intentFile(created!.projectId))).toBe(true);
+  });
+
+  it("defers automatic first-session creation until a local adapter is available", async () => {
+    const error = vi.spyOn(console, "error").mockImplementation(() => {});
+    server = await startServer({
+      port: 0,
+      bootToken: "boot-token",
+      telemetryOptIn: false,
+      identity: null,
+      machineId: "machine-1",
+      adapters: {},
+      stateRoot,
+      launchDir: existingRoot,
+      webDir,
+      autoCreateSession: false,
+      loadSystemPrompt: async () => "ordinary coding prompt",
+    });
+
+    const response = await request(server, "/settings", {
+      method: "PATCH",
+      body: JSON.stringify({ recentDirs: [newRoot, existingRoot] }),
+    });
+    expect(response.status).toBe(200);
+    const created = await vi.waitFor(async () => {
+      const project = await new StudioProjectCatalog(
+        path.join(stateRoot, "studio-projects.json"),
+      ).resolveIdentityForPath(newRoot);
+      expect(project).not.toBeNull();
+      expect(await exists(intentFile(project!.projectId))).toBe(true);
+      expect(error).toHaveBeenCalledWith(
+        "[harness] project bootstrap session start deferred: adapter_unavailable",
+      );
+      return project!;
+    });
+    expect(server.sessionManager.list()).toEqual([]);
+
+    await server.close();
+    server = undefined;
+    error.mockRestore();
+    server = await boot();
+
+    expect(launches).toHaveLength(1);
+    expect(server.sessionManager.list()).toEqual([
+      expect.objectContaining({
+        title: "Plan Agents",
+        cwd: newRoot,
+        agentMapIdentity: expect.objectContaining({
+          projectId: created!.projectId,
+        }),
+        projectBootstrap: expect.objectContaining({
+          projectId: created!.projectId,
+        }),
+      }),
+    ]);
+  });
+
+  it("does not replace a published first-session tombstone during repeated state reads", async () => {
+    const crashBeforeHook = (): HarnessAdapter => ({
+      id: "claude-code",
+      eventSource: "hooks",
+      doctor: async () => [],
+      launch: (options) => {
+        launches.push(options);
+        return {
+          command: process.execPath,
+          args: ["-e", "process.exit(0)"],
+          env: {},
+          cwd: options.cwd,
+        };
+      },
+      resume: (_agentSessionId, options) => ({
+        command: process.execPath,
+        args: ["-e", "process.exit(0)"],
+        env: {},
+        cwd: options.cwd,
+      }),
+      listPastSessions: async () => [],
+      canResume: async () => false,
+    });
+    server = await boot(false, crashBeforeHook());
+
+    const opened = await request(server, "/settings", {
+      method: "PATCH",
+      body: JSON.stringify({ recentDirs: [newRoot, existingRoot] }),
+    });
+    expect(opened.status).toBe(200);
+    await vi.waitFor(() => {
+      expect(server!.sessionManager.list()).toEqual([
+        expect.objectContaining({
+          title: "Plan Agents",
+          status: "exited",
+          agentSessionId: null,
+        }),
+      ]);
+    });
+    const firstSessionId = server.sessionManager.list()[0]!.id;
+
+    for (let read = 0; read < 8; read += 1) {
+      const pathname = read % 2 === 0 ? "/state" : "/workflows";
+      expect((await request(server, pathname, { method: "GET" })).status).toBe(
+        200,
+      );
+    }
+    expect(launches).toHaveLength(1);
+    expect(server.sessionManager.list().map((session) => session.id)).toEqual([
+      firstSessionId,
+    ]);
+
+    await server.close();
+    server = undefined;
+    server = await boot(false, crashBeforeHook());
+    for (const pathname of ["/state", "/workflows", "/state"]) {
+      expect((await request(server, pathname, { method: "GET" })).status).toBe(
+        200,
+      );
+    }
+    expect(launches).toHaveLength(1);
+    expect(server.sessionManager.list().map((session) => session.id)).toEqual([
+      firstSessionId,
+    ]);
+    await expect(
+      fs.readFile(intentFile(existingProjectId), "utf8"),
+    ).rejects.toMatchObject({ code: "ENOENT" });
+    const created = await new StudioProjectCatalog(
+      path.join(stateRoot, "studio-projects.json"),
+    ).resolveIdentityForPath(newRoot);
+    expect(created).not.toBeNull();
+    await expect(
+      fs.readFile(intentFile(created!.projectId), "utf8").then(JSON.parse),
+    ).resolves.toMatchObject({
+      status: "claimed",
+      targetSessionId: firstSessionId,
+    });
+  });
+
+  it("fully closes a post-listen startup failure before rejecting", async () => {
+    await fs.mkdir(path.dirname(intentFile(existingProjectId)), {
+      recursive: true,
+    });
+    await fs.writeFile(
+      intentFile(existingProjectId),
+      `${JSON.stringify({
+        schemaVersion: 1,
+        projectId: existingProjectId,
+        userId: "local:machine-1",
+        targetSessionId: null,
+        status: "scheduled",
+        createdAt: "2026-09-04T00:00:00.000Z",
+        updatedAt: "2026-09-04T00:00:00.000Z",
+      })}\n`,
+    );
+    let rejectedPort = 0;
+
+    await expect(
+      startServer({
+        port: 0,
+        bootToken: "boot-token",
+        telemetryOptIn: false,
+        identity: null,
+        machineId: "machine-1",
+        adapters: { "claude-code": adapter() },
+        stateRoot,
+        launchDir: existingRoot,
+        webDir,
+        autoCreateSession: false,
+        loadSystemPrompt: async () => "ordinary coding prompt",
+        projectBootstrapTestHooks: {
+          afterListenBeforeRecovery: (port) => {
+            rejectedPort = port;
+            throw new Error("simulated post-listen recovery failure");
+          },
+        },
+      }),
+    ).rejects.toThrow("simulated post-listen recovery failure");
+
+    expect(rejectedPort).toBeGreaterThan(0);
+    const rebound = createHttpServer();
+    await new Promise<void>((resolve, reject) => {
+      rebound.once("error", reject);
+      rebound.listen(rejectedPort, "127.0.0.1", () => resolve());
+    });
+    await new Promise<void>((resolve, reject) => {
+      rebound.close((error) => (error ? reject(error) : resolve()));
+    });
+    await new Promise<void>((resolve) => setTimeout(resolve, 50));
+    expect(launches).toEqual([]);
+    await expect(
+      fs.readFile(intentFile(existingProjectId), "utf8").then(JSON.parse),
+    ).resolves.toMatchObject({ status: "scheduled", targetSessionId: null });
+  });
+
+  it.each(["bootstrap", "session flush"] as const)(
+    "releases the listener with admission fenced when %s teardown never settles",
+    async (stalledResource) => {
+      server = await boot();
+      const active = server;
+      const port = active.port;
+      let releaseTeardown!: () => void;
+      const teardown = new Promise<void>((resolve) => {
+        releaseTeardown = resolve;
+      });
+      const originalBootstrapClose = ProjectBootstrapCoordinator.prototype.close;
+      const kills = vi.spyOn(active.sessionManager, "killAll");
+      const stalled = stalledResource === "bootstrap"
+        ? vi.spyOn(ProjectBootstrapCoordinator.prototype, "close")
+            .mockImplementation(async function (this: ProjectBootstrapCoordinator) {
+              await originalBootstrapClose.call(this);
+              await teardown;
+            })
+        : vi.spyOn(active.sessionManager, "flush")
+            .mockImplementation(() => teardown);
+      vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
+      let closed = false;
+      const closing = active.close().then(() => { closed = true; });
+
+      try {
+        await vi.waitFor(() => expect(stalled).toHaveBeenCalled());
+        await expect(active.sessionManager.create({
+          harness: "claude-code", cwd: newRoot,
+        })).rejects.toBeInstanceOf(SessionManagerClosingError);
+        await vi.waitFor(() => expect(kills).toHaveBeenCalled());
+        await vi.advanceTimersByTimeAsync(0);
+        await vi.advanceTimersByTimeAsync(5_001);
+        await vi.waitFor(() => expect(closed).toBe(true), {
+          timeout: 250,
+        });
+        await closing;
+        server = undefined;
+
+        const rebound = createHttpServer();
+        await new Promise<void>((resolve, reject) => {
+          rebound.once("error", reject);
+          rebound.listen(port, "127.0.0.1", () => resolve());
+        });
+        await new Promise<void>((resolve, reject) => {
+          rebound.close((error) => (error ? reject(error) : resolve()));
+        });
+        expect(launches).toEqual([]);
+      } finally {
+        releaseTeardown();
+        vi.useRealTimers();
+        await closing;
+      }
+    },
+  );
+
+  it("makes concurrent server close calls share one complete teardown", async () => {
+    server = await boot();
+    const port = server.port;
+
+    await Promise.all([server.close(), server.close(), server.close()]);
+    server = undefined;
+
+    const rebound = createHttpServer();
+    await new Promise<void>((resolve, reject) => {
+      rebound.once("error", reject);
+      rebound.listen(port, "127.0.0.1", () => resolve());
+    });
+    await new Promise<void>((resolve, reject) => {
+      rebound.close((error) => (error ? reject(error) : resolve()));
+    });
+    expect(launches).toEqual([]);
+  });
+});
diff --git a/packages/harness/src/server/rehydrate-session.test.ts b/packages/harness/src/server/rehydrate-session.test.ts
index 8c2375b0a..549a5b494 100644
--- a/packages/harness/src/server/rehydrate-session.test.ts
+++ b/packages/harness/src/server/rehydrate-session.test.ts
@@ -35,7 +35,12 @@ const PRIOR_AGENT_SESSION = "prior-agent-session";
  *  is real and killable. Declares `launch-flag` exactly as both shipped
  *  adapters do, so the delivery channel under test is the production one. */
 function fakeAdapter(harness: HarnessKind): HarnessAdapter {
-  const spec = (opts: LaunchOpts): SpawnSpec => ({ command: "bash", args: [], env: {}, cwd: opts.cwd });
+  const spec = (opts: LaunchOpts): SpawnSpec => ({
+    command: "bash",
+    args: [],
+    env: {},
+    cwd: opts.cwd,
+  });
   return {
     id: harness,
     eventSource: harness === "codex" ? "transcript-tail" : "hooks",
@@ -79,7 +84,12 @@ describe("portable continue — rehydrating a fresh session", () => {
     // Retried: a session's exit-time `removeGeneratedSessionDir` is
     // fire-and-forget, so it can still be deleting inside `generated/` while
     // this tears the whole scratch root down (ENOTEMPTY).
-    await rm(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+    await rm(dir, {
+      recursive: true,
+      force: true,
+      maxRetries: 10,
+      retryDelay: 50,
+    });
   });
 
   /** Seed events.ndjson with a prior session the harness recorded itself —
@@ -105,11 +115,20 @@ describe("portable continue — rehydrating a fresh session", () => {
       n: number,
       type: AnalyticsEventType,
       payload: Record<string, unknown>,
-    ): AnalyticsEvent => ({ ...base, eventId: `event-${n}`, seq: n, ts: at(n), type, payload });
+    ): AnalyticsEvent => ({
+      ...base,
+      eventId: `event-${n}`,
+      seq: n,
+      ts: at(n),
+      type,
+      payload,
+    });
 
     const events: AnalyticsEvent[] = [
       event(1, "session.start", { source: "startup", cwd }),
-      event(2, "prompt.submitted", { prompt: "make the retry backoff jittered" }),
+      event(2, "prompt.submitted", {
+        prompt: "make the retry backoff jittered",
+      }),
       event(3, "tool.call", {
         toolName: "Edit",
         toolInput: JSON.stringify({ file_path: join(cwd, "src/retry.ts") }),
@@ -120,7 +139,9 @@ describe("portable continue — rehydrating a fresh session", () => {
         toolInput: JSON.stringify({ command: "pnpm build" }),
         toolResponseSummary: "built",
       }),
-      event(5, "turn.completed", { assistantText: "Jitter is in; the tests still need updating." }),
+      event(5, "turn.completed", {
+        assistantText: "Jitter is in; the tests still need updating.",
+      }),
       event(6, "session.end", { reason: "exit" }),
     ];
     await mkdir(dir, { recursive: true });
@@ -143,7 +164,10 @@ describe("portable continue — rehydrating a fresh session", () => {
   }
 
   async function systemPrompt(harnessSessionId: string): Promise<string> {
-    return readFile(join(generatedRoot, harnessSessionId, "system-prompt.txt"), "utf8");
+    return readFile(
+      join(generatedRoot, harnessSessionId, "system-prompt.txt"),
+      "utf8",
+    );
   }
 
   // The acceptance criterion "same code path works for claude-code and codex"
@@ -177,7 +201,9 @@ describe("portable continue — rehydrating a fresh session", () => {
         expect(prompt).toContain("reconstruction, not restored context");
         // What the session was doing.
         expect(prompt).toContain("make the retry backoff jittered");
-        expect(prompt).toContain("Jitter is in; the tests still need updating.");
+        expect(prompt).toContain(
+          "Jitter is in; the tests still need updating.",
+        );
         expect(prompt).toContain("src/retry.ts");
         expect(prompt).toContain("pnpm build");
         expect(prompt).toContain(cwd);
@@ -196,7 +222,9 @@ describe("portable continue — rehydrating a fresh session", () => {
           rehydrateFrom: PRIOR_AGENT_SESSION,
         });
         expect(session.rehydratedFrom).toBe(PRIOR_AGENT_SESSION);
-        expect(await systemPrompt(session.id)).toContain("make the retry backoff jittered");
+        expect(await systemPrompt(session.id)).toContain(
+          "make the retry backoff jittered",
+        );
       });
 
       it("includes the rolling summary when one was produced, and degrades without it", async () => {
@@ -208,7 +236,9 @@ describe("portable continue — rehydrating a fresh session", () => {
           harness,
           rehydrateFrom: PRIOR_SESSION,
         });
-        expect(await systemPrompt(withoutSummary.id)).not.toContain("Rolling summary");
+        expect(await systemPrompt(withoutSummary.id)).not.toContain(
+          "Rolling summary",
+        );
 
         await mkdir(join(generatedRoot, PRIOR_SESSION), { recursive: true });
         await writeFile(
@@ -247,7 +277,9 @@ describe("portable continue — rehydrating a fresh session", () => {
         server = await boot(harness);
         const session = await server.sessionManager.create({ cwd, harness });
         expect(session.rehydratedFrom).toBeNull();
-        expect(await systemPrompt(session.id)).not.toContain("reconstruction, not restored context");
+        expect(await systemPrompt(session.id)).not.toContain(
+          "reconstruction, not restored context",
+        );
       });
     });
   }
@@ -257,7 +289,10 @@ describe("portable continue — rehydrating a fresh session", () => {
      *  is the proof that a future harness with no prompt flag gets working
      *  rehydration from one line in its adapter rather than silence. */
     function promptFlaglessAdapter(): HarnessAdapter {
-      return { ...fakeAdapter("claude-code"), systemPromptDelivery: "post-ready-injection" };
+      return {
+        ...fakeAdapter("claude-code"),
+        systemPromptDelivery: "post-ready-injection",
+      };
     }
 
     async function bootFlagless(): Promise<HarnessServer> {
@@ -284,7 +319,9 @@ describe("portable continue — rehydrating a fresh session", () => {
       // A brief exists and will be delivered, so the session says so — but not
       // through a file this adapter never reads.
       expect(session.rehydratedFrom).toBe(PRIOR_SESSION);
-      expect(await systemPrompt(session.id)).not.toContain("reconstruction, not restored context");
+      expect(await systemPrompt(session.id)).not.toContain(
+        "reconstruction, not restored context",
+      );
       // Nothing injected yet: the pty is running but not `ready`, which is the
       // state a TUI sitting on a trust prompt is in.
       expect(submitInput).not.toHaveBeenCalled();
@@ -321,37 +358,70 @@ describe("portable continue — rehydrating a fresh session", () => {
       expect(submitInput).toHaveBeenCalledTimes(1);
     });
 
-    it("injects nothing for a session that was never rehydrated", async () => {
+    it("injects no rehydration brief for a session that was never rehydrated", async () => {
       server = await bootFlagless();
       const submitInput = vi.spyOn(server.sessionManager, "submitInput");
-      const session = await server.sessionManager.create({ cwd, harness: "claude-code" });
+      const session = await server.sessionManager.create({
+        cwd,
+        harness: "claude-code",
+      });
       server.sessionManager.setReady(session.id);
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      expect(submitInput).not.toHaveBeenCalled();
+      await vi.waitFor(() => expect(submitInput).toHaveBeenCalledTimes(1));
+      expect(submitInput.mock.calls[0]?.[1]).toContain(
+        "Agent Studio project bootstrap",
+      );
+      expect(submitInput.mock.calls[0]?.[1]).not.toContain(
+        "reconstruction, not restored context",
+      );
     });
   });
 
   it("is reachable over POST /api/sessions", async () => {
     await seedPriorSession("claude-code");
     server = await boot("claude-code");
-    const response = await fetch(`http://127.0.0.1:${server.port}/api/sessions`, {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-harness-token": "test-token" },
-      body: JSON.stringify({ cwd, harness: "claude-code", rehydrateFrom: PRIOR_SESSION }),
-    });
+    const response = await fetch(
+      `http://127.0.0.1:${server.port}/api/sessions`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-harness-token": "test-token",
+        },
+        body: JSON.stringify({
+          cwd,
+          harness: "claude-code",
+          rehydrateFrom: PRIOR_SESSION,
+        }),
+      },
+    );
     expect(response.status).toBe(201);
-    const session = (await response.json()) as { id: string; rehydratedFrom: string | null };
+    const session = (await response.json()) as {
+      id: string;
+      rehydratedFrom: string | null;
+    };
     expect(session.rehydratedFrom).toBe(PRIOR_SESSION);
-    expect(await systemPrompt(session.id)).toContain("make the retry backoff jittered");
+    expect(await systemPrompt(session.id)).toContain(
+      "make the retry backoff jittered",
+    );
   });
 
   it("rejects an empty rehydrateFrom rather than silently ignoring it", async () => {
     server = await boot("claude-code");
-    const response = await fetch(`http://127.0.0.1:${server.port}/api/sessions`, {
-      method: "POST",
-      headers: { "content-type": "application/json", "x-harness-token": "test-token" },
-      body: JSON.stringify({ cwd, harness: "claude-code", rehydrateFrom: "" }),
-    });
+    const response = await fetch(
+      `http://127.0.0.1:${server.port}/api/sessions`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-harness-token": "test-token",
+        },
+        body: JSON.stringify({
+          cwd,
+          harness: "claude-code",
+          rehydrateFrom: "",
+        }),
+      },
+    );
     expect(response.status).toBe(400);
   });
 });
diff --git a/packages/harness/src/server/rest.test.ts b/packages/harness/src/server/rest.test.ts
index a007e6461..4952d42bb 100644
--- a/packages/harness/src/server/rest.test.ts
+++ b/packages/harness/src/server/rest.test.ts
@@ -23,8 +23,11 @@ import type {
   WorkflowInfo,
 } from "../shared/types.js";
 import {
-  SessionManager,
   ProjectSessionScopeUnavailableError,
+  SessionBackgroundInputPreemptedError,
+  SessionInputIsolationError,
+  SessionManager,
+  SessionManagerClosingError,
   SessionNotReadyError,
   UnknownSessionError,
 } from "../core/session-manager.js";
@@ -49,11 +52,13 @@ function fakeSessionManager(initial: HarnessSession[] = []) {
     getAgentSessionOwner: vi.fn((agentSessionId: string) =>
       Array.from(sessions.values()).find(
         (session) => session.agentSessionId === agentSessionId,
-      )),
+      ),
+    ),
     isAgentSessionIdentityReserved: vi.fn((agentSessionId: string) =>
       Array.from(sessions.values()).some(
         (session) => session.agentSessionId === agentSessionId,
-      )),
+      ),
+    ),
     create: vi.fn(),
     resume: vi.fn(),
     kill: vi.fn(() => true),
@@ -111,20 +116,6 @@ function exitedSession(
   };
 }
 
-/** A valid legacy record normalized by SessionManager during boot. */
-function migratedProjectSession(): HarnessSession {
-  const identity = { projectId: "project-1", sessionId: "migrated-1", userId: "user-1" };
-  return exitedSession({
-    id: identity.sessionId,
-    agentMapIdentity: identity,
-    planning: {
-      identity: { ...identity, role: "map-planner" },
-      greeting: { status: "delivered", messageId: "message-1" },
-      queuedInputIds: [],
-    },
-  });
-}
-
 /** A history adapter whose resumability answer and transcript listing are both
  *  controllable — the two independent inputs the history endpoint merges. */
 function historyAdapter(
@@ -383,6 +374,99 @@ describe("createRestRouter", () => {
       expect(await reread.json()).toMatchObject({ rollingSummary: true });
     });
 
+    it("initializes only genuinely added committed recent directories", async () => {
+      const onRecentDirAdded = vi.fn(async () => {});
+      start({ onRecentDirAdded });
+      const existing = path.join(tmpHome, "existing");
+      const first = path.join(tmpHome, "first");
+      const second = path.join(tmpHome, "second");
+      await Promise.all([existing, first, second].map((dir) => fs.mkdir(dir)));
+      const update = (recentDirs: string[]) =>
+        fetch(`${baseUrl}/settings`, {
+          method: "PATCH",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ recentDirs }),
+        });
+
+      expect((await update([existing])).status).toBe(200);
+      onRecentDirAdded.mockClear();
+      expect((await update([first, existing, second])).status).toBe(200);
+      expect((await update([first, existing, second])).status).toBe(200);
+      expect((await update([second, existing, first])).status).toBe(200);
+
+      expect(onRecentDirAdded.mock.calls).toEqual([[first], [second]]);
+    });
+
+    it("returns committed settings while new-root initialization is still pending", async () => {
+      const first = path.join(tmpHome, "first");
+      const second = path.join(tmpHome, "second");
+      await Promise.all([first, second].map((dir) => fs.mkdir(dir)));
+      let releaseInitialization!: () => void;
+      const initialization = new Promise<void>((resolve) => {
+        releaseInitialization = resolve;
+      });
+      const onRecentDirAdded = vi.fn(async (root: string) => {
+        if (root === first) await initialization;
+      });
+      start({ onRecentDirAdded });
+      let responded = false;
+      const pendingResponse = fetch(`${baseUrl}/settings`, {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ recentDirs: [first, second] }),
+      }).then((response) => {
+        responded = true;
+        return response;
+      });
+
+      try {
+        await vi.waitFor(() => expect(onRecentDirAdded).toHaveBeenCalledWith(first));
+        const reread = await fetch(`${baseUrl}/settings`);
+        expect(await reread.json()).toMatchObject({ recentDirs: [first, second] });
+        await vi.waitFor(() => expect(responded).toBe(true), { timeout: 250 });
+        const response = await pendingResponse;
+        expect(response.status).toBe(200);
+        expect(await response.json()).toMatchObject({ recentDirs: [first, second] });
+        expect(onRecentDirAdded.mock.calls).toEqual([[first], [second]]);
+      } finally {
+        releaseInitialization();
+        await pendingResponse;
+      }
+    });
+
+    it("keeps a committed settings PATCH successful when project initialization is deferred", async () => {
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+      const first = path.join(tmpHome, "first");
+      const second = path.join(tmpHome, "second");
+      await Promise.all([first, second].map((dir) => fs.mkdir(dir)));
+      const onRecentDirAdded = vi.fn(async (root: string) => {
+        if (root === first) throw new Error(`private failure at ${root}`);
+      });
+      start({ onRecentDirAdded });
+
+      const response = await fetch(`${baseUrl}/settings`, {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ recentDirs: [first, second] }),
+      });
+
+      expect(response.status).toBe(200);
+      expect(await response.json()).toMatchObject({
+        recentDirs: [first, second],
+      });
+      expect(onRecentDirAdded.mock.calls).toEqual([[first], [second]]);
+      expect(error).toHaveBeenCalledTimes(1);
+      expect(error).toHaveBeenCalledWith(
+        "[harness] project initialization deferred after settings commit",
+      );
+      expect(JSON.stringify(error.mock.calls)).not.toContain(tmpHome);
+
+      const reread = await fetch(`${baseUrl}/settings`);
+      expect(await reread.json()).toMatchObject({
+        recentDirs: [first, second],
+      });
+    });
+
     it("calls onTelemetryOptInChange only when telemetryOptIn actually changes", async () => {
       start();
       await fetch(`${baseUrl}/settings`, {
@@ -422,7 +506,10 @@ describe("createRestRouter", () => {
       const res = await fetch(`${baseUrl}/settings`, {
         method: "PATCH",
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({ helpSeen: true, telemetryNoticeDismissed: true }),
+        body: JSON.stringify({
+          helpSeen: true,
+          telemetryNoticeDismissed: true,
+        }),
       });
       expect(await res.json()).toMatchObject({
         helpSeen: true,
@@ -455,26 +542,6 @@ describe("createRestRouter", () => {
   });
 
   describe("POST /sessions", () => {
-    it("accepts the composer's content-free first-input hint", async () => {
-      const sessionManager = fakeSessionManager();
-      (sessionManager.create as ReturnType<typeof vi.fn>).mockResolvedValue(
-        exitedSession({ status: "starting" }),
-      );
-      start({ sessionManager });
-      const response = await fetch(`${baseUrl}/sessions`, {
-        method: "POST",
-        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
-        body: JSON.stringify({
-          cwd: "/tmp/proj",
-          harness: "claude-code",
-          initialUserInputPending: true,
-        }),
-      });
-      expect(response.status).toBe(201);
-      expect(sessionManager.create).toHaveBeenCalledWith(
-        expect.objectContaining({ initialUserInputPending: true }),
-      );
-    });
 
     it("calls onSessionCreated with the new session's cwd and id", async () => {
       const onSessionCreated = vi.fn();
@@ -511,7 +578,7 @@ describe("createRestRouter", () => {
       expect(onSessionCreated).not.toHaveBeenCalled();
     });
 
-    it("rejects role and project spoofing on generic session creation", async () => {
+    it("rejects project-authority spoofing on generic session creation", async () => {
       const sessionManager = fakeSessionManager();
       start({ sessionManager });
 
@@ -521,7 +588,7 @@ describe("createRestRouter", () => {
         body: JSON.stringify({
           cwd: "/tmp/proj",
           harness: "codex",
-          role: "map-planner",
+          authority: "forged",
           projectId: "forged-project",
         }),
       });
@@ -629,6 +696,36 @@ describe("createRestRouter", () => {
         "HARNESS_EXTERNAL",
       );
     });
+
+    it.each([
+      {
+        error: new ProjectSessionScopeUnavailableError("secret-session-id"),
+        code: "PROJECT_SESSION_SCOPE_UNAVAILABLE",
+        message: "the session's Studio project scope could not be revalidated",
+      },
+      {
+        error: new SessionManagerClosingError(),
+        code: "SESSION_MANAGER_CLOSING",
+        message: "session manager is shutting down",
+      },
+    ])("maps $code to a bounded 409", async ({ error, code, message }) => {
+      const sessionManager = fakeSessionManager();
+      (sessionManager.create as ReturnType<typeof vi.fn>).mockRejectedValue(
+        error,
+      );
+      start({ sessionManager });
+
+      const res = await fetch(`${baseUrl}/sessions`, {
+        method: "POST",
+        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+        body: JSON.stringify({ cwd: "/tmp/proj", harness: "claude-code" }),
+      });
+
+      expect(res.status).toBe(409);
+      const body = await res.json();
+      expect(body).toEqual({ code, error: message });
+      expect(JSON.stringify(body)).not.toContain("secret-session-id");
+    });
   });
 
   describe("POST /sessions/:id/attachments", () => {
@@ -774,37 +871,6 @@ describe("createRestRouter", () => {
   });
 
   describe("POST /sessions/:id/input", () => {
-    it("routes migrated session input through the durable lifecycle boundary", async () => {
-      const session = migratedProjectSession();
-      const sessionManager = fakeSessionManager([session]);
-      const submitSessionInput = vi.fn(async () => true);
-      start({ sessionManager, submitSessionInput });
-      const response = await fetch(`${baseUrl}/sessions/${session.id}/input`, {
-        method: "POST",
-        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
-        body: JSON.stringify({ text: "keep this request" }),
-      });
-      expect(response.status).toBe(200);
-      expect(submitSessionInput).toHaveBeenCalledWith(session.id, "keep this request", true);
-      expect(sessionManager.submitInput).not.toHaveBeenCalled();
-    });
-
-    it("returns a scope conflict when a migrated session loses authority", async () => {
-      const session = migratedProjectSession();
-      const sessionManager = fakeSessionManager([session]);
-      const submitSessionInput = vi.fn(async () => {
-        throw new ProjectSessionScopeUnavailableError(session.id);
-      });
-      start({ sessionManager, submitSessionInput });
-      const response = await fetch(`${baseUrl}/sessions/${session.id}/input`, {
-        method: "POST",
-        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
-        body: JSON.stringify({ text: "must not dispatch" }),
-      });
-      expect(response.status).toBe(409);
-      expect(sessionManager.submitInput).not.toHaveBeenCalled();
-    });
-
     it("submits input and returns ok:true", async () => {
       const sessionManager = fakeSessionManager();
       start({ sessionManager });
@@ -824,6 +890,144 @@ describe("createRestRouter", () => {
       );
     });
 
+    it("forwards submitted and editable input through the injected canonical authority exactly once", async () => {
+      const submitSessionInput = vi.fn(
+        async (
+          _sessionId: string,
+          _text: string,
+          _submit: boolean,
+          requestId?: string,
+        ) =>
+          requestId
+            ? {
+                ok: true as const,
+                receipt: {
+                  requestId,
+                  inputId: "input-1",
+                  status: "queued" as const,
+                  acceptedAt: "2026-09-04T00:00:00.000Z",
+                },
+              }
+            : true,
+      );
+      start({ submitSessionInput });
+
+      const [submitted, editable] = await Promise.all([
+        fetch(`${baseUrl}/sessions/bootstrap-owned/input`, {
+          method: "POST",
+          headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+          body: JSON.stringify({
+            text: "build now",
+            requestId: "request-build-now",
+          }),
+        }),
+        fetch(`${baseUrl}/sessions/bootstrap-owned/input`, {
+          method: "POST",
+          headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+          body: JSON.stringify({ text: "draft", submit: false }),
+        }),
+      ]);
+
+      expect(submitted.status).toBe(200);
+      expect(editable.status).toBe(200);
+      expect(await submitted.json()).toEqual({
+        ok: true,
+        receipt: {
+          requestId: "request-build-now",
+          inputId: "input-1",
+          status: "queued",
+          acceptedAt: "2026-09-04T00:00:00.000Z",
+        },
+      });
+      expect(submitSessionInput).toHaveBeenCalledTimes(2);
+      expect(submitSessionInput).toHaveBeenCalledWith(
+        "bootstrap-owned",
+        "build now",
+        true,
+        "request-build-now",
+      );
+      expect(submitSessionInput).toHaveBeenCalledWith(
+        "bootstrap-owned",
+        "draft",
+        false,
+        undefined,
+      );
+    });
+
+    it("returns the durable request-id conflict from the canonical input authority", async () => {
+      const conflict = Object.assign(
+        new Error(
+          "project bootstrap request id was reused with different input",
+        ),
+        { code: "project_bootstrap_request_id_reused" },
+      );
+      const submitSessionInput = vi.fn(async () => {
+        throw conflict;
+      });
+      start({ submitSessionInput });
+
+      const response = await fetch(
+        `${baseUrl}/sessions/bootstrap-owned/input`,
+        {
+          method: "POST",
+          headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+          body: JSON.stringify({
+            text: "changed payload",
+            requestId: "request-reused",
+          }),
+        },
+      );
+
+      expect(response.status).toBe(409);
+      expect(await response.json()).toEqual({
+        error: conflict.message,
+        code: conflict.code,
+      });
+      expect(submitSessionInput).toHaveBeenCalledWith(
+        "bootstrap-owned",
+        "changed payload",
+        true,
+        "request-reused",
+      );
+    });
+
+    it("returns bounded durable-input capacity from the canonical input authority", async () => {
+      const capacity = Object.assign(
+        new Error(
+          "project bootstrap input receipt capacity is temporarily full",
+        ),
+        { code: "project_bootstrap_input_capacity" },
+      );
+      const submitSessionInput = vi.fn(async () => {
+        throw capacity;
+      });
+      start({ submitSessionInput });
+
+      const response = await fetch(
+        `${baseUrl}/sessions/bootstrap-owned/input`,
+        {
+          method: "POST",
+          headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+          body: JSON.stringify({
+            text: "new logical request",
+            requestId: "request-at-capacity",
+          }),
+        },
+      );
+
+      expect(response.status).toBe(409);
+      expect(await response.json()).toEqual({
+        error: capacity.message,
+        code: capacity.code,
+      });
+      expect(submitSessionInput).toHaveBeenCalledWith(
+        "bootstrap-owned",
+        "new logical request",
+        true,
+        "request-at-capacity",
+      );
+    });
+
     it("400s a malformed body (missing text)", async () => {
       start();
       const res = await fetch(`${baseUrl}/sessions/sess-1/input`, {
@@ -834,33 +1038,30 @@ describe("createRestRouter", () => {
       expect(res.status).toBe(400);
     });
 
-    it("requires planner input to use the project-scoped FIFO", async () => {
-      const planner = exitedSession({
-        id: "planner-1",
-        planning: {
-          identity: {
-            projectId: "project-1",
-            sessionId: "planner-1",
-            userId: "user-1",
-            role: "map-planner",
-          },
-          greeting: { status: "pending" },
-          queuedInputIds: [],
+    it("accepts ordinary input for a project session without a role-specific 409", async () => {
+      const projectSession = exitedSession({
+        id: "project-session-1",
+        agentMapIdentity: {
+          projectId: "project-1",
+          sessionId: "project-session-1",
+          userId: "user-1",
         },
       });
-      const sessionManager = fakeSessionManager([planner]);
+      const sessionManager = fakeSessionManager([projectSession]);
       start({ sessionManager });
 
-      const res = await fetch(`${baseUrl}/sessions/planner-1/input`, {
+      const res = await fetch(`${baseUrl}/sessions/project-session-1/input`, {
         method: "POST",
         headers: { ...TOKEN_HEADER, "content-type": "application/json" },
         body: JSON.stringify({ text: "bypass" }),
       });
-      expect(res.status).toBe(409);
-      expect(await res.json()).toMatchObject({
-        code: "planner_session_requires_scoped_route",
-      });
-      expect(sessionManager.submitInput).not.toHaveBeenCalled();
+      expect(res.status).toBe(200);
+      expect(await res.json()).toEqual({ ok: true });
+      expect(sessionManager.submitInput).toHaveBeenCalledWith(
+        projectSession.id,
+        "bypass",
+        true,
+      );
     });
 
     it("404s when submitInput reports no live pty for the session", async () => {
@@ -896,6 +1097,46 @@ describe("createRestRouter", () => {
       expect(body.error).toMatch(/not ready yet/i);
       expect(body.error).toMatch(/trust the folder/i);
     });
+
+    it("409s a concurrent staged submission without adding another dispatch", async () => {
+      const submitSessionInput = vi.fn(async () => {
+        throw new SessionBackgroundInputPreemptedError(false);
+      });
+      start({ submitSessionInput });
+
+      const res = await fetch(`${baseUrl}/sessions/sess-1/input`, {
+        method: "POST",
+        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+        body: JSON.stringify({ text: "overlapping input" }),
+      });
+
+      expect(res.status).toBe(409);
+      expect(await res.json()).toEqual({
+        code: "SESSION_BACKGROUND_INPUT_PREEMPTED",
+        error: "background session input was preempted by user input",
+      });
+      expect(submitSessionInput).toHaveBeenCalledOnce();
+    });
+
+    it("409s a fenced terminal composer so the caller can retry after reset", async () => {
+      const submitSessionInput = vi.fn(async () => {
+        throw new SessionInputIsolationError();
+      });
+      start({ submitSessionInput });
+
+      const res = await fetch(`${baseUrl}/sessions/sess-1/input`, {
+        method: "POST",
+        headers: { ...TOKEN_HEADER, "content-type": "application/json" },
+        body: JSON.stringify({ text: "retry after reset" }),
+      });
+
+      expect(res.status).toBe(409);
+      expect(await res.json()).toEqual({
+        code: "SESSION_INPUT_ISOLATION_REQUIRED",
+        error: "session input is blocked until the terminal composer is reset",
+      });
+      expect(submitSessionInput).toHaveBeenCalledOnce();
+    });
   });
 
   describe("PATCH /sessions/:id/workflow", () => {
@@ -1032,45 +1273,32 @@ describe("createRestRouter", () => {
   });
 
   describe("POST /sessions/:id/resume — error class → HTTP status mapping", () => {
-    it("resumes a migrated project session by its exact ordinary session id", async () => {
-      const session = migratedProjectSession();
-      const sessionManager = fakeSessionManager([session]);
-      (sessionManager.resume as ReturnType<typeof vi.fn>).mockResolvedValue(session);
-      start({ sessionManager });
-      const response = await fetch(`${baseUrl}/sessions/${session.id}/resume`, {
-        method: "POST",
-        headers: TOKEN_HEADER,
-      });
-      expect(response.status).toBe(200);
-      expect(sessionManager.resume).toHaveBeenCalledWith(session.id);
-    });
-
-    it("requires planner resume to use the trusted project resolver", async () => {
-      const planner = exitedSession({
-        id: "planner-1",
-        planning: {
-          identity: {
-            projectId: "project-1",
-            sessionId: "planner-1",
-            userId: "user-1",
-            role: "map-planner",
-          },
-          greeting: { status: "delivered", messageId: "message-1" },
-          queuedInputIds: [],
+    it("resumes a project session through the ordinary endpoint without a role-specific 409", async () => {
+      const projectSession = exitedSession({
+        id: "project-session-1",
+        agentMapIdentity: {
+          projectId: "project-1",
+          sessionId: "project-session-1",
+          userId: "user-1",
         },
       });
-      const sessionManager = fakeSessionManager([planner]);
+      const sessionManager = fakeSessionManager([projectSession]);
+      (sessionManager.resume as ReturnType<typeof vi.fn>).mockResolvedValue({
+        ...projectSession,
+        status: "running",
+      });
       start({ sessionManager });
 
-      const res = await fetch(`${baseUrl}/sessions/planner-1/resume`, {
+      const res = await fetch(`${baseUrl}/sessions/project-session-1/resume`, {
         method: "POST",
         headers: TOKEN_HEADER,
       });
-      expect(res.status).toBe(409);
+      expect(res.status).toBe(200);
       expect(await res.json()).toMatchObject({
-        code: "planner_session_requires_scoped_route",
+        id: projectSession.id,
+        status: "running",
       });
-      expect(sessionManager.resume).not.toHaveBeenCalled();
+      expect(sessionManager.resume).toHaveBeenCalledWith(projectSession.id);
     });
 
     it("404s when resume() throws UnknownSessionError (class-based dispatch, not string match)", async () => {
@@ -1142,6 +1370,25 @@ describe("createRestRouter", () => {
       expect(body.code).toBe("SESSION_NOT_RESUMEABLE");
     });
 
+    it("409s with a bounded code when project scope cannot be revalidated", async () => {
+      const sessionManager = fakeSessionManager();
+      (sessionManager.resume as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new ProjectSessionScopeUnavailableError("private-session-id"),
+      );
+      start({ sessionManager });
+
+      const res = await fetch(`${baseUrl}/sessions/private-session-id/resume`, {
+        method: "POST",
+        headers: TOKEN_HEADER,
+      });
+
+      expect(res.status).toBe(409);
+      expect(await res.json()).toEqual({
+        error: "the session's Studio project scope could not be revalidated",
+        code: "PROJECT_SESSION_SCOPE_UNAVAILABLE",
+      });
+    });
+
     it("400s when resume() throws AdapterNotFoundError (persisted session with unknown harness kind — C2)", async () => {
       // Simulates a sessions.json entry with harness: "future-harness" that
       // has no registered adapter — should be a 400 not a 500.
@@ -1480,33 +1727,48 @@ describe("createRestRouter", () => {
       expect(sessionManager.resume).toHaveBeenCalledWith("sess-existing");
     });
 
-    it("adopts a migrated project conversation through its existing session", async () => {
-      const session = { ...migratedProjectSession(), agentSessionId: body.agentSessionId };
-      const sessionManager = fakeSessionManager([session]);
-      (sessionManager.resume as ReturnType<typeof vi.fn>).mockResolvedValue(session);
-      start({ sessionManager, adapters: { "claude-code": historyAdapter() } });
-      expect((await adopt(body)).status).toBe(200);
+    it("bounds a scope-revalidation failure on the ordinary adopt path", async () => {
+      const existing = exitedSession({
+        id: "sess-existing",
+        agentSessionId: body.agentSessionId,
+      });
+      const sessionManager = fakeSessionManager([existing]);
+      (sessionManager.resume as ReturnType<typeof vi.fn>).mockRejectedValue(
+        new ProjectSessionScopeUnavailableError(existing.id),
+      );
+      start({
+        sessionManager,
+        adapters: {
+          "claude-code": historyAdapter({ canResume: async () => true }),
+        },
+      });
+
+      const res = await adopt(body);
+
+      expect(res.status).toBe(409);
+      expect(await res.json()).toEqual({
+        error: "the session's Studio project scope could not be revalidated",
+        code: "PROJECT_SESSION_SCOPE_UNAVAILABLE",
+      });
       expect(sessionManager.registerHistorical).not.toHaveBeenCalled();
-      expect(sessionManager.resume).toHaveBeenCalledWith(session.id);
+      expect(sessionManager.resume).toHaveBeenCalledWith(existing.id);
     });
 
-    it("requires an existing foreign-owned planner to use its scoped route without mutation", async () => {
-      const planner = exitedSession({
-        id: "planner-existing",
+    it("reuses an existing owner through ordinary adopt without duplicating its record", async () => {
+      const existingOwner = exitedSession({
+        id: "project-session-existing",
         agentSessionId: body.agentSessionId,
-        planning: {
-          identity: {
-            projectId: "foreign-project",
-            sessionId: "planner-existing",
-            userId: "foreign-user",
-            role: "map-planner",
-          },
-          greeting: { status: "delivered", messageId: "message-1" },
-          queuedInputIds: [],
+        agentMapIdentity: {
+          projectId: "foreign-project",
+          sessionId: "project-session-existing",
+          userId: "foreign-user",
         },
       });
-      const original = structuredClone(planner.planning);
-      const sessionManager = fakeSessionManager([planner]);
+      const sessionManager = fakeSessionManager([existingOwner]);
+      (sessionManager.resume as ReturnType<typeof vi.fn>).mockResolvedValue({
+        ...existingOwner,
+        status: "running",
+      });
       const canResume = vi.fn(async () => true);
       start({
         sessionManager,
@@ -1515,39 +1777,36 @@ describe("createRestRouter", () => {
         },
       });
 
-      const res = await adopt({ ...body, cwd: "/tmp/client-supplied-alias" });
+      const res = await adopt(body);
 
-      expect(res.status).toBe(409);
+      expect(res.status).toBe(200);
       expect(await res.json()).toMatchObject({
-        code: "planner_session_requires_scoped_route",
+        id: existingOwner.id,
+        status: "running",
       });
-      expect(canResume).not.toHaveBeenCalled();
+      expect(canResume).toHaveBeenCalledWith(body.agentSessionId, body.cwd);
       expect(sessionManager.registerHistorical).not.toHaveBeenCalled();
-      expect(sessionManager.resume).not.toHaveBeenCalled();
-      expect(sessionManager.get("planner-existing")?.planning).toEqual(original);
+      expect(sessionManager.resume).toHaveBeenCalledWith(existingOwner.id);
     });
 
-    it("rejects a rotated planner's durable old alias even though its current pointer changed", async () => {
-      const planner = exitedSession({
-        id: "planner-rotated",
+    it("rejects a durable rotated provider alias independently of project context", async () => {
+      const projectSession = exitedSession({
+        id: "project-session-rotated",
         agentSessionId: "vendor-new",
-        planning: {
-          identity: {
-            projectId: "project-1",
-            sessionId: "planner-rotated",
-            userId: "user-1",
-            role: "map-planner",
-          },
-          greeting: { status: "delivered", messageId: "message-1" },
-          queuedInputIds: [],
-        },
       });
-      const sessionManager = fakeSessionManager([planner]);
+      const sessionManager = fakeSessionManager([projectSession]);
       (
-        sessionManager.getAgentSessionOwner as unknown as ReturnType<typeof vi.fn>
+        sessionManager.getAgentSessionOwner as unknown as ReturnType<
+          typeof vi.fn
+        >
       ).mockImplementation((agentSessionId: string) =>
-        agentSessionId === body.agentSessionId ? planner : undefined,
+        agentSessionId === body.agentSessionId ? projectSession : undefined,
       );
+      (
+        sessionManager.isAgentSessionIdentityReserved as unknown as ReturnType<
+          typeof vi.fn
+        >
+      ).mockReturnValue(true);
       const canResume = vi.fn(async () => true);
       start({
         sessionManager,
@@ -1558,7 +1817,7 @@ describe("createRestRouter", () => {
 
       expect(response.status).toBe(409);
       expect(await response.json()).toMatchObject({
-        code: "planner_session_requires_scoped_route",
+        code: "AGENT_SESSION_IDENTITY_RESERVED",
       });
       expect(canResume).not.toHaveBeenCalled();
       expect(sessionManager.registerHistorical).not.toHaveBeenCalled();
@@ -1573,7 +1832,9 @@ describe("createRestRouter", () => {
       const original = structuredClone(owner);
       const sessionManager = fakeSessionManager([owner]);
       (
-        sessionManager.getAgentSessionOwner as unknown as ReturnType<typeof vi.fn>
+        sessionManager.getAgentSessionOwner as unknown as ReturnType<
+          typeof vi.fn
+        >
       ).mockImplementation((agentSessionId: string) =>
         agentSessionId === body.agentSessionId ? owner : undefined,
       );
diff --git a/packages/harness/src/server/rest.ts b/packages/harness/src/server/rest.ts
index 3744064c2..ac63ef739 100644
--- a/packages/harness/src/server/rest.ts
+++ b/packages/harness/src/server/rest.ts
@@ -1,3 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { resolveWithinRoot } from "../core/path-safety.js";
 /**
  * REST surface under /api — see src/shared/types.ts for the full contract
  * table. This router covers the session-lifecycle endpoints (W1); workflows,
@@ -7,10 +10,8 @@
 import express, { Router } from "express";
 import rateLimit from "express-rate-limit";
 import { z } from "zod";
-
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
+
 import type {
   AdoptSessionRequest,
   AnalyticsEvent,
@@ -31,13 +32,14 @@ import type {
   UiEventName,
   UiTrackRequest,
   WorkflowInfo,
+  SessionInputSubmissionResult,
 } from "../shared/types.js";
 import type { WorkspaceScopeSummary } from "../shared/system-graph.js";
 import type { StudioProjectSummary } from "../shared/agent-map.js";
 import {
   HARNESS_UPLOADS_DIR,
-  JSON_BODY_LIMIT_BYTES,
   MAX_INLINE_ATTACHMENT_BYTES,
+  JSON_BODY_LIMIT_BYTES,
   SPAWNABLE_HARNESS_KINDS,
   EDITOR_KINDS,
 } from "../shared/types.js";
@@ -49,15 +51,28 @@ import {
   SessionNotResumeableError,
   SpawnTargetError,
 } from "../core/errors.js";
-import { ProjectSessionScopeUnavailableError, SessionNotReadyError, UnknownSessionError, type SessionManager } from "../core/session-manager.js";
+import {
+  ProjectSessionScopeUnavailableError,
+  SessionBackgroundInputPreemptedError,
+  SessionInputIsolationError,
+  SessionManagerClosingError,
+  SessionNotReadyError,
+  UnknownSessionError,
+  type SessionManager,
+} from "../core/session-manager.js";
 import { normalizeCwd } from "./cwd-normalize.js";
 import type { SessionRecordReader } from "../core/session-record.js";
-import { getHarnessAdapter, listHarnessAdapters } from "../core/adapters/registry.js";
-import { resolveWithinRoot } from "../core/path-safety.js";
+import {
+  getHarnessAdapter,
+  listHarnessAdapters,
+} from "../core/adapters/registry.js";
 import { loadSettings, saveSettings } from "../cli/settings.js";
 
+
+
 const DATA_URL_RE = /^data:([a-z0-9.+/-]+);base64,([\s\S]+)$/i;
 
+
 /** Validate standard padded base64 in one pass and return decoded size. */
 function decodedBase64Size(encoded: string): number | null {
   if (encoded.length === 0 || encoded.length % 4 !== 0) return null;
@@ -92,6 +107,7 @@ const createSessionSchema = z.object({
 const injectInputSchema = z.object({
   text: z.string(),
   submit: z.boolean().optional(),
+  requestId: z.string().min(1).max(200).optional(),
 }) satisfies z.ZodType<InjectInputRequest>;
 
 const attachFileSchema = z.object({
@@ -196,7 +212,11 @@ export interface RestRouterOptions {
   adapters: Partial<Record<HarnessKind, HarnessAdapter>>;
   version: string;
   /** Sapiom identity from CLI auth; null when unauthenticated / --no-auth. */
-  identity: { userId: string; tenantId: string; organizationName: string } | null;
+  identity: {
+    userId: string;
+    tenantId: string;
+    organizationName: string;
+  } | null;
   listWorkflows: () => Promise<WorkflowInfo[]>;
   /** Workspace identities backing the folder projection and system-graph route. */
   listWorkspaceScopes?: () =>
@@ -228,18 +248,24 @@ export interface RestRouterOptions {
   /** Called after a settings PATCH persists a changed telemetryOptIn, so the
    * live collector batcher can be gated without a server restart. */
   onTelemetryOptInChange?: (optIn: boolean) => void;
+  /** Called only for roots newly added to the user's durable project list. */
+  onRecentDirAdded?: (root: string) => Promise<void> | void;
   /** Called (fire-and-forget) after a session is created, with its cwd and id
    * — lets the integrator scan that directory for workflows (so opening a
    * session in a new project discovers them without a manual "+ Connect")
    * and, when the scan discovers one, render the new session's canvas. */
   onSessionCreated?: (cwd: string, harnessSessionId: string) => void;
-  /** Keeps migrated sessions on their durable startup FIFO while the
-   * project bootstrap coordinator replaces the legacy implementation. */
+  /**
+   * Optional lifecycle-aware input boundary. It lets a pending project
+   * bootstrap yield durably to real user input; ordinary sessions fall back
+   * to SessionManager.submitInput.
+   */
   submitSessionInput?: (
     sessionId: string,
     text: string,
     submit: boolean,
-  ) => Promise<boolean>;
+    requestId?: string,
+  ) => Promise<boolean | SessionInputSubmissionResult>;
   /** The directory the CLI was launched against — surfaced in AppState so the
    * SPA can prefill the new-session modal with it. */
   launchDir: string;
@@ -394,13 +420,34 @@ export function createRestRouter(options: RestRouterOptions): Router {
       const current = await loadSettings(options.settingsPath);
       const updated: HarnessSettings = { ...current, ...parsed.data };
       await saveSettings(updated, options.settingsPath);
+      // saveSettings owns path validation, de-duplication, and the eight-entry
+      // cap. Re-read the committed shape so lifecycle work and the response
+      // describe what actually reached disk, never raw submitted paths.
+      const committed = await loadSettings(options.settingsPath);
       if (
         parsed.data.telemetryOptIn !== undefined &&
         parsed.data.telemetryOptIn !== current.telemetryOptIn
       ) {
         options.onTelemetryOptInChange?.(parsed.data.telemetryOptIn);
       }
-      res.json(updated);
+      if (parsed.data.recentDirs) {
+        const existing = new Set(current.recentDirs);
+        for (const root of committed.recentDirs) {
+          if (existing.has(root)) continue;
+          // Initialization may fetch configuration or start a provider. Each
+          // root proceeds independently after the durable settings commit;
+          // neither it nor the HTTP response waits for another root's start.
+          void Promise.resolve()
+            .then(() => options.onRecentDirAdded?.(root))
+            .catch(() => {
+              // Normal state reconciliation recovers the committed root.
+              console.error(
+                "[harness] project initialization deferred after settings commit",
+              );
+            });
+        }
+      }
+      res.json(committed);
     } catch (err) {
       next(err);
     }
@@ -455,14 +502,21 @@ export function createRestRouter(options: RestRouterOptions): Router {
       res.status(201).json(session);
       options.onSessionCreated?.(request.cwd, session.id);
     } catch (err) {
-      if (err instanceof AdapterNotFoundError || err instanceof SpawnTargetError) {
+      if (
+        err instanceof AdapterNotFoundError ||
+        err instanceof SpawnTargetError
+      ) {
         // Both are user-actionable ("install claude", "restart to repair") —
         // the dialog renders this message verbatim, so a 500 here buried the
         // one string that tells the user what to do.
         res.status(400).json({ error: err.message, code: err.code });
         return;
       }
-      if (err instanceof ExternalHarnessError) {
+      if (
+        err instanceof ExternalHarnessError ||
+        err instanceof ProjectSessionScopeUnavailableError ||
+        err instanceof SessionManagerClosingError
+      ) {
         res.status(409).json({ error: err.message, code: err.code });
         return;
       }
@@ -627,7 +681,9 @@ export function createRestRouter(options: RestRouterOptions): Router {
       // agent session — they carry live status the transcript can't know.
       const registryRows = sessionManager
         .list()
-        .filter((session) => session.cwd === cwd && session.agentSessionId != null);
+        .filter(
+          (session) => session.cwd === cwd && session.agentSessionId != null,
+        );
       // Only rows the scan did NOT account for need a direct probe — the
       // phantoms, plus the narrow case of a transcript that exists but holds
       // no line our parser understands (see ClaudeCodeAdapter.canResume, which
@@ -636,7 +692,12 @@ export function createRestRouter(options: RestRouterOptions): Router {
         registryRows.map(async (session) =>
           foundInStore.has(`${session.harness}\u0000${session.agentSessionId!}`)
             ? true
-            : agentHoldsConversation(adapters, session.harness, session.agentSessionId!, session.cwd),
+            : agentHoldsConversation(
+                adapters,
+                session.harness,
+                session.agentSessionId!,
+                session.cwd,
+              ),
         ),
       );
 
@@ -655,7 +716,10 @@ export function createRestRouter(options: RestRouterOptions): Router {
       });
       for (const record of transcripts) {
         if (byAgentSessionId.has(record.agentSessionId)) continue;
-        byAgentSessionId.set(record.agentSessionId, { ...record, resumeMode: "agent-resume" });
+        byAgentSessionId.set(record.agentSessionId, {
+          ...record,
+          resumeMode: "agent-resume",
+        });
       }
 
       const merged = Array.from(byAgentSessionId.values()).sort((a, b) =>
@@ -676,7 +740,9 @@ export function createRestRouter(options: RestRouterOptions): Router {
         for (const summary of merged) {
           const turnCount =
             turnCounts.get(summary.agentSessionId) ??
-            (summary.harnessSessionId ? turnCounts.get(summary.harnessSessionId) : undefined);
+            (summary.harnessSessionId
+              ? turnCounts.get(summary.harnessSessionId)
+              : undefined);
           if (turnCount !== undefined) summary.turnCount = turnCount;
         }
       }
@@ -699,7 +765,10 @@ export function createRestRouter(options: RestRouterOptions): Router {
       res.status(404).json({ error: err.message });
       return true;
     }
-    if (err instanceof AdapterNotFoundError || err instanceof SpawnTargetError) {
+    if (
+      err instanceof AdapterNotFoundError ||
+      err instanceof SpawnTargetError
+    ) {
       // AdapterNotFoundError: a persisted session with an unknown harness kind
       // (e.g. from a future or removed harness type) cannot be resumed.
       // SpawnTargetError: the agent binary can't be spawned on Windows (not on
@@ -711,11 +780,13 @@ export function createRestRouter(options: RestRouterOptions): Router {
     if (
       err instanceof ExternalHarnessError ||
       err instanceof AgentSessionIdentityReservedError ||
+      err instanceof ProjectSessionScopeUnavailableError ||
       err instanceof SessionAlreadyLiveError ||
-      err instanceof SessionNotResumeableError ||
-      err instanceof ProjectSessionScopeUnavailableError
+      err instanceof SessionNotResumeableError
     ) {
-      res.status(409).json({ error: err.message, code: (err as { code: string }).code });
+      res
+        .status(409)
+        .json({ error: err.message, code: (err as { code: string }).code });
       return true;
     }
     return false;
@@ -730,35 +801,27 @@ export function createRestRouter(options: RestRouterOptions): Router {
   router.post("/sessions/adopt", async (req, res, next) => {
     const parsed = adoptSessionSchema.safeParse(req.body);
     if (!parsed.success) {
-      res.status(400).json({ error: parsed.error.issues.map((i) => i.message).join("; ") });
+      res
+        .status(400)
+        .json({ error: parsed.error.issues.map((i) => i.message).join("; ") });
       return;
     }
     const { agentSessionId, harness, title, lastActiveAt } = parsed.data;
     const cwd = normalizeCwd(parsed.data.cwd);
     try {
-      // Resolve ownership before probing or mutating adapter state. Valid
-      // migrated records use ordinary resume, whose manager revalidates their
-      // neutral project identity. Unmigrated legacy authority stays fenced.
+      // Resolve an already-owned registry row before probing or mutating any
+      // adapter state. Project scope is re-derived by SessionManager on the
+      // ordinary resume path; a legacy planner origin is metadata, never a
+      // separate authority or lifecycle route.
       const durableOwner = sessionManager.getAgentSessionOwner(agentSessionId);
       const identityReserved =
         sessionManager.isAgentSessionIdentityReserved(agentSessionId);
       const identityOwners = sessionManager
         .list()
         .filter((session) => session.agentSessionId === agentSessionId);
-      if (
-        (durableOwner?.planning !== undefined && !durableOwner.agentMapIdentity) ||
-        identityOwners.some(
-          (session) => session.planning !== undefined && !session.agentMapIdentity,
-        )
-      ) {
-        res.status(409).json({
-          code: "planner_session_requires_scoped_route",
-          error: "Planner sessions must be resumed through their project route",
-        });
-        return;
-      }
-      // Cwd remains part of the historical-record identity. Client-supplied
-      // paths cannot alias around current ownership or a durable reservation.
+      // Cwd remains part of the historical-record identity. The client cannot
+      // use it to choose Agent Map authority: the server resolves the current
+      // canonical project again before the resumed process is spawned.
       const existing = identityOwners.find(
         (session) => normalizeCwd(session.cwd) === cwd,
       );
@@ -774,7 +837,9 @@ export function createRestRouter(options: RestRouterOptions): Router {
       // Never take the client's word for resumability — it's re-derived from
       // the agent's own store here, so a stale history row (transcript deleted
       // between the list and the click) can't leave a phantom record behind.
-      if (!(await agentHoldsConversation(adapters, harness, agentSessionId, cwd))) {
+      if (
+        !(await agentHoldsConversation(adapters, harness, agentSessionId, cwd))
+      ) {
         const label = getHarnessAdapter(harness).label;
         res.status(409).json({
           error: `${label} no longer has the conversation for session ${agentSessionId} in ${cwd} — there is nothing to resume. Start a new session in this directory instead.`,
@@ -817,7 +882,9 @@ export function createRestRouter(options: RestRouterOptions): Router {
    */
   router.get("/sessions/:id/record", async (req, res, next) => {
     if (!options.sessionRecords) {
-      res.status(501).json({ error: "session records are not available on this server" });
+      res
+        .status(501)
+        .json({ error: "session records are not available on this server" });
       return;
     }
     try {
@@ -833,14 +900,6 @@ export function createRestRouter(options: RestRouterOptions): Router {
   });
 
   router.post("/sessions/:id/resume", async (req, res, next) => {
-    const existing = sessionManager.get(req.params.id);
-    if (existing?.planning && !existing.agentMapIdentity) {
-      res.status(409).json({
-        code: "planner_session_requires_scoped_route",
-        error: "Planner sessions must be resumed through their project route",
-      });
-      return;
-    }
     try {
       const session = await sessionManager.resume(req.params.id);
       res.json(session);
@@ -866,32 +925,50 @@ export function createRestRouter(options: RestRouterOptions): Router {
       res.status(400).json({ error: parsed.error.message });
       return;
     }
-    const existing = sessionManager.get(req.params.id);
-    if (
-      existing?.planning &&
-      (!existing.agentMapIdentity || !options.submitSessionInput)
-    ) {
-      res.status(409).json({
-        code: "planner_session_requires_scoped_route",
-        error: "Planner input must use the project-scoped message route",
-      });
-      return;
-    }
     try {
       const submit = parsed.data.submit ?? true;
-      const ok = options.submitSessionInput
-        ? await options.submitSessionInput(req.params.id, parsed.data.text, submit)
-        : await sessionManager.submitInput(req.params.id, parsed.data.text, submit);
-      if (!ok) {
+      const submitted = options.submitSessionInput
+        ? await options.submitSessionInput(
+            req.params.id,
+            parsed.data.text,
+            submit,
+            parsed.data.requestId,
+          )
+        : await sessionManager.submitInput(
+            req.params.id,
+            parsed.data.text,
+            submit,
+          );
+      const result =
+        typeof submitted === "boolean" ? { ok: submitted } : submitted;
+      if (!result.ok) {
         res.status(404).json({ error: "session not found or has no live pty" });
         return;
       }
-      res.json({ ok: true });
+      res.json(result);
     } catch (err) {
       if (
         err instanceof SessionNotReadyError ||
         err instanceof ExternalHarnessError ||
-        err instanceof ProjectSessionScopeUnavailableError
+        err instanceof SessionBackgroundInputPreemptedError ||
+        err instanceof SessionInputIsolationError
+      ) {
+        res.status(409).json({ error: err.message, code: err.code });
+        return;
+      }
+      if (
+        err instanceof Error &&
+        "code" in err &&
+        err.code === "project_bootstrap_dispatch_forbidden"
+      ) {
+        res.status(403).json({ error: err.message, code: err.code });
+        return;
+      }
+      if (
+        err instanceof Error &&
+        "code" in err &&
+        (err.code === "project_bootstrap_request_id_reused" ||
+          err.code === "project_bootstrap_input_capacity")
       ) {
         res.status(409).json({ error: err.message, code: err.code });
         return;
diff --git a/packages/harness/src/shared/agent-map.ts b/packages/harness/src/shared/agent-map.ts
index 303b673f0..d7ff1d8b9 100644
--- a/packages/harness/src/shared/agent-map.ts
+++ b/packages/harness/src/shared/agent-map.ts
@@ -337,109 +337,6 @@ export interface AgentMapReadSnapshot {
   proposal: MapChangeProposal | null;
 }
 
-export type PlannerGreetingErrorCode =
-  | "session_not_ready"
-  | "session_exited"
-  | "injection_failed"
-  | "model_turn_failed"
-  | "delivery_timeout"
-  | "persistence_failed";
-
-export type PlannerGreetingState =
-  | { status: "pending" }
-  | { status: "generating"; attemptId: string }
-  | { status: "delivered"; messageId: string }
-  | {
-      status: "failed";
-      retryable: boolean;
-      errorCode: PlannerGreetingErrorCode;
-    }
-  | { status: "skipped"; reason: "user-proceeded" };
-
-export interface PlannerSessionMetadata {
-  identity: Extract<PlanningSessionIdentity, { role: "map-planner" }>;
-  greeting: PlannerGreetingState;
-  queuedInputIds: string[];
-}
-
-export interface PlannerQueuedInput {
-  id: string;
-  sessionId: string;
-  text: string;
-  acceptedAt: string;
-}
-
-export interface PlannerSessionRequest {
-  mode: "resume-or-create" | "fresh";
-  harness?: import("./types.js").HarnessKind;
-  theme?: import("./types.js").UiTheme;
-}
-
-export interface PlannerSessionResponse {
-  session: import("./types.js").HarnessSession;
-  resolution: "created" | "live" | "resumed" | "rehydrated";
-}
-
-export interface PlannerMessageRequest {
-  text: string;
-}
-
-/** Authoritative coordinator state returned after a planner mutation. */
-export interface PlannerSessionMetadataResponse {
-  metadata: PlannerSessionMetadata;
-}
-
-/**
- * Content-free planner lifecycle telemetry. Callers may persist these fields,
- * but must never add prompts, assistant text, local paths, or provider errors.
- */
-export type PlannerLifecycleEvent =
-  | {
-      name: "planner_session.created" | "planner_session.resumed";
-      projectId: StudioProjectId;
-      sessionId: string;
-      resolution: PlannerSessionResponse["resolution"];
-    }
-  | {
-      name: "planner_greeting.attempted" | "planner_greeting.retried";
-      projectId: StudioProjectId;
-      sessionId: string;
-      attemptId: string;
-      queueDepth: number;
-    }
-  | {
-      name: "planner_greeting.delivered";
-      projectId: StudioProjectId;
-      sessionId: string;
-      attemptId: string;
-      queueDepth: number;
-    }
-  | {
-      name: "planner_greeting.failed";
-      projectId: StudioProjectId;
-      sessionId: string;
-      attemptId?: string;
-      errorCode: PlannerGreetingErrorCode;
-      retryable: boolean;
-      queueDepth: number;
-    }
-  | {
-      name: "planner_greeting.skipped";
-      projectId: StudioProjectId;
-      sessionId: string;
-      attemptId?: string;
-      reason: "user-proceeded";
-      queueDepth: number;
-    }
-  | {
-      name: "planner_session.input_delivery_uncertain";
-      projectId: StudioProjectId;
-      sessionId: string;
-      inputId: string;
-      errorCode: "delivery_uncertain";
-      queueDepth: number;
-    };
-
 export type ProjectBootstrapErrorCode =
   | "session_not_ready"
   | "session_exited"
diff --git a/packages/harness/src/shared/types.ts b/packages/harness/src/shared/types.ts
index 02761e590..933752d41 100644
--- a/packages/harness/src/shared/types.ts
+++ b/packages/harness/src/shared/types.ts
@@ -214,8 +214,6 @@ export interface HarnessSession {
    * answer the blocking prompt themselves.
    */
   ready: boolean;
-  /** Trusted Studio-owned role metadata. Generic POST /sessions cannot set it. */
-  planning?: import("./agent-map.js").PlannerSessionMetadata;
   /** Server-authored, path-free identity used only to revalidate MCP scope. */
   agentMapIdentity?: import("./agent-map.js").ProjectAgentSession;
   /** Context for the existing project startup; separate from authority. */
@@ -831,19 +829,17 @@ export type AnalyticsEventType =
   | "agent_map.workspace_read_failed"
   | "agent_map.mcp_tool"
   | "agent_map.capability"
-  | "planner_session.created"
-  | "planner_session.resumed"
-  | "planner_session.input_delivery_uncertain"
-  /** @deprecated Compatibility-only; new planner sessions do not inject synthetic greetings. */
-  | "planner_greeting.attempted"
-  /** @deprecated Compatibility-only; new planner sessions do not inject synthetic greetings. */
-  | "planner_greeting.delivered"
-  /** @deprecated Compatibility-only; new planner sessions do not inject synthetic greetings. */
-  | "planner_greeting.failed"
-  /** @deprecated Compatibility-only; new planner sessions do not inject synthetic greetings. */
-  | "planner_greeting.skipped"
-  /** @deprecated Compatibility-only; new planner sessions do not inject synthetic greetings. */
-  | "planner_greeting.retried";
+  | "project_agent.identity_migrated"
+  | "project_agent.identity_rejected"
+  | "project_bootstrap.scheduled"
+  | "project_bootstrap.recovered"
+  | "project_bootstrap.attempted"
+  | "project_bootstrap.retried"
+  | "project_bootstrap.delivered"
+  | "project_bootstrap.failed"
+  | "project_bootstrap.preempted"
+  | "project_bootstrap.skipped"
+  | "project_bootstrap.input_delivery_uncertain";
 
 /**
  * The normalized event — the shape that (with opt-in) is batched to the
@@ -1042,7 +1038,7 @@ export interface SessionRecord {
 // GET    /api/sessions/:id/record       → SessionRecord (reconstructed transcript)
 // POST   /api/sessions/:id/resume       → HarnessSession (new pty, --resume)
 // DELETE /api/sessions/:id              → { ok: true }   (kill pty)
-// POST   /api/sessions/:id/input        InjectInputRequest → { ok: true }
+// POST   /api/sessions/:id/input        InjectInputRequest → InjectInputResponse
 // POST   /api/sessions/:id/attachments  AttachFileRequest → AttachFileResponse (materialize only)
 // PATCH  /api/sessions/:id/workflow     BindWorkflowRequest → HarnessSession
 // POST   /api/agents/scaffold           { root, name, template? } → AgentScaffoldResponse (the harness creates the agent)
@@ -1161,6 +1157,12 @@ export interface InjectInputRequest {
   text: string;
   /** Append a carriage return (submit). Default true. */
   submit?: boolean;
+  /**
+   * Optional idempotency key used only when the new-project bootstrap FIFO
+   * owns this submitted turn. Ordinary post-bootstrap input remains one
+   * intentional message per request.
+   */
+  requestId?: string;
 }
 
 /** `PATCH /api/sessions/:id/workflow` body. `null` unbinds. `workflowPath`
@@ -1820,3 +1822,16 @@ export interface StudioRailLaunchEdge {
 export interface StudioRailLaunchEdgesResponse {
   edges: StudioRailLaunchEdge[];
 }
+
+export interface InjectInputResponse {
+  ok: true;
+  /** Present only when the durable bootstrap FIFO handled this request. */
+  receipt?: import("./agent-map.js").ProjectBootstrapInputReceipt;
+}
+
+export type SessionInputSubmissionResult =
+  | { ok: false }
+  | {
+      ok: true;
+      receipt?: import("./agent-map.js").ProjectBootstrapInputReceipt;
+    };