usebeeline 0.0.45 → 0.0.47

package/dist/usebeeline.mjs

@@ -196,11 +196,11 @@ function parseUpdateManifest(raw, platform) {
   }
   const bundle = entry;
   const file = typeof bundle.file === "string" ? bundle.file : "";
-  const sha2563 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
+  const sha2564 = typeof bundle.sha256 === "string" ? bundle.sha256.toLowerCase() : "";
   if (!file || !/^[a-z0-9][a-z0-9._-]*$/i.test(file)) {
     throw new Error(`update manifest names an unusable bundle file: ${JSON.stringify(bundle.file)}`);
   }
-  if (!/^[0-9a-f]{64}$/.test(sha2563)) {
+  if (!/^[0-9a-f]{64}$/.test(sha2564)) {
     throw new Error(`update manifest carries no usable sha256 for ${platform}`);
   }
   const sourceCommit = typeof bundle.commit === "string" && bundle.commit ? bundle.commit : typeof manifest.sourceCommit === "string" ? manifest.sourceCommit : void 0;
@@ -212,7 +212,7 @@ function parseUpdateManifest(raw, platform) {
     bundles,
     bundle: {
       file,
-      sha256: sha2563,
+      sha256: sha2564,
       ...typeof bundle.bytes === "number" ? { bytes: bundle.bytes } : {},
       ...sourceCommit ? { commit: sourceCommit } : {},
       ...version ? { version } : {},
@@ -307,14 +307,14 @@ __export(self_update_exports, {
   writeUpdateAttemptFixture: () => writeUpdateAttemptFixture,
   writeUpdateState: () => writeUpdateState
 });
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
-import { access, chmod as chmod3, lstat as lstat2, mkdir as mkdir10, open, readFile as readFile8, rename as rename3, rm as rm4, symlink as symlink2, writeFile as writeFile8 } from "node:fs/promises";
+import { access, chmod as chmod3, lstat as lstat2, mkdir as mkdir11, open, readFile as readFile9, rename as rename3, rm as rm5, symlink as symlink2, writeFile as writeFile8 } from "node:fs/promises";
 import { spawn as spawn4 } from "node:child_process";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname9, join as join6, resolve as resolve18 } from "node:path";
+import { dirname as dirname9, join as join7, resolve as resolve19 } from "node:path";
 function anchorLayout(rawLibDir) {
-  const libDir = resolve18(rawLibDir);
+  const libDir = resolve19(rawLibDir);
   const segments = libDir.split(/[/\\]/);
   const idx = segments.lastIndexOf(RELEASES_SEGMENT);
   if (idx >= 2 && segments[idx - 1] === "lib") {
@@ -330,9 +330,9 @@ function anchorLayout(rawLibDir) {
     // prefix's bin, NOT <prefix>/lib/bin — deriving it one level up was the
     // defect that made activateRelease write its stable forwarders where
     // nothing executed them, leaving stale raw wrappers in <prefix>/bin.
-    binDir: resolve18(libDir, "../../bin"),
+    binDir: resolve19(libDir, "../../bin"),
     libDir,
-    releasesRoot: resolve18(libDir, `../${RELEASES_SEGMENT}`)
+    releasesRoot: resolve19(libDir, `../${RELEASES_SEGMENT}`)
   };
 }
 function beelineInstallLayout(env = process.env) {
@@ -343,7 +343,7 @@ function beelineInstallLayout(env = process.env) {
 }
 function defaultBeelineInstallLayout(env = process.env) {
   const home = env.HOME?.trim() || homedir9();
-  return anchorLayout(resolve18(home, ".local", "lib", "beeline"));
+  return anchorLayout(resolve19(home, ".local", "lib", "beeline"));
 }
 function hostPlatformKey() {
   const os = process.platform === "linux" ? "linux" : process.platform === "darwin" ? "darwin" : "";
@@ -353,13 +353,13 @@ function hostPlatformKey() {
   return `${os}-${arch}`;
 }
 function bundleJsonCandidates(bundleDir) {
-  return [join6(bundleDir, "lib", "beeline", "bundle.json"), join6(bundleDir, "bundle.json")];
+  return [join7(bundleDir, "lib", "beeline", "bundle.json"), join7(bundleDir, "bundle.json")];
 }
 async function readBundleJson(bundleDir) {
   let raw;
   for (const candidate of bundleJsonCandidates(bundleDir)) {
     try {
-      raw = await readFile8(candidate, "utf8");
+      raw = await readFile9(candidate, "utf8");
       break;
     } catch {
     }
@@ -377,17 +377,17 @@ async function readBundleJson(bundleDir) {
   }
 }
 function updateStatePath(layout) {
-  return join6(layout.releasesRoot, ".state", "update-state.json");
+  return join7(layout.releasesRoot, ".state", "update-state.json");
 }
 async function readUpdateState(layout) {
   try {
-    return JSON.parse(await readFile8(updateStatePath(layout), "utf8"));
+    return JSON.parse(await readFile9(updateStatePath(layout), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeUpdateState(layout, state) {
-  await mkdir10(join6(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir11(join7(layout.releasesRoot, ".state"), { recursive: true });
   await writeFile8(updateStatePath(layout), `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -469,7 +469,7 @@ function run(command, args, timeoutMs) {
   });
 }
 function entrypointCandidates(bundleDir) {
-  return [join6(bundleDir, BUNDLE_ENTRYPOINT), join6(bundleDir, "beeline-cli.mjs")];
+  return [join7(bundleDir, BUNDLE_ENTRYPOINT), join7(bundleDir, "beeline-cli.mjs")];
 }
 async function resolveBundleEntrypoint(bundleDir) {
   for (const candidate of entrypointCandidates(bundleDir)) {
@@ -491,18 +491,18 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log2 = opts.logger ?? ((line) => console.log(`[body] self-update: ${line}`));
   const releaseId = sanitizeReleaseId(published.commit ?? published.version ?? `release-${Date.now()}`);
-  const releaseDir = join6(layout.releasesRoot, releaseId);
-  const okMarker = join6(releaseDir, ".stage-ok");
+  const releaseDir = join7(layout.releasesRoot, releaseId);
+  const okMarker = join7(releaseDir, ".stage-ok");
   let previouslyVerified = false;
   try {
-    const recorded = await readFile8(okMarker, "utf8");
+    const recorded = await readFile9(okMarker, "utf8");
     if (recorded.trim() === published.sha256)
       return releaseId;
     previouslyVerified = true;
   } catch {
   }
-  await mkdir10(releaseDir, { recursive: true });
-  const tempArchive = join6(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
+  await mkdir11(releaseDir, { recursive: true });
+  const tempArchive = join7(layout.releasesRoot, `.download-${releaseId}-${process.pid}.tar.gz`);
   try {
     log2(`downloading ${published.file}`);
     const response = await fetchImpl(archiveUrlFor(manifestUrl, published.file), {
@@ -511,7 +511,7 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     if (!response.ok || !response.body) {
       throw new Error(`downloading ${published.file} failed: HTTP ${response.status}`);
     }
-    const hash = createHash4("sha256");
+    const hash = createHash5("sha256");
     const chunks = [];
     for await (const chunk of response.body) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -542,13 +542,13 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
       throw new Error(`extracting bundle failed: ${extract2.stderr}`);
     for (const relative3 of requiredBundlePaths()) {
       try {
-        await access(join6(releaseDir, relative3), fsConstants.F_OK);
+        await access(join7(releaseDir, relative3), fsConstants.F_OK);
       } catch {
         throw new Error(`staged bundle is missing ${relative3}`);
       }
     }
     if (opts.smokeTestCli !== false) {
-      const probe = await run(process.execPath, [join6(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
+      const probe = await run(process.execPath, [join7(releaseDir, BUNDLE_ENTRYPOINT), "--version"], 6e4);
       if (probe.status !== 0) {
         throw new Error(`staged bundle failed its startup smoke test (--version exited ${probe.status})${probe.stderr ? `: ${probe.stderr.trim()}` : ""}`);
       }
@@ -559,10 +559,10 @@ async function stageRelease(layout, manifestUrl, published, opts = {}) {
     return releaseId;
   } catch (error) {
     if (!previouslyVerified)
-      await rm4(releaseDir, { recursive: true, force: true });
+      await rm5(releaseDir, { recursive: true, force: true });
     throw error;
   } finally {
-    await rm4(tempArchive, { force: true });
+    await rm5(tempArchive, { force: true });
   }
 }
 function forwarderScript(tool) {
@@ -586,21 +586,21 @@ async function replaceFile(path, contents, mode) {
   await rename3(temp, path);
 }
 async function activateRelease(layout, releaseId) {
-  const releaseDir = join6(layout.releasesRoot, releaseId);
-  await access(join6(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
-  await mkdir10(layout.releasesRoot, { recursive: true });
-  await mkdir10(layout.binDir, { recursive: true });
+  const releaseDir = join7(layout.releasesRoot, releaseId);
+  await access(join7(releaseDir, BUNDLE_ENTRYPOINT), fsConstants.F_OK);
+  await mkdir11(layout.releasesRoot, { recursive: true });
+  await mkdir11(layout.binDir, { recursive: true });
   let previousReleaseId = await activeReleaseId(layout);
   const kind = await pathKind(layout.libDir);
   if (kind === "directory") {
     const legacyIdentity = await readBundleJson(layout.libDir);
     const legacyId = sanitizeReleaseId(legacyIdentity?.commit ?? legacyIdentity?.version ?? `legacy-${Date.now()}`);
-    const legacyDir = join6(layout.releasesRoot, legacyId);
+    const legacyDir = join7(layout.releasesRoot, legacyId);
     try {
       await access(legacyDir, fsConstants.F_OK);
       previousReleaseId = `${legacyId}-${Date.now()}`;
-      await rename3(layout.libDir, join6(layout.releasesRoot, previousReleaseId));
-      await normalizeLegacyBundleShape(join6(layout.releasesRoot, previousReleaseId));
+      await rename3(layout.libDir, join7(layout.releasesRoot, previousReleaseId));
+      await normalizeLegacyBundleShape(join7(layout.releasesRoot, previousReleaseId));
     } catch {
       await rename3(layout.libDir, legacyDir);
       await normalizeLegacyBundleShape(legacyDir);
@@ -608,19 +608,19 @@ async function activateRelease(layout, releaseId) {
     }
   }
   const tempLink = `${layout.libDir}.new-${process.pid}`;
-  await rm4(tempLink, { force: true });
-  await symlink2(join6("beeline-releases", releaseId), tempLink);
+  await rm5(tempLink, { force: true });
+  await symlink2(join7("beeline-releases", releaseId), tempLink);
   await rename3(tempLink, layout.libDir);
   await fsyncDir(dirname9(layout.libDir));
   await writeBinForwarders(layout, releaseDir);
   return { previousReleaseId };
 }
 async function normalizeLegacyBundleShape(bundleDir) {
-  const innerLib = join6(bundleDir, "lib", "beeline");
+  const innerLib = join7(bundleDir, "lib", "beeline");
   let anyFlat = false;
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join6(bundleDir, name), fsConstants.F_OK);
+      await access(join7(bundleDir, name), fsConstants.F_OK);
       anyFlat = true;
       break;
     } catch {
@@ -628,62 +628,62 @@ async function normalizeLegacyBundleShape(bundleDir) {
   }
   if (!anyFlat)
     return;
-  await mkdir10(innerLib, { recursive: true });
+  await mkdir11(innerLib, { recursive: true });
   for (const name of LEGACY_FLAT_BUNDLE_FILES) {
     try {
-      await access(join6(innerLib, name), fsConstants.F_OK);
+      await access(join7(innerLib, name), fsConstants.F_OK);
       continue;
     } catch {
     }
-    await rename3(join6(bundleDir, name), join6(innerLib, name)).catch(() => void 0);
+    await rename3(join7(bundleDir, name), join7(innerLib, name)).catch(() => void 0);
   }
 }
 async function writeBinForwarders(layout, activeBundleRoot) {
   for (const tool of FORWARDER_TOOLS) {
-    const target = join6(activeBundleRoot, "bin", tool);
+    const target = join7(activeBundleRoot, "bin", tool);
     try {
       await access(target, fsConstants.X_OK);
     } catch {
       continue;
     }
-    await replaceFile(join6(layout.binDir, tool), forwarderScript(tool), 493);
+    await replaceFile(join7(layout.binDir, tool), forwarderScript(tool), 493);
   }
 }
 async function repairInstallForwarders(layout, opts = {}) {
   if (await pathKind(layout.libDir) !== "symlink")
     return false;
-  const forwarderPath = join6(layout.binDir, "beeline");
+  const forwarderPath = join7(layout.binDir, "beeline");
   let current;
   try {
-    current = await readFile8(forwarderPath, "utf8");
+    current = await readFile9(forwarderPath, "utf8");
   } catch {
     current = void 0;
   }
   if (current === forwarderScript("beeline"))
     return false;
-  await mkdir10(layout.binDir, { recursive: true });
+  await mkdir11(layout.binDir, { recursive: true });
   await writeBinForwarders(layout, layout.libDir);
   opts.logger?.(`[body] self-update: repaired <prefix>/bin forwarders to follow the active-bundle anchor (${layout.libDir})`);
   return true;
 }
 async function rollbackToPreviousRelease(layout, previousReleaseId) {
-  const releaseDir = join6(layout.releasesRoot, previousReleaseId);
+  const releaseDir = join7(layout.releasesRoot, previousReleaseId);
   const entrypoint = await resolveBundleEntrypoint(releaseDir);
   if (!entrypoint) {
     throw new Error(`release ${previousReleaseId} has no runnable CLI entrypoint`);
   }
   const tempLink = `${layout.libDir}.rollback-${process.pid}`;
-  await rm4(tempLink, { force: true });
-  await symlink2(join6("beeline-releases", previousReleaseId), tempLink);
+  await rm5(tempLink, { force: true });
+  await symlink2(join7("beeline-releases", previousReleaseId), tempLink);
   await rename3(tempLink, layout.libDir);
   await fsyncDir(dirname9(layout.libDir));
 }
 function updateAttemptPath(layout) {
-  return join6(layout.releasesRoot, ".state", "update-attempt.json");
+  return join7(layout.releasesRoot, ".state", "update-attempt.json");
 }
 async function readUpdateAttempt(layout) {
   try {
-    const raw = JSON.parse(await readFile8(updateAttemptPath(layout), "utf8"));
+    const raw = JSON.parse(await readFile9(updateAttemptPath(layout), "utf8"));
     if (raw.version !== 1 || typeof raw.appliedAt !== "number" || typeof raw.confirmBy !== "number" || typeof raw.releaseId !== "string" || !["pending", "confirmed", "reverted"].includes(raw.status)) {
       return void 0;
     }
@@ -693,7 +693,7 @@ async function readUpdateAttempt(layout) {
   }
 }
 async function writeUpdateAttempt(layout, record2) {
-  await mkdir10(join6(layout.releasesRoot, ".state"), { recursive: true });
+  await mkdir11(join7(layout.releasesRoot, ".state"), { recursive: true });
   const path = updateAttemptPath(layout);
   const staged = `${path}.${process.pid}.tmp`;
   await writeFile8(staged, `${JSON.stringify(record2, null, 2)}
@@ -955,8 +955,8 @@ var init_self_update = __esm({
 });
 
 // apps/body/dist/cli.js
-import { dirname as dirname15, resolve as resolve25 } from "node:path";
-import { readFile as readFile13, unlink as unlink3, writeFile as writeFile14 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve26 } from "node:path";
+import { readFile as readFile14, unlink as unlink3, writeFile as writeFile14 } from "node:fs/promises";
 import { stdin as stdin4, stdout as stdout5 } from "node:process";
 
 // node_modules/@clack/core/dist/index.mjs
@@ -3828,7 +3828,7 @@ var AcpClient = class extends EventEmitter {
     const current = this.activeRunIds.get(sessionId);
     if (current)
       return Promise.resolve(current);
-    return new Promise((resolve26, reject) => {
+    return new Promise((resolve27, reject) => {
       const onUpdate = (update) => {
         if (update.sessionId !== sessionId)
           return;
@@ -3836,7 +3836,7 @@ var AcpClient = class extends EventEmitter {
         if (!runId)
           return;
         cleanup();
-        resolve26(runId);
+        resolve27(runId);
       };
       const timer = setTimeout(() => {
         cleanup();
@@ -3920,13 +3920,13 @@ var AcpClient = class extends EventEmitter {
     }
     const id = this.nextId++;
     const payload = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve26, reject) => {
+    return new Promise((resolve27, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new AcpRequestTimeoutError(method, timeoutMs, this.stderrTail, Boolean(onStart), detail));
       }, timeoutMs);
       this.pending.set(id, {
-        resolve: resolve26,
+        resolve: resolve27,
         reject,
         timer,
         method,
@@ -13277,10 +13277,10 @@ async function activateDaemonTransport(path, fetchImpl = fetch) {
 
 // apps/body/dist/room-runtime.js
 import { execFile as execFile4 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync4, mkdirSync } from "node:fs";
-import { mkdir as mkdir8, rm as rm3 } from "node:fs/promises";
-import { dirname as dirname6, resolve as resolve16 } from "node:path";
+import { mkdir as mkdir9, rm as rm4 } from "node:fs/promises";
+import { dirname as dirname6, resolve as resolve17 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 
 // apps/body/dist/grant-runner.js
@@ -14122,17 +14122,17 @@ var GrantRunnerServer = class {
 
 // apps/body/dist/monolith-corner-turn.js
 import { execFile as execFile3 } from "node:child_process";
-import { mkdir as mkdir6 } from "node:fs/promises";
+import { mkdir as mkdir7 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 
 // apps/body/dist/agent-home.js
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { chmod as chmod2, copyFile, lstat, mkdir as mkdir4, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile5 } from "node:fs/promises";
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { chmod as chmod2, copyFile, lstat, mkdir as mkdir4, readFile as readFile6, readdir as readdir2, realpath, rename as rename2, rm as rm2, symlink, unlink, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { basename as basename3, dirname as dirname5, relative as relative2, resolve as resolve13, sep } from "node:path";
+import { basename as basename3, dirname as dirname5, join as join3, relative as relative2, resolve as resolve13, sep } from "node:path";
 
 // apps/body/dist/beeline-skill.js
 import { readFileSync as readFileSync3 } from "node:fs";
@@ -14145,7 +14145,7 @@ var BEELINE_ROOM_CAPABILITIES = [
   "Tag the user only when you need a decision or input, or when the task they asked for is finished. Never tag for progress, acknowledgement, or questions the transcript already answers.",
   "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
-  "To send a file, call beeline-agent attach_file with a path inside your checkout or your writable scratch directory (where files you generate live); it is attached to your reply.",
+  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent attach_file with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote); it is attached to your reply. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
   "To run something later or repeatedly, call beeline-agent create_schedule (interval in minutes or a 5-field cron, optional maxRuns); list_schedules / delete_schedule manage them.",
   "When repository work is needed, you MUST call beeline-agent open_corner with a name of at most three words - it titles the corner everywhere - and a complete objective of no more than 24 words. The host-governed call is the only way to start write work.",
   "When open_corner succeeds, the server posts the corner card: do not announce or restate the opening. End the turn with nothing more unless the person asked something else.",
@@ -14157,7 +14157,7 @@ var BEELINE_DM_CAPABILITIES = [
   "The repository filesystem is read-only in this session.",
   "Every MCP server mounted into this session is approved tool by tool - use operator and host tools freely; the read-only filesystem sandbox is the boundary, not a tool list. Network web search is enabled.",
   "Files and photos people share are downloaded for you: read them at the local path named in the prompt (photos may also arrive inline); never fetch the reference URL.",
-  "To send a file, call beeline-agent attach_file with a path inside your checkout or your writable scratch directory (where files you generate live); it is attached to your reply.",
+  "To create a file (this Room has no other way to write one), call beeline-agent write_scratch_file with a relative path and content - text by default, or base64 for bytes you computed; it returns a path in your writable session home. To send a file, call beeline-agent attach_file with a path inside your checkout or anywhere in your writable session home (wherever a file you or your harness generated actually landed, including one you just wrote); it is attached to your reply. write_scratch_file produces the file, not a picture - turning it into a raster image needs a converter, which needs shell, which this Room does not have.",
   "Tag the person only when you need a decision or input, or when the task they asked for is finished.",
   "Never claim an action or reply happened unless the prompt or a tool result proves it."
 ].join(" ");
@@ -14805,6 +14805,9 @@ var OPERATOR_SKILL_SOURCE_DIRS = [
   ".pi/agent/skills"
 ];
 var AGENT_SKILL_DIRS = ["claude", "codex", "grok", "pi"];
+function agentSkillDir(kind) {
+  return AGENT_SKILL_DIRS.includes(kind ?? "") ? kind : "codex";
+}
 var SHARED_SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function isSharedSkillName(value) {
   return typeof value === "string" && SHARED_SKILL_NAME_PATTERN.test(value) && !BEELINE_DEFAULT_SKILL_NAMES.includes(value);
@@ -14861,7 +14864,7 @@ async function prepareRoomAgentHome(input) {
     await symlink(source, target).catch(() => void 0);
   }
   const prior = agentHomeProvisionQueues.get(root) ?? Promise.resolve();
-  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed ?? false, input.sharedSkills ?? [], input.openRouterRouting));
+  const provision = prior.catch(() => void 0).then(() => provisionAgentSkillsAndMcp(root, operatorHome, input.skillReleaseId ?? runningBeelineReleaseId(), input.failClosed ?? false, input.sharedSkills ?? [], agentSkillDir(input.agentKind), input.openRouterRouting));
   agentHomeProvisionQueues.set(root, provision);
   try {
     await provision;
@@ -14871,15 +14874,12 @@ async function prepareRoomAgentHome(input) {
   }
   return roomAgentHomeEnv(root);
 }
-async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, openRouterRouting) {
+async function provisionAgentSkillsAndMcp(root, operatorHome, skillReleaseId, failClosed, sharedSkills, skillDir, openRouterRouting) {
   const managedSkills = [
     { name: USING_BEELINE_SKILL_NAME, content: usingBeelineSkillMarkdown(skillReleaseId) }
   ];
   const shared = await resolveSharedSkillSources(operatorHome, sharedSkills);
-  for (const dir of AGENT_SKILL_DIRS) {
-    const target = resolve13(root, dir, "skills");
-    await provisionManagedSkillsDir(target, managedSkills, shared, sharedSkills.length === 0);
-  }
+  await provisionManagedSkillsDir(resolve13(root, skillDir, "skills"), managedSkills, shared, sharedSkills.length === 0);
   for (const config of HARNESS_MCP_CONFIGS) {
     try {
       const source = resolve13(operatorHome, config.toml);
@@ -15013,26 +15013,19 @@ function filteredHarnessMcpToml(source) {
 async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, optionalShares) {
   const parent = dirname5(target);
   await assertRealContainedDirectory(parent, dirname5(parent));
+  const plan = await planManagedSkills(managedSkills, sharedSkills, optionalShares);
+  if (await materializedSkillManifest(target) === plan.manifest)
+    return;
   const staged = resolve13(parent, `.skills.${process.pid}.${randomUUID()}.tmp`);
   await mkdir4(staged, { mode: 448 });
-  const names = new Set(managedSkills.map((skill) => skill.name));
   try {
-    for (const skill of managedSkills) {
-      const skillDir = resolve13(staged, skill.name);
-      await mkdir4(skillDir, { recursive: true });
-      await writeIsolatedHarnessFile(resolve13(skillDir, "SKILL.md"), skill.content);
-    }
-    for (const shared of sharedSkills) {
-      if (names.has(shared.name)) {
-        throw new Error(`shared skill collides with Beeline-owned skill: ${shared.name}`);
-      }
-      names.add(shared.name);
-      try {
-        await copySafeSkillTree(shared.source, resolve13(staged, shared.name), shared.source);
-      } catch (error) {
-        if (!optionalShares)
-          throw error;
-        console.warn(`[body] skipping shared skill ${shared.name}:`, error);
+    for (const entry of plan.entries) {
+      if (entry.kind === "managed") {
+        const skillDir = resolve13(staged, entry.name);
+        await mkdir4(skillDir, { recursive: true });
+        await writeIsolatedHarnessFile(resolve13(skillDir, "SKILL.md"), entry.content);
+      } else {
+        await copySafeSkillTree(entry.source, resolve13(staged, entry.name), entry.source);
       }
     }
     const existing = await lstat(target).catch(() => void 0);
@@ -15043,6 +15036,70 @@ async function provisionManagedSkillsDir(target, managedSkills, sharedSkills, op
     await rm2(staged, { recursive: true, force: true });
   }
 }
+async function planManagedSkills(managedSkills, sharedSkills, optionalShares) {
+  const entries = [];
+  const lines = [];
+  const names = new Set(managedSkills.map((skill) => skill.name));
+  for (const skill of managedSkills) {
+    entries.push({ kind: "managed", name: skill.name, content: skill.content });
+    lines.push(`d ${skill.name}`, `f ${skill.name}/SKILL.md ${sha2563(skill.content)}`);
+  }
+  for (const shared of sharedSkills) {
+    if (names.has(shared.name)) {
+      throw new Error(`shared skill collides with Beeline-owned skill: ${shared.name}`);
+    }
+    names.add(shared.name);
+    try {
+      const tree = [];
+      await walkSafeSkillTree(shared.source, shared.source, {
+        directory: async (rel) => void tree.push(`d ${join3(shared.name, rel)}`),
+        file: async (rel, realPath) => void tree.push(`f ${join3(shared.name, rel)} ${sha2563(await readFile6(realPath))}`)
+      });
+      entries.push({ kind: "shared", name: shared.name, source: shared.source });
+      lines.push(...tree);
+    } catch (error) {
+      if (!optionalShares)
+        throw error;
+      console.warn(`[body] skipping shared skill ${shared.name}:`, error);
+    }
+  }
+  return { entries, manifest: lines.sort().join("\n") };
+}
+async function materializedSkillManifest(target) {
+  const stats = await lstat(target).catch(() => void 0);
+  if (!stats?.isDirectory() || stats.isSymbolicLink())
+    return void 0;
+  const lines = [];
+  const visit = async (directory, prefix) => {
+    for (const entry of await readdir2(directory)) {
+      const path = resolve13(directory, entry);
+      const rel = prefix ? join3(prefix, entry) : entry;
+      const entryStats = await lstat(path);
+      if (entryStats.isSymbolicLink())
+        return false;
+      if (entryStats.isDirectory()) {
+        lines.push(`d ${rel}`);
+        if (!await visit(path, rel))
+          return false;
+        continue;
+      }
+      if (!entryStats.isFile() || entryStats.nlink !== 1)
+        return false;
+      lines.push(`f ${rel} ${sha2563(await readFile6(path))}`);
+    }
+    return true;
+  };
+  try {
+    if (!await visit(target, ""))
+      return void 0;
+  } catch {
+    return void 0;
+  }
+  return lines.sort().join("\n");
+}
+function sha2563(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
 async function resolveSharedSkillSources(operatorHome, names) {
   if (names.length > 0)
     return resolveExplicitSkillSources(operatorHome, names);
@@ -15127,7 +15184,7 @@ async function assertRealContainedDirectory(path, root) {
   }
 }
 var BLOCKED_SHARED_FILENAMES = /^(?:\.env(?:\..*)?|auth\.json|\.credentials\.json|config\.toml|settings(?:\.local)?\.json|\.mcp\.json|credentials?|secrets?|plugins?|\.codex-plugin|\.claude-plugin|memory(?:\.md)?|\.netrc|\.git-credentials|.*\.(?:pem|key))$/i;
-async function copySafeSkillTree(source, target, sourceRoot) {
+async function walkSafeSkillTree(source, sourceRoot, visitor, rel = "") {
   assertContained(sourceRoot, source);
   const resolvedSource = await realpath(source);
   if (resolvedSource !== resolve13(source)) {
@@ -15141,19 +15198,30 @@ async function copySafeSkillTree(source, target, sourceRoot) {
     throw new Error(`shared skill contains credential or configuration material: ${source}`);
   }
   if (stats.isDirectory()) {
-    await mkdir4(target, { mode: 448 });
+    await visitor.directory(rel);
     for (const entry of await readdir2(resolvedSource)) {
       if (entry === "." || entry === "..")
         throw new Error("invalid shared skill entry");
-      await copySafeSkillTree(resolve13(source, entry), resolve13(target, entry), sourceRoot);
+      await walkSafeSkillTree(resolve13(source, entry), sourceRoot, visitor, rel ? join3(rel, entry) : entry);
     }
     return;
   }
   if (!stats.isFile() || stats.nlink !== 1) {
     throw new Error(`shared skill contains a nonordinary file: ${source}`);
   }
-  await copyFile(resolvedSource, target);
-  await chmod2(target, 384);
+  await visitor.file(rel, resolvedSource);
+}
+async function copySafeSkillTree(source, target, sourceRoot) {
+  await walkSafeSkillTree(source, sourceRoot, {
+    directory: async (rel) => {
+      await mkdir4(resolve13(target, rel), { mode: 448 });
+    },
+    file: async (rel, realPath) => {
+      const destination = resolve13(target, rel);
+      await copyFile(realPath, destination);
+      await chmod2(destination, 384);
+    }
+  });
 }
 async function writeIsolatedHarnessFile(path, content) {
   const parent = dirname5(path);
@@ -15207,7 +15275,7 @@ function harnessStateDirsFromEnv(env) {
 
 // apps/body/dist/attachment-delivery.js
 import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename4, extname, join as join3 } from "node:path";
+import { basename as basename4, extname, join as join4 } from "node:path";
 var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
 var FETCH_TIMEOUT_MS = 3e4;
 var MAX_INLINE_IMAGE_BYTES = 5 * 1024 * 1024;
@@ -15245,7 +15313,7 @@ async function deliverAttachments(attachments, dir, fetchImpl = fetch) {
       const bytes = Buffer.from(await response.arrayBuffer());
       if (bytes.length > MAX_ATTACHMENT_BYTES)
         return tooLarge(bytes.length);
-      const path = join3(dir, safeFileName(attachment, index, taken));
+      const path = join4(dir, safeFileName(attachment, index, taken));
       await writeFile6(path, bytes);
       const mimeType = attachment.mimeType ?? response.headers.get("content-type") ?? "";
       if (!mimeType.startsWith("image/"))
@@ -15428,6 +15496,109 @@ function isCornerStatusRestatement(reply, systemLines) {
   return statusWords(text2).every((word) => !word || admitted.has(word));
 }
 
+// apps/body/dist/turn-stream.js
+function durableReplyText(agentText) {
+  return sanitizeAgentReply(agentText);
+}
+var AgentTurnStream = class {
+  options;
+  latest = "";
+  /**
+   * The newest snapshot not yet handed to a write. A draft is a picture of the
+   * whole answer so far, so an older snapshot that never reached the wire is
+   * not a lost message — it is a frame nobody needed. Keeping only the newest
+   * one bounds the lane at ONE write in flight plus ONE waiting.
+   */
+  pending;
+  /** The draft write on the wire, if any. Never rejects; failures are logged. */
+  inFlight;
+  /** Closed lanes publish nothing more, so the answer never queues behind a draft. */
+  closed = false;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * The ACP delta hook: hand it straight to `sessionPrompt`. `full` is every
+   * assistant run so far joined — not the final answer — so it is only ever
+   * shown provisionally.
+   */
+  onChunk = (_delta, full) => {
+    this.latest = full;
+    const text2 = sanitizeAgentReply(full);
+    if (!text2 || this.closed)
+      return;
+    this.pending = text2;
+    this.publishPending();
+  };
+  /**
+   * Hand the newest snapshot to the wire, one write at a time.
+   *
+   * Serialized, never parallel: two drafts in flight can land out of order and
+   * a reader would watch the answer go backwards. Serialized used to mean an
+   * unbounded chain — every delta got its own write, and the durable reply
+   * awaited the whole tail, so a finished answer sat behind writes showing text
+   * nobody would ever read. It waits for at most one write now, and only to
+   * keep the retract last.
+   */
+  publishPending() {
+    if (this.inFlight || this.pending === void 0)
+      return;
+    const text2 = this.pending;
+    this.pending = void 0;
+    const { api, agentId, roomId, requestId, label } = this.options;
+    this.inFlight = api.execute("postAgentDraft", { agentId, roomId, turnId: requestId, text: text2 }).then(() => void 0).catch((error) => console.error(`[thin-core] ${label} draft publish failed:`, error)).then(() => {
+      this.inFlight = void 0;
+      this.publishPending();
+    });
+  }
+  /**
+   * Everything the delta hook has seen this turn: every assistant run joined,
+   * which is a LONGER string than `PromptResult.agentText` whenever the turn
+   * spoke before a tool call. Nothing durable is derived from it.
+   */
+  get streamedText() {
+    return this.latest;
+  }
+  /** Forget the previous run's stream text; a re-pinned retry starts clean. */
+  beginRun() {
+    this.latest = "";
+    this.pending = void 0;
+  }
+  /**
+   * Stop drafting. The answer is known from here on, so anything still waiting
+   * is obsolete and is dropped rather than published ahead of the final.
+   */
+  close() {
+    this.closed = true;
+    this.pending = void 0;
+  }
+  /**
+   * Post the durable reply under the turn's request id and dissolve the draft.
+   * An empty reply settles through the turn receipt instead, and the lane is
+   * retracted either way.
+   */
+  async settle(reply, fields = {}) {
+    this.close();
+    const { api, agentId, roomId, requestId } = this.options;
+    if (reply) {
+      await api.execute("postRoomMessage", {
+        roomId,
+        requestId,
+        text: reply,
+        presentation: "message",
+        ...fields
+      });
+    }
+    await this.inFlight;
+    await api.execute("retractAgentLiveOutput", {
+      agentId,
+      roomId,
+      turnId: requestId,
+      kind: "draft"
+    });
+  }
+};
+
 // apps/body/dist/turn-failure-reason.js
 var TURN_FAILURE_REASON_MAX = 200;
 function redactToolDetail(value) {
@@ -15482,6 +15653,17 @@ function toolCallFailureLine(call) {
   return detail ? `${title} refused: ${detail}` : `${title} refused with no reason given`;
 }
 
+// apps/body/dist/session-config-fingerprint.js
+function sessionConfigFingerprint(input) {
+  return JSON.stringify([
+    input.model ?? "",
+    input.effort ?? "",
+    input.soul?.name ?? "",
+    input.soul?.instructions ?? "",
+    input.agentName ?? ""
+  ]);
+}
+
 // apps/body/dist/room-session.js
 import { resolve as resolve14 } from "node:path";
 
@@ -15524,6 +15706,62 @@ function shellPayload(toolCall) {
   const record2 = rawInput;
   return typeof record2.command === "string" || typeof record2.cmd === "string";
 }
+var ROOM_MOUNTED_MCP_SERVERS = [
+  READ_ONLY_MCP_SERVER_NAME,
+  BEELINE_AGENT_MCP_SERVER_NAME
+];
+var DISPATCHER_TOOL_NAME_KEYS = ["tool_name", "toolName"];
+var DISPATCHER_TOOL_INPUT_KEYS = ["tool_input", "toolInput"];
+var TOOL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+function permissionRecord(rawInput) {
+  return rawInput && typeof rawInput === "object" && !Array.isArray(rawInput) ? rawInput : void 0;
+}
+function dispatchedPayloadIsShell(record2) {
+  if (!record2)
+    return false;
+  return DISPATCHER_TOOL_INPUT_KEYS.some((key) => key in record2 && shellPayload({ rawInput: record2[key] }));
+}
+function toolIdentityCandidates(toolCall) {
+  const candidates = [];
+  const add = (value) => {
+    if (typeof value === "string" && value.trim())
+      candidates.push(value.trim());
+  };
+  add(toolCall?.title);
+  const record2 = permissionRecord(toolCall?.rawInput);
+  for (const key of DISPATCHER_TOOL_NAME_KEYS)
+    add(record2?.[key]);
+  return candidates;
+}
+function normalizedServerName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+}
+function resolveMountedMcpToolCall(request, mountedServers) {
+  const toolCall = request.toolCall;
+  if (shellPayload(toolCall))
+    return void 0;
+  const record2 = permissionRecord(toolCall?.rawInput);
+  if (dispatchedPayloadIsShell(record2))
+    return void 0;
+  const candidates = toolIdentityCandidates(toolCall);
+  for (const server of mountedServers) {
+    const spellings = /* @__PURE__ */ new Set([server.toLowerCase(), normalizedServerName(server)]);
+    for (const candidate of candidates) {
+      const lowered = candidate.toLowerCase();
+      for (const spelling of spellings) {
+        for (const separator of TOOL_NAME_SEPARATORS) {
+          const prefix = `${spelling}${separator}`;
+          if (!lowered.startsWith(prefix))
+            continue;
+          const tool = candidate.slice(prefix.length).trim();
+          if (TOOL_NAME_PATTERN.test(tool))
+            return { server, tool };
+        }
+      }
+    }
+  }
+  return void 0;
+}
 function isReadOnlyMcpPermissionRequest(request) {
   const toolCall = request.toolCall;
   const title = toolCall?.title?.trim() ?? "";
@@ -15545,9 +15783,11 @@ function isReadOnlyMcpPermissionRequest(request) {
   }
   return false;
 }
-function isMountedMcpToolPermissionRequest(request) {
+function isMountedMcpToolPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
   const toolCall = request.toolCall;
   const rawInput = toolCall?.rawInput;
+  if (dispatchedPayloadIsShell(permissionRecord(rawInput)))
+    return false;
   if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
     const call = rawInput;
     if (typeof call.server === "string" && typeof call.tool === "string")
@@ -15560,18 +15800,32 @@ function isMountedMcpToolPermissionRequest(request) {
     return true;
   if (/^mcp\.[^.]+\.[^.]/.test(title))
     return true;
+  if (resolveMountedMcpToolCall(request, mountedServers))
+    return true;
   return isReadOnlyMcpPermissionRequest(request) || isBeelineAgentMcpPermissionRequest(request);
 }
-var AGENT_SURFACE_TOOL_NAMES = ["open_corner", "pr_checks_status", "attach_file"];
-var SQUIRE_TITLE_PREFIXES = ["mcp__squire__", "mcp.squire.", "squire.", "squire/"];
+var AGENT_SURFACE_TOOL_NAMES = [
+  "open_corner",
+  "pr_checks_status",
+  "attach_file",
+  "write_scratch_file"
+];
+var SQUIRE_TITLE_PREFIXES = [
+  "mcp__squire__",
+  "mcp.squire.",
+  "squire.",
+  "squire/",
+  // grok's qualified `<server>__<tool>` spelling, inside `use_tool` or as the
+  // relabelled title.
+  "squire__"
+];
 function isSquireMcpPermissionRequest(request) {
   const rawInput = request.toolCall?.rawInput;
   if (rawInput && typeof rawInput === "object" && !Array.isArray(rawInput)) {
     if (rawInput.server === "squire")
       return true;
   }
-  const title = request.toolCall?.title?.trim() ?? "";
-  return SQUIRE_TITLE_PREFIXES.some((prefix) => title.startsWith(prefix));
+  return toolIdentityCandidates(request.toolCall).some((candidate) => SQUIRE_TITLE_PREFIXES.some((prefix) => candidate.toLowerCase().startsWith(prefix)));
 }
 function isBeelineAgentMcpPermissionRequest(request) {
   const toolCall = request.toolCall;
@@ -15628,7 +15882,7 @@ function readOnlyMcpServer(config, cwd, agentMemoryDir) {
   if (!config.readonlyMcpCommand) {
     throw new ReadOnlyToolsUnavailableError("read-only tools unavailable: beeline-readonly-mcp is required for Room sessions");
   }
-  const skillDir = config.agentKind === "claude" || config.agentKind === "codex" || config.agentKind === "grok" || config.agentKind === "pi" ? config.agentKind : "codex";
+  const skillDir = agentSkillDir(config.agentKind);
   return {
     name: READ_ONLY_MCP_SERVER_NAME,
     command: config.readonlyMcpCommand,
@@ -15647,7 +15901,7 @@ function readOnlyMcpServer(config, cwd, agentMemoryDir) {
 }
 
 // apps/body/dist/pi-turn-record.js
-import { readdir as readdir3, readFile as readFile6 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile7 } from "node:fs/promises";
 import { resolve as resolve15 } from "node:path";
 function summarizeProviderError(errorMessage2) {
   const trimmed = errorMessage2.trim();
@@ -15669,7 +15923,7 @@ function summarizeProviderError(errorMessage2) {
 }
 async function sessionFileFromMap(home, sessionId) {
   try {
-    const raw = await readFile6(resolve15(home, ".pi", "pi-acp", "session-map.json"), "utf8");
+    const raw = await readFile7(resolve15(home, ".pi", "pi-acp", "session-map.json"), "utf8");
     const map = JSON.parse(raw);
     const file = map.sessions?.[sessionId]?.sessionFile;
     return typeof file === "string" && file ? file : void 0;
@@ -15714,7 +15968,7 @@ async function readPiTurnRecord(input) {
     return void 0;
   let raw;
   try {
-    raw = await readFile6(file, "utf8");
+    raw = await readFile7(file, "utf8");
   } catch {
     return void 0;
   }
@@ -15837,6 +16091,38 @@ function checksStateFromLifecycle(lifecycle) {
 var MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE = "Maintain your assigned identity and soul in every response, including when tools or permissions block the requested action.";
 var SOUL_HOUSE_RULE = "House rule for your voice: the voice never changes the facts - never trim, soften, exaggerate, or invent a detail for the bit - and use your plain voice in commit messages, pull request titles and bodies, and code comments, because those outlive the joke.";
 
+// apps/body/dist/warm-transcript.js
+var WARM_TRANSCRIPT_OVERLAP = 8;
+var WarmTranscript = class {
+  sessionId;
+  delivered = /* @__PURE__ */ new Set();
+  /**
+   * The rows this prompt should render. A row counts as delivered once it has
+   * been handed to a session: a prompt that times out was still received by the
+   * harness, and a prompt that could not be handed over at all takes the
+   * session down with it, which resets the memory on the next activation.
+   */
+  select(sessionId, rows) {
+    if (!sessionId || sessionId !== this.sessionId) {
+      this.sessionId = sessionId;
+      this.delivered.clear();
+    }
+    const overlapFrom = Math.max(0, rows.length - WARM_TRANSCRIPT_OVERLAP);
+    const selected = rows.filter((row, index) => index >= overlapFrom || !this.delivered.has(row.id));
+    for (const row of rows)
+      this.delivered.add(row.id);
+    return { rows: selected, elided: rows.length - selected.length };
+  }
+  /** Render a selection, and say plainly when it is only what is new. */
+  static render(selection, whole, sinceLastTurn) {
+    const transcript = selection.rows.map((row) => row.line).join("\n");
+    if (!transcript)
+      return "";
+    return `${selection.elided ? sinceLastTurn : whole}
+${transcript}`;
+  }
+};
+
 // apps/body/dist/turn-receipt-heartbeat.js
 var TURN_RECEIPT_HEARTBEAT_MS = 3e4;
 async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
@@ -15858,6 +16144,283 @@ async function withTurnReceiptHeartbeat(api, receipt, task, onHeartbeatError) {
   }
 }
 
+// apps/body/dist/turn-trace.js
+import { appendFile, mkdir as mkdir6, readdir as readdir4, rm as rm3 } from "node:fs/promises";
+import { resolve as resolve16 } from "node:path";
+import { performance as performance2 } from "node:perf_hooks";
+var TURN_PHASES = [
+  /** Enqueued on `SessionScheduler` until this turn holds a slot. A capacity wait lives here. */
+  "queue-wait",
+  /**
+   * The work that buys a usable session: on a cold turn `lifecycle.activate()`
+   * — the ACP spawn and `session/new` — and on a warm one only the check that
+   * the retained process still matches the agent's configuration (C104).
+   */
+  "activation",
+  /** Room conversation, Workspace roster and attachment downloads, before the prompt. */
+  "context-fetch",
+  /** `session/prompt` sent until the first assistant text chunk arrives. */
+  "first-model-output",
+  /** First chunk until the prompt resolves: the rest of the model's answer, tools included. */
+  "model-stream",
+  /** Union of the intervals with at least one tool call outstanding. Nested in the model phases. */
+  "tool-work",
+  /** The durable reply write that settles the turn. */
+  "publish"
+];
+function toolCallOutstanding(call) {
+  return !/^(?:completed|complete|failed|error|succeeded|success|passed|done|rejected|denied|cancelled|canceled)$/i.test(call.status ?? "");
+}
+var TurnTrace = class {
+  options;
+  now;
+  startedAtWall = (/* @__PURE__ */ new Date()).toISOString();
+  begunAt;
+  attempts = [];
+  open = /* @__PURE__ */ new Map();
+  atQueue;
+  atAdmission;
+  finished = false;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? (() => performance2.now());
+    this.begunAt = this.now();
+    this.attempts.push(this.newAttempt(1));
+  }
+  newAttempt(attempt) {
+    return {
+      attempt,
+      activation: "warm",
+      capacityWait: false,
+      phases: /* @__PURE__ */ new Map(),
+      toolCallIds: /* @__PURE__ */ new Set()
+    };
+  }
+  get current() {
+    return this.attempts[this.attempts.length - 1];
+  }
+  add(phase, ms) {
+    const attempt = this.current;
+    attempt.phases.set(phase, (attempt.phases.get(phase) ?? 0) + Math.max(0, ms));
+  }
+  /** Open a phase. A phase already open keeps its original start. */
+  start(phase) {
+    if (!this.open.has(phase))
+      this.open.set(phase, this.now());
+  }
+  /** Close a phase and accumulate it on the current attempt. A no-op when it never opened. */
+  end(phase) {
+    const openedAt = this.open.get(phase);
+    if (openedAt === void 0)
+      return;
+    this.open.delete(phase);
+    this.add(phase, this.now() - openedAt);
+  }
+  /** Time `run` as one phase, whether it resolves or throws. */
+  async measure(phase, run2) {
+    this.start(phase);
+    try {
+      return await run2();
+    } finally {
+      this.end(phase);
+    }
+  }
+  noteScheduler(where, snapshot) {
+    if (where === "queue")
+      this.atQueue = snapshot;
+    else
+      this.atAdmission = snapshot;
+  }
+  /** The scheduler told this turn it was waiting for a slot: the wait is capacity, not the model. */
+  noteCapacityWait() {
+    this.current.capacityWait = true;
+  }
+  noteActivation(kind) {
+    this.current.activation = kind;
+  }
+  /** The prompt left for the harness. Idempotent: a steer resume is the same attempt. */
+  promptSent() {
+    this.current.promptSentAt ??= this.now();
+  }
+  /** The first assistant text chunk of this attempt landed. */
+  firstModelOutput() {
+    const attempt = this.current;
+    if (attempt.firstOutputAt !== void 0 || attempt.promptSentAt === void 0)
+      return;
+    attempt.firstOutputAt = this.now();
+    attempt.phases.set("first-model-output", attempt.firstOutputAt - attempt.promptSentAt);
+  }
+  /**
+   * The harness's tool-call snapshot for this attempt. `tool-work` is the
+   * union of the intervals with at least one call outstanding — never a sum of
+   * per-call times, which would double-count parallel calls. A harness that
+   * never marks a call terminal therefore reads as "tools outstanding to the
+   * end of the turn", which is exactly what happened.
+   */
+  toolCalls(calls) {
+    const attempt = this.current;
+    calls.forEach((call, index) => attempt.toolCallIds.add(call.id ?? `#${index}`));
+    const outstanding = calls.some((call) => toolCallOutstanding(call));
+    if (outstanding && attempt.toolWorkOpenedAt === void 0) {
+      attempt.toolWorkOpenedAt = this.now();
+    } else if (!outstanding && attempt.toolWorkOpenedAt !== void 0) {
+      this.add("tool-work", this.now() - attempt.toolWorkOpenedAt);
+      attempt.toolWorkOpenedAt = void 0;
+    }
+  }
+  /** The prompt resolved (or gave up). Closes this attempt's model and tool windows. */
+  promptSettled() {
+    const attempt = this.current;
+    if (attempt.settled)
+      return;
+    attempt.settled = true;
+    const settledAt = this.now();
+    if (attempt.toolWorkOpenedAt !== void 0) {
+      this.add("tool-work", settledAt - attempt.toolWorkOpenedAt);
+      attempt.toolWorkOpenedAt = void 0;
+    }
+    if (attempt.firstOutputAt !== void 0) {
+      attempt.phases.set("model-stream", settledAt - attempt.firstOutputAt);
+    } else if (attempt.promptSentAt !== void 0) {
+      attempt.phases.set("first-model-output", settledAt - attempt.promptSentAt);
+    }
+  }
+  /**
+   * Open the attempt a provider re-pin buys. Everything after this call —
+   * including the re-pin's own `activate()` — belongs to the new attempt, so
+   * the retry reads as its own timeline rather than as slow first-token time.
+   */
+  retry(input = {}) {
+    const next = this.newAttempt(this.current.attempt + 1);
+    next.activation = "cold";
+    if (input.provider)
+      next.provider = input.provider;
+    if (input.reason)
+      next.retryReason = input.reason;
+    this.attempts.push(next);
+  }
+  /** The record as it stands, without writing it. */
+  snapshot(outcome, reason) {
+    return {
+      version: 1,
+      surface: this.options.surface,
+      agentId: this.options.agentId,
+      roomId: this.options.roomId,
+      requestId: this.options.requestId,
+      startedAt: this.startedAtWall,
+      outcome,
+      ...reason ? { reason } : {},
+      totalMs: round(this.now() - this.begunAt),
+      attempts: this.attempts.map((attempt) => ({
+        attemptId: `${this.options.requestId}#${attempt.attempt}`,
+        attempt: attempt.attempt,
+        activation: attempt.activation,
+        ...attempt.capacityWait ? { capacityWait: true } : {},
+        ...attempt.provider ? { provider: attempt.provider } : {},
+        ...attempt.retryReason ? { retryReason: attempt.retryReason } : {},
+        phases: Object.fromEntries(TURN_PHASES.filter((phase) => attempt.phases.has(phase)).map((phase) => [
+          phase,
+          round(attempt.phases.get(phase))
+        ])),
+        toolCalls: attempt.toolCallIds.size
+      })),
+      scheduler: {
+        ...this.atQueue ? { atQueue: this.atQueue } : {},
+        ...this.atAdmission ? { atAdmission: this.atAdmission } : {}
+      }
+    };
+  }
+  /**
+   * Close every open phase and hand the record to the sink. Called once, after
+   * the turn's receipt, so it never delays an answer; failures are swallowed,
+   * because losing a diagnostic must never fail a turn.
+   */
+  async finish(outcome, reason) {
+    if (!this.finished) {
+      this.finished = true;
+      for (const phase of [...this.open.keys()])
+        this.end(phase);
+      this.promptSettled();
+    }
+    const record2 = this.snapshot(outcome, reason);
+    await this.options.sink?.write(record2).catch((error) => {
+      console.error("[thin-core] turn trace write failed:", error);
+    });
+    return record2;
+  }
+};
+function round(ms) {
+  return Math.round(ms * 10) / 10;
+}
+function formatDuration(ms) {
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(2)}s` : `${Math.round(ms)}ms`;
+}
+function formatTurnAttempt(attempt) {
+  const parts = [`attempt ${attempt.attempt} ${attempt.activation}`];
+  if (attempt.capacityWait)
+    parts.push("capacity-wait");
+  if (attempt.provider)
+    parts.push(`provider ${attempt.provider}`);
+  for (const phase of TURN_PHASES) {
+    const value = attempt.phases[phase];
+    if (value === void 0)
+      continue;
+    parts.push(phase === "tool-work" ? `tool-work ${formatDuration(value)} (within model time)` : `${phase} ${formatDuration(value)}`);
+  }
+  if (attempt.toolCalls)
+    parts.push(`${attempt.toolCalls} tool call${attempt.toolCalls === 1 ? "" : "s"}`);
+  return parts.join(" \xB7 ");
+}
+function formatTurnTraceLine(record2) {
+  const head = `${record2.surface} ${record2.roomId} turn ${record2.requestId} ${record2.outcome} ${formatDuration(record2.totalMs)}`;
+  return [head, ...record2.attempts.map((attempt) => formatTurnAttempt(attempt))].join("\n  ");
+}
+function turnTraceDirectory(runtimeDir) {
+  return resolve16(runtimeDir, "turn-traces");
+}
+var TURN_TRACE_RETENTION_DAYS = 7;
+function traceFileName(date) {
+  return `turns-${date.toISOString().slice(0, 10)}.jsonl`;
+}
+var TurnTraceFile = class {
+  directory;
+  options;
+  tail = Promise.resolve();
+  announced = false;
+  prunedDay;
+  constructor(directory, options = {}) {
+    this.directory = directory;
+    this.options = options;
+  }
+  path(now2 = (this.options.clock ?? (() => /* @__PURE__ */ new Date()))()) {
+    return resolve16(this.directory, traceFileName(now2));
+  }
+  write(record2) {
+    this.tail = this.tail.catch(() => void 0).then(async () => {
+      const now2 = (this.options.clock ?? (() => /* @__PURE__ */ new Date()))();
+      const path = this.path(now2);
+      await mkdir6(this.directory, { recursive: true, mode: 448 });
+      await appendFile(path, `${JSON.stringify(record2)}
+`, { mode: 384 });
+      await this.prune(now2);
+      const log2 = this.options.log ?? ((line) => console.log(line));
+      log2(`[thin-core] turn trace ${formatTurnTraceLine(record2)}${this.announced ? "" : `
+  recorded in ${path}`}`);
+      this.announced = true;
+    });
+    return this.tail;
+  }
+  async prune(now2) {
+    const day = now2.toISOString().slice(0, 10);
+    if (this.prunedDay === day)
+      return;
+    this.prunedDay = day;
+    const cutoff = traceFileName(new Date(now2.getTime() - TURN_TRACE_RETENTION_DAYS * 864e5));
+    const names = await readdir4(this.directory).catch(() => []);
+    await Promise.all(names.filter((name) => /^turns-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name < cutoff).map((name) => rm3(resolve16(this.directory, name), { force: true })));
+  }
+};
+
 // apps/body/dist/monolith-corner-turn.js
 var execFileAsync2 = promisify2(execFile3);
 var TOOL_ARGUMENT_MAX_BYTES = 1200;
@@ -15994,6 +16557,10 @@ var MonolithCornerTurnLoop = class {
   agent;
   client;
   sessionId;
+  /** The configuration the live session baked in; a change invalidates it. */
+  sessionFingerprint;
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
@@ -16005,7 +16572,6 @@ var MonolithCornerTurnLoop = class {
   turnIdentityInstructions = "";
   busy = false;
   forcedStop = false;
-  draftTail = Promise.resolve();
   activityTail = Promise.resolve();
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
   attachmentDir;
@@ -16013,6 +16579,8 @@ var MonolithCornerTurnLoop = class {
   sessionScratchDir;
   /** The turn in flight and who asked for it, for ledger rows and the grant runner. */
   currentTurn;
+  /** Operator-local turn traces; built once when the daemon configured a directory. */
+  turnTraceSink;
   memberNames = /* @__PURE__ */ new Map();
   /** The last server check state that started a turn; the same state never starts another. */
   lastChecksState;
@@ -16057,9 +16625,44 @@ var MonolithCornerTurnLoop = class {
     this.memberNames = new Map(roster.members.map((member) => [member.identityId, member.name]));
     return roster;
   }
-  async activate() {
+  /**
+   * Drop this corner's live harness process. The next activation starts cold.
+   * A rotation is a fact about one live session, so the pin goes with it.
+   */
+  async discardSession() {
+    const client = this.client;
+    this.client = void 0;
+    this.sessionId = void 0;
+    this.sessionFingerprint = void 0;
+    this.pinnedProviderOverride = void 0;
+    if (client?.isAlive)
+      await client.stop();
+  }
+  /** See `MonolithRoomTurnLoop.sessionIsCurrent`: retention never keeps a
+   *  session whose persona or model pin the operator has since changed. */
+  async sessionIsCurrent() {
+    return await this.currentSessionFingerprint() === this.sessionFingerprint;
+  }
+  async currentSessionFingerprint() {
+    const [configuration, roster] = await Promise.all([
+      this.options.api.execute("getAgentConfiguration", {
+        agentId: this.agent.publicKey,
+        roomId: this.options.cornerId
+      }),
+      this.roster()
+    ]);
+    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
+    return sessionConfigFingerprint({
+      model: configuration.model ?? this.options.config.modelSelection?.model,
+      effort: configuration.effort ?? this.options.config.modelSelection?.effort,
+      soul: configuration.soul ?? self?.soul,
+      agentName: self?.name ?? this.agent.name
+    });
+  }
+  async activate(trace) {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
+    trace?.noteActivation("cold");
     const [configuration, roster] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
@@ -16067,11 +16670,19 @@ var MonolithCornerTurnLoop = class {
       }),
       this.roster()
     ]);
-    await mkdir6(this.options.worktreePath, { recursive: true });
+    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
+    const fingerprint = sessionConfigFingerprint({
+      model: configuration.model ?? this.options.config.modelSelection?.model,
+      effort: configuration.effort ?? this.options.config.modelSelection?.effort,
+      soul: configuration.soul ?? self?.soul,
+      agentName: self?.name ?? this.agent.name
+    });
+    await mkdir7(this.options.worktreePath, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
       sharedSkills: this.options.config.sharedSkills ?? [],
+      ...this.options.config.agentKind ? { agentKind: this.options.config.agentKind } : {},
       ...this.options.config.operatorHome ? { operatorHome: this.options.config.operatorHome } : {},
       ...openRouterRoutingInput(this.options.config, selection, this.options.fetchImpl, {
         ...this.pinnedProviderOverride ? { providerOverride: this.pinnedProviderOverride } : {},
@@ -16097,10 +16708,10 @@ var MonolithCornerTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir6();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join4(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join5(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir6(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir7(dir, { recursive: true })));
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
@@ -16147,11 +16758,12 @@ var MonolithCornerTurnLoop = class {
         workspaceId: this.options.workspaceId,
         cornerId: this.options.cornerId,
         attachRoot: this.options.worktreePath,
-        ...tmpDir ? { attachScratchRoot: tmpDir } : {},
+        // The whole per-session overlay, not an enumerated subset: see
+        // `monolith-room-turn.ts`'s matching comment.
+        attachScratchRoot: this.options.config.agentHomeRoot ?? tmpDir,
         ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
       })
     ];
-    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const persona = configuration.soul ?? self?.soul;
     const identityInstructions = `Your Beeline identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
@@ -16179,23 +16791,30 @@ var MonolithCornerTurnLoop = class {
       ].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
+    this.sessionFingerprint = fingerprint;
     if (selection) {
       const options = filterAllowedModelConfigOptions(parseAdvertisedConfigOptions(opened.raw, selection.model));
       await applyAgentModelSelection(this.client, opened.sessionId, options, selection);
     }
     return opened.sessionId;
   }
-  lifecycle() {
+  /** The scheduler seam: `queue-wait` closes when a slot buys a session. */
+  lifecycle(trace) {
     return {
-      activate: () => this.activate(),
-      suspend: async () => {
-        const client = this.client;
-        this.client = void 0;
-        this.sessionId = void 0;
-        this.pinnedProviderOverride = void 0;
-        if (client?.isAlive)
-          await client.stop();
-      }
+      activate: async () => {
+        trace?.end("queue-wait");
+        return trace ? trace.measure("activation", () => this.activate(trace)) : this.activate();
+      },
+      isCurrent: () => {
+        trace?.end("queue-wait");
+        const check = () => this.sessionIsCurrent();
+        return trace ? trace.measure("activation", check) : check();
+      },
+      onStateChange: (state) => {
+        if (state === "waiting-for-slot")
+          trace?.noteCapacityWait();
+      },
+      suspend: () => this.discardSession()
     };
   }
   /** A picture reaches the model only if the harness AND the model take one (C87). */
@@ -16210,7 +16829,7 @@ var MonolithCornerTurnLoop = class {
   }
   /** Why a turn carried no answer text, or undefined when it did. */
   async explainEmpty(result) {
-    if (stripAgentReplyPreamble(result.agentText).trim())
+    if (durableReplyText(result.agentText))
       return void 0;
     return explainEmptyAgentTurn({
       agentLabel: this.options.config.agentCommand ?? this.options.config.agentBinary,
@@ -16224,19 +16843,34 @@ var MonolithCornerTurnLoop = class {
    * fresh session on it, so the retry of an empty completion is served — and
    * named — by exactly one provider (C92).
    */
-  async repinNextProvider() {
+  async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
     if (!next)
       return void 0;
-    this.pinnedProviderOverride = next;
+    trace?.retry({ provider: next, ...reason ? { reason } : {} });
     const client = this.client;
     this.client = void 0;
     this.sessionId = void 0;
+    this.sessionFingerprint = void 0;
     if (client?.isAlive)
       await client.stop();
-    await this.activate();
+    this.pinnedProviderOverride = next;
+    await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
+  /** One turn's stopwatch; writes only when the daemon configured a trace directory. */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "corner",
+      agentId: this.agent.publicKey,
+      roomId: this.options.cornerId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+    });
+  }
   async prompt(requestId, trigger, attachments = [], requestedById, restates) {
     const { api, cornerId } = this.options;
     const spoken = (text2) => restates && isCornerStatusRestatement(text2, restates) ? "" : text2;
@@ -16245,146 +16879,120 @@ var MonolithCornerTurnLoop = class {
       ...this.memberNames.get(requestedById) ? { name: this.memberNames.get(requestedById) } : {}
     } : void 0;
     this.currentTurn = { requestId, ...requester ? { requester } : {} };
+    const trace = this.beginTurnTrace(requestId);
     try {
       await withTurnReceiptHeartbeat(api, {
         agentId: this.agent.publicKey,
         roomId: cornerId,
         requestId,
         generationId: `${this.agent.publicKey}:${cornerId}`
-      }, () => this.options.scheduler.run(cornerId, this.lifecycle(), async () => {
-        if (this.forcedStop)
-          throw new Error("corner turn stopped for daemon handoff");
-        this.busy = true;
-        const [conversation, roster, delivered] = await Promise.all([
-          api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
-          this.roster(),
-          this.attachmentDir && attachments.length ? deliverAttachments(attachments, join4(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
-        ]);
-        const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
-        const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
-        if (requestedBy)
-          this.currentTurn = { requestId, requester: requestedBy };
-        const transcript = conversation.items.slice(-120).map((message) => `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`).join("\n");
-        const prompt = [
-          this.turnIdentityInstructions,
-          `Corner objective:
+      }, () => {
+        trace.noteScheduler("queue", this.options.scheduler.snapshot());
+        trace.start("queue-wait");
+        return this.options.scheduler.run(cornerId, this.lifecycle(trace), async () => {
+          trace.end("queue-wait");
+          trace.noteScheduler("admission", this.options.scheduler.snapshot());
+          if (this.forcedStop)
+            throw new Error("corner turn stopped for daemon handoff");
+          this.busy = true;
+          const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
+            api.execute("getRoomConversation", { roomId: cornerId, limit: 200 }),
+            this.roster(),
+            this.attachmentDir && attachments.length ? deliverAttachments(attachments, join5(this.attachmentDir, requestId.replace(/[^\w-]/g, "_")), this.options.fetchImpl) : Promise.resolve([])
+          ]));
+          const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
+          const requestedBy = requester && !requester.name && names.get(requester.pubkey) ? { ...requester, name: names.get(requester.pubkey) } : requester;
+          if (requestedBy)
+            this.currentTurn = { requestId, requester: requestedBy };
+          const transcriptRows = conversation.items.slice(-120).map((message) => ({
+            id: message.id,
+            line: `${names.get(message.authorId) ?? "Beeline"} [${message.type}]: ${message.body}`
+          }));
+          const buildPrompt = () => [
+            this.turnIdentityInstructions,
+            `Corner objective:
 ${this.options.objective}`,
-          transcript ? `Corner transcript:
-${transcript}` : "",
-          [
-            `Newest trigger:
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Corner transcript:", "New in the corner since your last turn (the earlier transcript is already in this session):"),
+            [
+              `Newest trigger:
 ${trigger}`,
-            ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
-          ].join("\n"),
-          "Continue the objective. Obey the PR checks and human hold rules in your session instructions.",
-          MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
-        ].filter(Boolean).join("\n\n");
-        const turnId = requestId;
-        const publishedToolCalls = /* @__PURE__ */ new Set();
-        const NARRATION_MAX_SEGMENTS = 20;
-        let narrationPostedChars = 0;
-        let narrationSegments = 0;
-        const postNarrationSegments = (full) => {
-          if (narrationSegments >= NARRATION_MAX_SEGMENTS)
-            return;
-          const unposted = full.slice(narrationPostedChars);
-          const boundaries = [...unposted.matchAll(/\n\n|[.!?](?=\s)/g)];
-          if (!boundaries.length)
-            return;
-          const boundary = boundaries[boundaries.length - 1];
-          const segmentEnd = narrationPostedChars + boundary.index + boundary[0].length;
-          const segment = stripAgentReplyPreamble(full.slice(narrationPostedChars, segmentEnd));
-          const start = narrationPostedChars;
-          narrationPostedChars = segmentEnd;
-          narrationSegments += 1;
-          const trimmed = spoken(segment.trim());
-          if (!trimmed)
-            return;
-          this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
-            await api.execute("postRoomMessage", {
-              roomId: cornerId,
-              text: trimmed,
-              presentation: "message"
-            });
-          }).catch(() => {
-            narrationPostedChars = start;
-            narrationSegments -= 1;
+              ...attachmentPromptLines(attachments, delivered, this.acceptsImages())
+            ].join("\n"),
+            "Continue the objective. Obey the PR checks and human hold rules in your session instructions.",
+            MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
+          ].filter(Boolean).join("\n\n");
+          const stream = new AgentTurnStream({
+            api,
+            agentId: this.agent.publicKey,
+            roomId: cornerId,
+            requestId,
+            label: `corner ${cornerId}`
           });
-        };
-        const publishToolCalls = (calls, settledOnly) => {
-          calls.forEach((call, index) => {
-            const key = toolCallKey(call, index);
-            if (publishedToolCalls.has(key) || settledOnly && !toolCallSettled(call))
-              return;
-            publishedToolCalls.add(key);
-            this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
-              const activity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
-              await api.execute("postAgentActivity", {
-                agentId: this.agent.publicKey,
-                roomId: cornerId,
-                requestId,
-                activity: [activity]
+          const publishedToolCalls = /* @__PURE__ */ new Set();
+          const publishToolCalls = (calls, settledOnly) => {
+            calls.forEach((call, index) => {
+              const key = toolCallKey(call, index);
+              if (publishedToolCalls.has(key) || settledOnly && !toolCallSettled(call))
+                return;
+              publishedToolCalls.add(key);
+              this.activityTail = this.activityTail.catch(() => void 0).then(async () => {
+                const activity = await cornerToolActivity(call, this.options.worktreePath, requestedBy);
+                await api.execute("postAgentActivity", {
+                  agentId: this.agent.publicKey,
+                  roomId: cornerId,
+                  requestId,
+                  activity: [activity]
+                });
+              }).then(() => void 0).catch((error) => {
+                publishedToolCalls.delete(key);
+                console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
               });
-            }).then(() => void 0).catch((error) => {
-              publishedToolCalls.delete(key);
-              console.error(`[thin-core] corner ${cornerId} tool activity failed:`, error);
             });
-          });
-        };
-        const runPrompt = async () => this.client.sessionPrompt(this.sessionId, promptWithImages(prompt, attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (_delta, full) => {
-          postNarrationSegments(full);
-          this.draftTail = this.draftTail.catch(() => void 0).then(() => api.execute("postAgentDraft", {
-            agentId: this.agent.publicKey,
-            roomId: cornerId,
-            turnId,
-            text: full
-          })).then(() => void 0).catch((error) => console.error(`[thin-core] corner ${cornerId} draft publish failed:`, error));
-        }, void 0, (calls) => publishToolCalls(calls, true));
-        let result = await runPrompt();
-        let explained = await this.explainEmpty(result);
-        if (explained && !restates && shouldRetryEmptyTurn(explained)) {
-          const silent = this.servingProviders();
-          const next = await this.repinNextProvider();
-          if (next) {
-            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
-            result = await runPrompt();
-            explained = await this.explainEmpty(result);
+          };
+          const runPrompt = async () => {
+            stream.beginRun();
+            trace.promptSent();
+            return this.client.sessionPrompt(this.sessionId, promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages())), 12e4, (delta, full) => {
+              trace.firstModelOutput();
+              stream.onChunk(delta, full);
+            }, void 0, (calls) => {
+              trace.toolCalls(calls);
+              publishToolCalls(calls, true);
+            });
+          };
+          let result = await runPrompt();
+          trace.promptSettled();
+          let explained = await this.explainEmpty(result);
+          if (explained && !restates && shouldRetryEmptyTurn(explained)) {
+            const silent = this.servingProviders();
+            const next = await this.repinNextProvider(trace, explained.reason);
+            if (next) {
+              console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
+              result = await runPrompt();
+              trace.promptSettled();
+              explained = await this.explainEmpty(result);
+            }
           }
-        }
-        await this.activityTail;
-        publishToolCalls(result.toolCalls, false);
-        for (const call of result.toolCalls) {
-          const failure = toolCallFailureLine(call);
-          if (failure)
-            console.warn(`[thin-core] corner ${cornerId} ${failure}`);
-        }
-        await this.activityTail;
-        await this.draftTail;
-        await this.activityTail;
-        let reply = stripAgentReplyPreamble(result.agentText).trim();
-        if (!reply && explained) {
-          reply = explained.recoveredText ? stripAgentReplyPreamble(explained.recoveredText).trim() : "";
-          if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
-            throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
+          await this.activityTail;
+          publishToolCalls(result.toolCalls, false);
+          for (const call of result.toolCalls) {
+            const failure = toolCallFailureLine(call);
+            if (failure)
+              console.warn(`[thin-core] corner ${cornerId} ${failure}`);
           }
-          console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
-        }
-        const durableTail = spoken(narrationPostedChars > 0 ? stripAgentReplyPreamble(result.agentText.slice(narrationPostedChars)).trim() : reply);
-        if (durableTail) {
-          await api.execute("postRoomMessage", {
-            roomId: cornerId,
-            requestId,
-            text: durableTail,
-            presentation: "message"
-          });
-        }
-        await api.execute("retractAgentLiveOutput", {
-          agentId: this.agent.publicKey,
-          roomId: cornerId,
-          turnId,
-          kind: "draft"
-        });
-      }, { priority: "interactive", roomKey: cornerId }), (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
+          await this.activityTail;
+          stream.close();
+          let reply = durableReplyText(result.agentText);
+          if (!reply && explained) {
+            reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
+            if (!reply && !(restates && !isAccountOrProviderRefusal(explained.record))) {
+              throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
+            }
+            console.warn(`[thin-core] corner ${cornerId} turn ${requestId}: ${explained.reason}`);
+          }
+          await trace.measure("publish", () => stream.settle(spoken(reply)));
+        }, { priority: "interactive", roomKey: cornerId });
+      }, (error) => console.error(`[thin-core] corner ${cornerId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
         roomId: cornerId,
@@ -16392,15 +17000,18 @@ ${trigger}`,
         status: "complete",
         generationId: `${this.agent.publicKey}:${cornerId}`
       });
+      await trace.finish("complete");
     } catch (error) {
+      const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
         roomId: cornerId,
         requestId,
         status: "failed",
         generationId: `${this.agent.publicKey}:${cornerId}`,
-        reason: distillTurnFailureReason(error)
+        reason
       });
+      await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
@@ -16481,7 +17092,10 @@ This answers your grant request; resume the paused work. If approved and it is a
           }
           cursor3 = inbox.cursor ?? cursor3;
           this.options.onPoll();
-          await wait(pollWithoutWait ? 0 : this.options.pollMs ?? cornerClosePollMs(), signal);
+          await Promise.race([
+            wait(pollWithoutWait ? 0 : this.options.pollMs ?? cornerClosePollMs(), signal),
+            waitForWake(api, cornerId, signal)
+          ]);
           pollWithoutWait = false;
         } catch (error) {
           if (signal?.aborted)
@@ -16497,6 +17111,14 @@ This answers your grant request; resume the paused work. If approved and it is a
     }
   }
 };
+async function waitForWake(api, cornerId, signal) {
+  if (signal?.aborted)
+    return;
+  try {
+    await api.execute("waitForCornerWake", { cornerId });
+  } catch {
+  }
+}
 async function wait(ms, signal) {
   if (signal?.aborted)
     return;
@@ -16512,19 +17134,19 @@ async function wait(ms, signal) {
 }
 
 // apps/body/dist/monolith-room-turn.js
-import { mkdir as mkdir7 } from "node:fs/promises";
+import { mkdir as mkdir8 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // packages/api-contract/dist/scheduled-prompts.js
 var SCHEDULE_SCHEDULER_NAME = "Beeline Scheduler";
 var SCHEDULE_RAN_VERB = "ran a schedule for";
 
 // apps/body/dist/monolith-room-turn.js
-function isRoomMcpPermissionRequest(request) {
+function isRoomMcpPermissionRequest(request, mountedServers = ROOM_MOUNTED_MCP_SERVERS) {
   if (isSquireMcpPermissionRequest(request))
     return false;
-  return isMountedMcpToolPermissionRequest(request);
+  return isMountedMcpToolPermissionRequest(request, mountedServers);
 }
 function roomPrincipalMayAddressAgent(authority, humanPermitted) {
   return authority.member && (authority.principalKind === "agent" || authority.principalKind === "human" && humanPermitted);
@@ -16586,6 +17208,8 @@ var MonolithRoomTurnLoop = class {
   agent;
   client;
   sessionId;
+  /** The configuration the live session baked in; a change invalidates it. */
+  sessionFingerprint;
   /** The live session's environment, read back for pi's own turn record. */
   agentEnv = {};
   /** OpenRouter providers this activation pinned, in order (C92). */
@@ -16594,7 +17218,6 @@ var MonolithRoomTurnLoop = class {
   pinnedProviderOverride;
   busy = false;
   turnInstructionPrefix = "";
-  draftTail = Promise.resolve();
   activeTurn;
   queuedTurns = [];
   /** Session scratch directory attachments are downloaded into (`TMPDIR/beeline-attachments`). */
@@ -16605,12 +17228,16 @@ var MonolithRoomTurnLoop = class {
   sessionScratchDir;
   /** The `agent-home.ts` overlay this session writes into; a Room grant keeps it. */
   sessionStateDirs = [];
+  /** What this exact ACP session has already been prompted with (`warm-transcript.ts`). */
+  warmTranscript = new WarmTranscript();
   /** Local copies already delivered this session, by message id, so transcript renders reuse them. */
   deliveredAttachments = /* @__PURE__ */ new Map();
   /** Names from the latest roster read, for ledger bylines the runner writes. */
   memberNames = /* @__PURE__ */ new Map();
   /** The request id of the turn that paused on a grant card, until its decision arrives. */
   pausedOnGrantRequestId;
+  /** Operator-local turn traces; built once when the daemon configured a directory. */
+  turnTraceSink;
   constructor(options) {
     this.options = options;
     this.agent = runtimeIdentity(options.runtime.agent);
@@ -16646,6 +17273,23 @@ var MonolithRoomTurnLoop = class {
       maskPaths: credentialMaskPaths(this.options.config.sandboxMaskPaths, this.options.config.operatorHome ?? homedir7())
     };
   }
+  /**
+   * One turn's stopwatch. It is created for every turn — measuring is cheap —
+   * and only WRITES when the daemon configured a runtime directory to write
+   * into, so a standalone or test Body stays silent.
+   */
+  beginTurnTrace(requestId) {
+    const directory = this.options.config.turnTraceDir;
+    if (directory)
+      this.turnTraceSink ??= new TurnTraceFile(directory);
+    return new TurnTrace({
+      surface: "room",
+      agentId: this.agent.publicKey,
+      roomId: this.options.roomId,
+      requestId,
+      ...this.turnTraceSink ? { sink: this.turnTraceSink } : {}
+    });
+  }
   currentTurnForRunner() {
     const active = this.activeTurn;
     if (!active)
@@ -16696,27 +17340,79 @@ var MonolithRoomTurnLoop = class {
     const cached = this.deliveredAttachments.get(item.id);
     if (cached)
       return cached;
-    const delivered = await deliverAttachments(item.attachments, join5(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
+    const delivered = await deliverAttachments(item.attachments, join6(this.attachmentDir, item.id.replace(/[^\w-]/g, "_")), this.options.fetchImpl);
     this.deliveredAttachments.set(item.id, withoutImageData(delivered));
     return delivered;
   }
-  async activate() {
+  repositoryState() {
+    return this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId });
+  }
+  /**
+   * Drop this Room's live harness process. The next activation starts cold.
+   * A rotation is a fact about one live session, so the pin goes with it.
+   */
+  async discardSession() {
+    const client = this.client;
+    this.client = void 0;
+    this.sessionId = void 0;
+    this.sessionFingerprint = void 0;
+    this.pinnedProviderOverride = void 0;
+    if (client?.isAlive)
+      await client.stop();
+  }
+  /**
+   * Whether the retained session still matches the agent's server-side
+   * configuration. Retention (C104) is a saving only while what it keeps is
+   * still current, and a session's persona and model pin are fixed when it
+   * opens: they cannot be corrected in place, so a changed one has to cost a
+   * respawn. The check is one round trip — the roster half of which the turn
+   * was going to fetch anyway — against a cold spawn measured in seconds.
+   */
+  async sessionIsCurrent() {
+    return await this.currentSessionFingerprint() === this.sessionFingerprint;
+  }
+  async currentSessionFingerprint() {
+    const [configuration, roster] = await Promise.all([
+      this.options.api.execute("getAgentConfiguration", {
+        agentId: this.agent.publicKey,
+        roomId: this.options.roomId
+      }),
+      this.roster()
+    ]);
+    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
+    return sessionConfigFingerprint({
+      model: configuration.model ?? this.options.config.modelSelection?.model,
+      effort: configuration.effort ?? this.options.config.modelSelection?.effort,
+      soul: configuration.soul ?? self?.soul,
+      agentName: self?.name ?? this.agent.name
+    });
+  }
+  async activate(trace) {
     if (this.client?.isAlive && this.sessionId)
       return this.sessionId;
+    trace?.noteActivation("cold");
     const [configuration, roster, repositoryState] = await Promise.all([
       this.options.api.execute("getAgentConfiguration", {
         agentId: this.agent.publicKey,
         roomId: this.options.roomId
       }),
       this.roster(),
-      this.options.api.execute("getRoomRepositoryState", { roomId: this.options.roomId })
+      this.repositoryState()
     ]);
+    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
+    const fingerprint = sessionConfigFingerprint({
+      model: configuration.model ?? this.options.config.modelSelection?.model,
+      effort: configuration.effort ?? this.options.config.modelSelection?.effort,
+      soul: configuration.soul ?? self?.soul,
+      agentName: self?.name ?? this.agent.name
+    });
     const directMessage = Array.isArray(repositoryState.directParticipants) && repositoryState.directParticipants.length === 2;
-    await mkdir7(this.options.cwd, { recursive: true });
+    await mkdir8(this.options.cwd, { recursive: true });
     const selection = configuration.model || configuration.effort ? { model: configuration.model, effort: configuration.effort } : this.options.config.modelSelection;
     const homeOverlay = this.options.config.agentHomeRoot ? await prepareRoomAgentHome({
       root: this.options.config.agentHomeRoot,
       sharedSkills: this.options.config.sharedSkills ?? [],
+      ...this.options.config.agentKind ? { agentKind: this.options.config.agentKind } : {},
       ...this.options.config.operatorHome ? { operatorHome: this.options.config.operatorHome } : {},
       ...openRouterRoutingInput(this.options.config, selection, this.options.fetchImpl, {
         ...this.pinnedProviderOverride ? { providerOverride: this.pinnedProviderOverride } : {},
@@ -16737,11 +17433,11 @@ var MonolithRoomTurnLoop = class {
     }, selection);
     const operatorHome = this.options.config.operatorHome ?? homedir7();
     const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
-    this.attachmentDir = tmpDir ? join5(tmpDir, "beeline-attachments") : void 0;
+    this.attachmentDir = tmpDir ? join6(tmpDir, "beeline-attachments") : void 0;
     this.sessionScratchDir = tmpDir;
     this.sessionStateDirs = stateDirs;
     const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-    await Promise.all(homeStateDirs.map((dir) => mkdir7(dir, { recursive: true })));
+    await Promise.all(homeStateDirs.map((dir) => mkdir8(dir, { recursive: true })));
     const spawnCommand = wrapAgentCommand({
       bwrapPath: this.options.config.bwrapPath,
       spec: {
@@ -16755,6 +17451,22 @@ var MonolithRoomTurnLoop = class {
       command,
       args: agentArgs
     });
+    const servers = [
+      readOnlyMcpServer(this.options.config, this.options.cwd),
+      beelineAgentMcpServer(this.options.config, this.options.api, {
+        roomId: this.options.roomId,
+        workspaceId: this.options.workspaceId,
+        attachRoot: this.options.cwd,
+        // The whole per-session overlay, not an enumerated subset: the agent
+        // never picks where a harness writes a file it generates (grok's own
+        // images dir, say), so anything inside the overlay it could possibly
+        // have written must be attachable, whatever subdirectory that is.
+        attachScratchRoot: this.options.config.agentHomeRoot ?? tmpDir,
+        directMessage,
+        ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
+      })
+    ];
+    const mountedServers = servers.map((server) => server.name);
     const clientOptions = {
       agentCommand: spawnCommand.command,
       agentArgs: spawnCommand.args,
@@ -16765,22 +17477,10 @@ var MonolithRoomTurnLoop = class {
       // (`config.ts`), which is exactly when `wrapAgentCommand` above wraps.
       osSandbox: Boolean(this.options.config.bwrapPath),
       autoApprovePermissions: false,
-      permissionAllowlist: isRoomMcpPermissionRequest
+      permissionAllowlist: (request) => isRoomMcpPermissionRequest(request, mountedServers)
     };
     this.client = (this.options.createAcpClient ?? ((value) => new AcpClient(value)))(clientOptions);
     await this.client.start();
-    const servers = [
-      readOnlyMcpServer(this.options.config, this.options.cwd),
-      beelineAgentMcpServer(this.options.config, this.options.api, {
-        roomId: this.options.roomId,
-        workspaceId: this.options.workspaceId,
-        attachRoot: this.options.cwd,
-        ...tmpDir ? { attachScratchRoot: tmpDir } : {},
-        directMessage,
-        ...this.options.grantRunnerEndpoint ? { grantRunner: this.options.grantRunnerEndpoint } : {}
-      })
-    ];
-    const self = roster.members.find((member) => member.identityId === this.agent.publicKey);
     const persona = configuration.soul ?? self?.soul;
     const identityInstructions = `Your Beeline Room identity is ${self?.name ?? this.agent.name}.`;
     const personaInstructions = [
@@ -16805,23 +17505,35 @@ var MonolithRoomTurnLoop = class {
       systemPrompt: [identityInstructions, personaInstructions, capabilityContext.sessionPrompt].filter(Boolean).join("\n\n")
     });
     this.sessionId = opened.sessionId;
+    this.sessionFingerprint = fingerprint;
     if (selection) {
       const options = filterAllowedModelConfigOptions(parseAdvertisedConfigOptions(opened.raw, selection.model));
       await applyAgentModelSelection(this.client, opened.sessionId, options, selection);
     }
     return opened.sessionId;
   }
-  lifecycle() {
+  /**
+   * The scheduler seam, and the only place that can see the boundary between
+   * waiting for a slot and spawning a harness: `queue-wait` closes the instant
+   * `activate()` is called, and `cold` vs `warm` is decided by whether this
+   * Room already holds a live ACP client.
+   */
+  lifecycle(trace) {
     return {
-      activate: () => this.activate(),
-      suspend: async () => {
-        const client = this.client;
-        this.client = void 0;
-        this.sessionId = void 0;
-        this.pinnedProviderOverride = void 0;
-        if (client?.isAlive)
-          await client.stop();
-      }
+      activate: async () => {
+        trace?.end("queue-wait");
+        return trace ? trace.measure("activation", () => this.activate(trace)) : this.activate();
+      },
+      isCurrent: () => {
+        trace?.end("queue-wait");
+        const check = () => this.sessionIsCurrent();
+        return trace ? trace.measure("activation", check) : check();
+      },
+      onStateChange: (state) => {
+        if (state === "waiting-for-slot")
+          trace?.noteCapacityWait();
+      },
+      suspend: () => this.discardSession()
     };
   }
   /** The pinned providers a failure reason should name for this session. */
@@ -16830,7 +17542,7 @@ var MonolithRoomTurnLoop = class {
   }
   /** Why a turn carried no answer text, or undefined when it did. */
   async explainEmpty(result) {
-    if (sanitizeAgentReply(result.agentText))
+    if (durableReplyText(result.agentText))
       return void 0;
     return explainEmptyAgentTurn({
       agentLabel: this.options.config.agentCommand ?? this.options.config.agentBinary,
@@ -16845,17 +17557,19 @@ var MonolithRoomTurnLoop = class {
    * named — by exactly one provider. Undefined when the pin has nowhere left
    * to go.
    */
-  async repinNextProvider() {
+  async repinNextProvider(trace, reason) {
     const next = nextPinnedProvider(this.pinnedProviders, this.pinnedProviderOverride);
     if (!next)
       return void 0;
-    this.pinnedProviderOverride = next;
+    trace?.retry({ provider: next, ...reason ? { reason } : {} });
     const client = this.client;
     this.client = void 0;
     this.sessionId = void 0;
+    this.sessionFingerprint = void 0;
     if (client?.isAlive)
       await client.stop();
-    await this.activate();
+    this.pinnedProviderOverride = next;
+    await (trace ? trace.measure("activation", () => this.activate(trace)) : this.activate());
     return next;
   }
   startPrompt(item) {
@@ -16898,6 +17612,7 @@ var MonolithRoomTurnLoop = class {
     const { item } = active;
     const api = this.options.api;
     this.busy = true;
+    const trace = this.beginTurnTrace(item.id);
     try {
       if (!this.memberNames.has(item.authorId))
         await this.roster().catch(() => void 0);
@@ -16920,22 +17635,28 @@ var MonolithRoomTurnLoop = class {
             }
           ]
         });
-        await this.options.scheduler.run(this.options.roomId, this.lifecycle(), async () => {
-          const [conversation, roster, delivered] = await Promise.all([
+        trace.noteScheduler("queue", this.options.scheduler.snapshot());
+        trace.start("queue-wait");
+        await this.options.scheduler.run(this.options.roomId, this.lifecycle(trace), async () => {
+          trace.end("queue-wait");
+          trace.noteScheduler("admission", this.options.scheduler.snapshot());
+          const [conversation, roster, delivered] = await trace.measure("context-fetch", () => Promise.all([
             api.execute("getRoomConversation", { roomId: this.options.roomId, limit: 200 }),
             this.roster(),
             this.deliver(item)
-          ]);
+          ]));
           const names = new Map(roster.members.map((member) => [member.identityId, member.name]));
-          const transcript = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())).join("\n");
+          const transcriptRows = conversation.items.filter((message) => message.type === "message" && message.id !== item.id && !active.steers.some((steerItem) => steerItem.id === message.id)).slice(-80).map((message) => ({
+            id: message.id,
+            line: roomMessagePrompt(names.get(message.authorId) ?? message.authorId.slice(0, 12), message.body, message.attachments, this.deliveredAttachments.get(message.id), this.acceptsImages())
+          }));
           const grantDecision = isGrantDecisionLine(item, this.agent.publicKey);
           const resumedRequestId = grantDecision ? this.pausedOnGrantRequestId : void 0;
           if (grantDecision)
             this.pausedOnGrantRequestId = void 0;
-          const prompt = [
+          const buildPrompt = () => [
             this.turnInstructionPrefix,
-            transcript ? `Room conversation so far:
-${transcript}` : "",
+            WarmTranscript.render(this.warmTranscript.select(this.sessionId, transcriptRows), "Room conversation so far:", "New in the Room since your last turn (the earlier conversation is already in this session):"),
             `Newest message from ${isScheduledPrompt(item, this.agent.publicKey) ? SCHEDULE_SCHEDULER_NAME : names.get(item.authorId) ?? item.authorId.slice(0, 12)}:`,
             roomMessagePrompt("", inboxItemPromptBody(item, this.agent.publicKey), item.attachments, delivered, this.acceptsImages()),
             grantDecision ? [
@@ -16950,25 +17671,25 @@ ${transcript}` : "",
               MAINTAIN_ASSIGNED_IDENTITY_DIRECTIVE
             ].join(" ")
           ].filter(Boolean).join("\n\n");
-          const turnId = item.id;
+          const stream = new AgentTurnStream({
+            api,
+            agentId: this.agent.publicKey,
+            roomId: this.options.roomId,
+            requestId: item.id,
+            label: `monolith Room ${this.options.roomId}`
+          });
           const runPrompt = async () => {
-            let nextPrompt = promptWithImages(prompt, attachmentImageBlocks(delivered, this.acceptsImages()));
+            let nextPrompt = promptWithImages(buildPrompt(), attachmentImageBlocks(delivered, this.acceptsImages()));
             let result2;
             for (; ; ) {
               let promptError;
               try {
-                let latestDraft = "";
-                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (_delta, full) => {
-                  latestDraft = sanitizeAgentReply(full);
-                  if (!latestDraft)
-                    return;
-                  this.draftTail = this.draftTail.catch(() => void 0).then(() => api.execute("postAgentDraft", {
-                    agentId: this.agent.publicKey,
-                    roomId: this.options.roomId,
-                    turnId,
-                    text: latestDraft
-                  })).then(() => void 0).catch((error) => console.error(`[thin-core] monolith Room ${this.options.roomId} draft publish failed:`, error));
-                });
+                stream.beginRun();
+                trace.promptSent();
+                result2 = await this.client.sessionPrompt(this.sessionId, nextPrompt, 12e4, (delta, full) => {
+                  trace.firstModelOutput();
+                  stream.onChunk(delta, full);
+                }, void 0, (calls) => trace.toolCalls(calls));
               } catch (error) {
                 promptError = error;
               }
@@ -16993,13 +17714,15 @@ ${transcript}` : "",
             return result2;
           };
           let result = await runPrompt();
+          trace.promptSettled();
           let explained = await this.explainEmpty(result);
           if (explained && shouldRetryEmptyTurn(explained)) {
             const silent = this.servingProviders();
-            const next = await this.repinNextProvider();
+            const next = await this.repinNextProvider(trace, explained.reason);
             if (next) {
               console.warn(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: ${turnFailureReasonWithProvider(explained.reason, silent)}; retrying on ${next}`);
               result = await runPrompt();
+              trace.promptSettled();
               explained = await this.explainEmpty(result);
             }
           }
@@ -17022,10 +17745,10 @@ ${transcript}` : "",
               console.warn(`[thin-core] monolith Room ${this.options.roomId} ${failure}`);
             }
           }
-          await this.draftTail;
-          let reply = sanitizeAgentReply(result.agentText);
+          stream.close();
+          let reply = durableReplyText(result.agentText);
           if (!reply && explained) {
-            reply = explained.recoveredText ? sanitizeAgentReply(explained.recoveredText) : "";
+            reply = explained.recoveredText ? durableReplyText(explained.recoveredText) : "";
             if (!reply) {
               throw new Error(turnFailureReasonWithProvider(explained.reason, this.servingProviders()));
             }
@@ -17034,22 +17757,10 @@ ${transcript}` : "",
           if (openCornerCall && !isFailedToolCall(openCornerCall)) {
             reply = stripCornerOpenEcho(reply);
           }
-          if (reply) {
-            await api.execute("postRoomMessage", {
-              roomId: this.options.roomId,
-              requestId: item.id,
-              triggerMessageId: item.id,
-              text: reply,
-              presentation: "message",
-              mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
-            });
-          }
-          await api.execute("retractAgentLiveOutput", {
-            agentId: this.agent.publicKey,
-            roomId: this.options.roomId,
-            turnId,
-            kind: "draft"
-          });
+          await trace.measure("publish", () => stream.settle(reply, reply ? {
+            triggerMessageId: item.id,
+            mentionIds: agentReplyMentionIds(reply, roster, this.agent.publicKey)
+          } : {}));
         }, { priority: "interactive", roomKey: this.options.roomId });
       }, (error) => console.error(`[thin-core] monolith Room ${this.options.roomId} receipt heartbeat failed:`, error));
       await api.execute("postAgentTurnReceipt", {
@@ -17059,15 +17770,18 @@ ${transcript}` : "",
         status: "complete",
         generationId: `${this.agent.publicKey}:${this.options.roomId}`
       });
+      await trace.finish("complete");
     } catch (error) {
+      const reason = distillTurnFailureReason(error);
       await api.execute("postAgentTurnReceipt", {
         agentId: this.agent.publicKey,
         roomId: this.options.roomId,
         requestId: item.id,
         status: "failed",
         generationId: `${this.agent.publicKey}:${this.options.roomId}`,
-        reason: distillTurnFailureReason(error)
+        reason
       });
+      await trace.finish("failed", reason);
       throw error;
     } finally {
       this.busy = false;
@@ -17173,6 +17887,22 @@ function resolvePerRoomLiveSessions(env = process.env) {
   const value = Number(raw);
   return Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_PER_ROOM_LIVE_SESSIONS;
 }
+var DEFAULT_SESSION_IDLE_MS = 30 * 6e4;
+var DEFAULT_MAX_WARM_SESSIONS = 4;
+function resolveMaxWarmSessions(env = process.env) {
+  const raw = env.BUZZY_BODY_MAX_WARM_SESSIONS?.trim();
+  if (!raw)
+    return DEFAULT_MAX_WARM_SESSIONS;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_MAX_WARM_SESSIONS;
+}
+function resolveSessionIdleMs(env = process.env) {
+  const raw = env.BUZZY_BODY_SESSION_IDLE_MS?.trim();
+  if (!raw)
+    return DEFAULT_SESSION_IDLE_MS;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value > 0 ? value : DEFAULT_SESSION_IDLE_MS;
+}
 var DEFAULT_WORKSPACE_LIVE_SESSIONS_FLOOR = 4;
 var SessionScheduler = class {
   /** Fixed ceiling when explicitly configured; undefined selects the dynamic one. */
@@ -17182,6 +17912,7 @@ var SessionScheduler = class {
   activeRoomCount;
   reserveInteractiveSlot;
   idleMs;
+  maxWarmSessions;
   live = /* @__PURE__ */ new Map();
   busy = /* @__PURE__ */ new Set();
   /** Per-logical-session queue. Interactive turns sort ahead of waiting background work. */
@@ -17199,10 +17930,14 @@ var SessionScheduler = class {
   capacityTail = Promise.resolve();
   sweepTimer;
   constructor(options = {}) {
-    this.idleMs = options.idleMs ?? 5 * 6e4;
+    this.idleMs = options.idleMs ?? DEFAULT_SESSION_IDLE_MS;
     if (!Number.isSafeInteger(this.idleMs) || this.idleMs < 1) {
       throw new Error("idleMs must be a positive integer");
     }
+    this.maxWarmSessions = options.maxWarmSessions ?? DEFAULT_MAX_WARM_SESSIONS;
+    if (!Number.isSafeInteger(this.maxWarmSessions) || this.maxWarmSessions < 1) {
+      throw new Error("maxWarmSessions must be a positive integer");
+    }
     this.reserveInteractiveSlot = options.reserveInteractiveSlot ?? false;
     if (options.maxLiveSessions !== void 0) {
       if (!Number.isSafeInteger(options.maxLiveSessions) || options.maxLiveSessions < 1) {
@@ -17307,6 +18042,11 @@ var SessionScheduler = class {
   generations(key) {
     return this.physicalHistory.get(key) ?? [];
   }
+  /**
+   * Read-only capacity diagnostic, exported beside the turn trace
+   * (`turn-trace.ts`) so a stalled turn can be attributed to a capacity wait
+   * rather than to a slow model. It reads state and changes none.
+   */
   snapshot() {
     let pending = 0;
     for (const session of this.live.values())
@@ -17318,9 +18058,18 @@ var SessionScheduler = class {
       busy: this.busy.size,
       queuedChannels: (/* @__PURE__ */ new Set([...this.queues.keys(), ...this.drainingKeys])).size,
       maxLive: this.workspaceCapacity(),
-      perRoom: this.perRoomLiveSessions
+      perRoom: this.perRoomLiveSessions,
+      warm: this.warmKeys().length,
+      maxWarm: this.maxWarmSessions
     };
   }
+  /**
+   * Live keys with no turn running and nothing queued behind them: exactly the
+   * processes retention is keeping resident, LRU-ordered oldest first.
+   */
+  warmKeys() {
+    return [...this.live.entries()].filter(([key, session]) => !session.pending && !this.busy.has(key) && !this.drainingKeys.has(key) && (this.queues.get(key)?.length ?? 0) === 0).sort((a2, b) => a2[1].lastUsedAt - b[1].lastUsedAt).map(([key]) => key);
+  }
   async suspend(key) {
     if (this.busy.has(key) || this.drainingKeys.has(key) || (this.queues.get(key)?.length ?? 0) > 0)
       return;
@@ -17400,36 +18149,47 @@ var SessionScheduler = class {
       let waitForCapacity;
       let evicted;
       let reservation;
+      let retained;
       try {
         if (priority === "background" && interactiveQueued())
           return false;
-        if (this.live.has(key)) {
+        retained = this.live.get(key);
+        if (retained) {
           this.busy.add(key);
-          return true;
-        }
-        const reserved = priority === "background" && this.reserveInteractiveSlot ? 1 : 0;
-        const roomLimit = Math.max(1, this.perRoomLiveSessions - reserved);
-        const workspaceLimit = Math.max(1, this.workspaceCapacity() - reserved);
-        const roomLive = [...this.live.values()].filter((session) => session.roomKey === roomKey).length;
-        if (roomLive >= roomLimit) {
-          evicted = this.claimIdleVictim((session) => session.roomKey === roomKey);
-        } else if (this.occupied() >= workspaceLimit) {
-          evicted = this.claimIdleVictim(() => true);
-        }
-        if (!evicted && (roomLive >= roomLimit || this.occupied() >= workspaceLimit)) {
-          waitForCapacity = new Promise((resolveWaiter) => this.waiters.push(resolveWaiter));
         } else {
-          const idleMs = lifecycle.idleMs ?? this.idleMs;
-          if (!Number.isSafeInteger(idleMs) || idleMs < 1) {
-            throw new Error("session lifecycle idleMs must be a positive integer");
+          const reserved = priority === "background" && this.reserveInteractiveSlot ? 1 : 0;
+          const roomLimit = Math.max(1, this.perRoomLiveSessions - reserved);
+          const workspaceLimit = Math.max(1, this.workspaceCapacity() - reserved);
+          const roomLive = [...this.live.values()].filter((session) => session.roomKey === roomKey).length;
+          if (roomLive >= roomLimit) {
+            evicted = this.claimIdleVictim((session) => session.roomKey === roomKey);
+          } else if (this.occupied() >= workspaceLimit) {
+            evicted = this.claimIdleVictim(() => true);
+          }
+          if (!evicted && (roomLive >= roomLimit || this.occupied() >= workspaceLimit)) {
+            waitForCapacity = new Promise((resolveWaiter) => this.waiters.push(resolveWaiter));
+          } else {
+            const idleMs = lifecycle.idleMs ?? this.idleMs;
+            if (!Number.isSafeInteger(idleMs) || idleMs < 1) {
+              throw new Error("session lifecycle idleMs must be a positive integer");
+            }
+            reservation = { lifecycle, lastUsedAt: Date.now(), roomKey, pending: true, idleMs };
+            this.live.set(key, reservation);
+            this.busy.add(key);
           }
-          reservation = { lifecycle, lastUsedAt: Date.now(), roomKey, pending: true, idleMs };
-          this.live.set(key, reservation);
-          this.busy.add(key);
         }
       } finally {
         releaseCapacity();
       }
+      if (retained) {
+        if (await this.stillCurrent(lifecycle))
+          return true;
+        if (this.live.get(key) === retained)
+          this.live.delete(key);
+        this.busy.delete(key);
+        await this.retire(retained);
+        continue;
+      }
       if (!reservation) {
         await this.notifyState(lifecycle, "waiting-for-slot");
         await waitForCapacity;
@@ -17475,6 +18235,15 @@ var SessionScheduler = class {
     this.suspending.add(victim[1]);
     return victim[1];
   }
+  /**
+   * Retire what retention should no longer be holding: first anything past its
+   * idle window, then — LRU first — whatever still exceeds the resident
+   * ceiling. The second pass is the real bound on retention: without it a
+   * longer idle window would let a Workspace with many Rooms grow its resident
+   * process count with the capacity ceiling. It runs on the sweep tick (at
+   * most every 30s), so the ceiling is enforced within one tick of a turn
+   * ending rather than instantly.
+   */
   async sweepIdle() {
     const now2 = Date.now();
     for (const [key, session] of [...this.live.entries()]) {
@@ -17482,6 +18251,26 @@ var SessionScheduler = class {
         await this.suspend(key);
       }
     }
+    const warm = this.warmKeys();
+    for (const key of warm.slice(0, Math.max(0, warm.length - this.maxWarmSessions))) {
+      await this.suspend(key);
+    }
+  }
+  /**
+   * Ask a lifecycle whether its retained process is still usable. A lifecycle
+   * that cannot answer keeps its session: a server hiccup is not a
+   * configuration change, and throwing away a live process over one would
+   * spend a cold start to learn nothing.
+   */
+  async stillCurrent(lifecycle) {
+    if (!lifecycle.isCurrent)
+      return true;
+    try {
+      return await lifecycle.isCurrent();
+    } catch (error) {
+      console.warn("[body] retained session currency check failed; keeping it:", error);
+      return true;
+    }
   }
   wakeCapacityWaiters() {
     const waiters = this.waiters.splice(0);
@@ -17561,7 +18350,8 @@ var RoomRuntimeCoordinator = class {
       perRoomLiveSessions: resolvePerRoomLiveSessions(process.env),
       workspaceFloor: Number(process.env.BUZZY_BODY_MAX_SESSIONS_FLOOR ?? String(DEFAULT_WORKSPACE_LIVE_SESSIONS_FLOOR)),
       activeRoomCount: () => this.running.size,
-      idleMs: Number(process.env.BUZZY_BODY_SESSION_IDLE_MS ?? String(5 * 6e4)),
+      idleMs: resolveSessionIdleMs(process.env),
+      maxWarmSessions: resolveMaxWarmSessions(process.env),
       reserveInteractiveSlot: true
     });
   }
@@ -17571,6 +18361,15 @@ var RoomRuntimeCoordinator = class {
   activeRoomCount() {
     return this.running.size;
   }
+  /**
+   * The session scheduler's capacity, read-only, beside the turn traces
+   * (`turn-trace.ts` embeds the same snapshot in every record). A turn that
+   * sat in `queue-wait` while this was at its ceiling waited on capacity, not
+   * on a model.
+   */
+  schedulerSnapshot() {
+    return this.scheduler.snapshot();
+  }
   needsFastReconcile() {
     return this.confirmationPending;
   }
@@ -17682,13 +18481,13 @@ var RoomRuntimeCoordinator = class {
     return this.runtime.rooms.find((room) => room.channelId === roomId);
   }
   roomRoot(roomId) {
-    return this.roomRecord(roomId)?.root ?? resolve16(dirname6(this.configPath), "rooms", roomId);
+    return this.roomRecord(roomId)?.root ?? resolve17(dirname6(this.configPath), "rooms", roomId);
   }
   roomAgentHomeRoot(workspaceRoot, required = false) {
     const flag = process.env.BUZZY_BODY_ROOM_HOME;
     if (!required && flag === "0")
       return void 0;
-    const home = resolve16(workspaceRoot, "agent-home");
+    const home = resolve17(workspaceRoot, "agent-home");
     if (!required && flag !== "1" && !existsSync4(home) && existsSync4(workspaceRoot))
       return void 0;
     try {
@@ -17705,9 +18504,10 @@ var RoomRuntimeCoordinator = class {
     return {
       ...this.baseConfig,
       workspaceRoot,
-      agentPrivateRoot: resolve16(workspaceRoot, "agent-private"),
-      agentMemoryRoot: resolve16(dirname6(this.configPath), "memory"),
+      agentPrivateRoot: resolve17(workspaceRoot, "agent-private"),
+      agentMemoryRoot: resolve17(dirname6(this.configPath), "memory"),
       openRouterRoutingCacheDir: openRouterRoutingCacheDir(dirname6(this.configPath)),
+      turnTraceDir: turnTraceDirectory(dirname6(this.configPath)),
       ...agentHomeRoot ? { agentHomeRoot } : {}
     };
   }
@@ -17773,12 +18573,12 @@ var RoomRuntimeCoordinator = class {
       return this.roomRoot(roomId);
     const remote = roomCheckoutRemote(repository.remote);
     const targetBranch = repository.targetBranch || "main";
-    const checkoutId = createHash3("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
-    const path = resolve16(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
-    await mkdir8(dirname6(path), { recursive: true, mode: 448 });
+    const checkoutId = createHash4("sha256").update(`${remote}\0${targetBranch}`).digest("hex").slice(0, 24);
+    const path = resolve17(this.runtime.supervisorRoot, "beeline", "room-checkouts", checkoutId);
+    await mkdir9(dirname6(path), { recursive: true, mode: 448 });
     const token = remote.startsWith("https://github.com/") ? await this.options.daemonApi.execute("getRoomGitHubToken", { roomId }) : void 0;
     const env = token ? githubGitEnv(token.token) : process.env;
-    if (!existsSync4(resolve16(path, ".git"))) {
+    if (!existsSync4(resolve17(path, ".git"))) {
       await execFileAsync3("git", ["clone", "--no-checkout", remote, path], {
         env,
         maxBuffer: 4 * 1024 * 1024
@@ -17808,9 +18608,13 @@ var RoomRuntimeCoordinator = class {
         this.options.daemonApi.execute("getRoomRepositoryState", {
           roomId: corner.parentRoomId
         }),
+        // Startup recovers the objective from the corner's FIRST durable
+        // message, so this is the one conversation read that wants the oldest
+        // end of the Room. Every other read defaults to the newest page.
         this.options.daemonApi.execute("getRoomConversation", {
           roomId: corner.cornerId,
-          limit: 200
+          limit: 200,
+          window: "earliest"
         }),
         this.options.daemonApi.execute("getRoomGitHubToken", {
           roomId: corner.parentRoomId
@@ -17898,13 +18702,13 @@ var RoomRuntimeCoordinator = class {
   }
   async materializeCornerWorktree(input) {
     const remote = githubHttpsRemote(input.remote);
-    const repositoryHash = createHash3("sha256").update(remote).digest("hex").slice(0, 24);
-    const gitCommonDir = resolve16(this.runtime.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
-    const path = resolve16(this.runtime.supervisorRoot, "beeline", "corners", input.cornerId);
-    await mkdir8(dirname6(gitCommonDir), { recursive: true, mode: 448 });
-    await mkdir8(dirname6(path), { recursive: true, mode: 448 });
+    const repositoryHash = createHash4("sha256").update(remote).digest("hex").slice(0, 24);
+    const gitCommonDir = resolve17(this.runtime.supervisorRoot, "beeline", "repositories", `${repositoryHash}.git`);
+    const path = resolve17(this.runtime.supervisorRoot, "beeline", "corners", input.cornerId);
+    await mkdir9(dirname6(gitCommonDir), { recursive: true, mode: 448 });
+    await mkdir9(dirname6(path), { recursive: true, mode: 448 });
     const authEnv = githubGitEnv(input.token);
-    if (!existsSync4(resolve16(gitCommonDir, "HEAD"))) {
+    if (!existsSync4(resolve17(gitCommonDir, "HEAD"))) {
       await execFileAsync3("git", ["clone", "--bare", remote, gitCommonDir], {
         env: authEnv,
         maxBuffer: 4 * 1024 * 1024
@@ -17917,8 +18721,8 @@ var RoomRuntimeCoordinator = class {
       "origin",
       `+refs/heads/${input.targetBranch}:refs/remotes/origin/${input.targetBranch}`
     ], { env: authEnv, maxBuffer: 4 * 1024 * 1024 });
-    if (!existsSync4(resolve16(path, ".git"))) {
-      await rm3(path, { recursive: true, force: true });
+    if (!existsSync4(resolve17(path, ".git"))) {
+      await rm4(path, { recursive: true, force: true });
       await execFileAsync3("git", [
         `--git-dir=${gitCommonDir}`,
         "worktree",
@@ -17954,7 +18758,7 @@ var RoomRuntimeCoordinator = class {
       `${this.agent.publicKey.slice(0, 16)}@users.noreply.github.com`
     ]);
     const top = await execFileAsync3("git", ["-C", path, "rev-parse", "--show-toplevel"]);
-    if (resolve16(top.stdout.trim()) !== resolve16(path)) {
+    if (resolve17(top.stdout.trim()) !== resolve17(path)) {
       throw new Error(`corner worktree escaped its isolated root: ${top.stdout.trim()}`);
     }
     return { path, gitCommonDir };
@@ -18132,9 +18936,9 @@ var ThinDaemonCore = class {
 
 // apps/body/dist/systemd.js
 import { execFile as execFile5 } from "node:child_process";
-import { mkdir as mkdir9, readFile as readFile7, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile8, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname7, resolve as resolve17 } from "node:path";
+import { dirname as dirname7, resolve as resolve18 } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile5);
@@ -18176,9 +18980,9 @@ WantedBy=default.target
 }
 function isCanonicalInstalledLauncher(env = process.env, invocationPath = process.argv[1]) {
   const home = env.HOME?.trim() || homedir8();
-  const expectedLibDir = resolve17(home, ".local", "lib", "beeline");
+  const expectedLibDir = resolve18(home, ".local", "lib", "beeline");
   const expectedPrefix = `${expectedLibDir}/`;
-  return resolve17(env.BEELINE_LIB_DIR?.trim() || "/") === expectedLibDir && Boolean(invocationPath) && resolve17(invocationPath).startsWith(expectedPrefix);
+  return resolve18(env.BEELINE_LIB_DIR?.trim() || "/") === expectedLibDir && Boolean(invocationPath) && resolve18(invocationPath).startsWith(expectedPrefix);
 }
 function assertCanonicalInstalledLauncher(env, invocationPath) {
   if (isCanonicalInstalledLauncher(env, invocationPath))
@@ -18186,8 +18990,8 @@ function assertCanonicalInstalledLauncher(env, invocationPath) {
   throw new Error("refusing to modify the shared Beeline systemd unit outside the canonical ~/.local/bin/beeline launcher");
 }
 function systemdUserUnitPath(env = process.env) {
-  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve17(homedir8(), ".config");
-  return resolve17(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
+  const configRoot = env.XDG_CONFIG_HOME?.trim() || resolve18(homedir8(), ".config");
+  return resolve18(configRoot, "systemd", "user", SYSTEMD_UNIT_NAME);
 }
 var runSystemctl = async (args) => {
   const result = await execFileAsync4("systemctl", ["--user", ...args], {
@@ -18203,9 +19007,9 @@ async function installAgentService(publicKey, options = {}) {
   assertCanonicalInstalledLauncher(env, options.invocationPath);
   const path = systemdUserUnitPath(env);
   const content = agentServiceUnit();
-  const existing = await readFile7(path, "utf8").catch(() => "");
+  const existing = await readFile8(path, "utf8").catch(() => "");
   if (existing !== content) {
-    await mkdir9(dirname7(path), { recursive: true, mode: 448 });
+    await mkdir10(dirname7(path), { recursive: true, mode: 448 });
     await writeFile7(path, content, { mode: 384 });
   }
   const run2 = options.run ?? runSystemctl;
@@ -18377,9 +19181,9 @@ async function runStartCommand(args, interactiveUi) {
 
 // apps/body/dist/connect-command.js
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
-import { chmod as chmod4, mkdir as mkdir11, readFile as readFile9, unlink as unlink2, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve19 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { chmod as chmod4, mkdir as mkdir12, readFile as readFile10, unlink as unlink2, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname10, resolve as resolve20 } from "node:path";
 import { stdin as stdin3, stdout as stdout4 } from "node:process";
 
 // packages/api-contract/dist/agent-pairing-code.js
@@ -18960,7 +19764,7 @@ function requestConnectGrant(baseUrl, pairingCode, selection, fetchImpl) {
   const normalizedPairingCode = normalizeAgentPairingCode(pairingCode);
   if (!normalizedPairingCode)
     throw new Error("invalid pairing code");
-  const avatarSeed = createHash5("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
+  const avatarSeed = createHash6("sha256").update(normalizedPairingCode.toUpperCase()).digest("hex").slice(0, 32);
   return jsonRequest(`${baseUrl}/auth/agent/connect`, {
     pairing_code: normalizedPairingCode,
     harness: selection.harness,
@@ -18993,7 +19797,7 @@ async function installCurrentRelease(fetchImpl) {
   });
   await activateRelease(layout, releaseId);
   return {
-    binary: resolve19(layout.binDir, "beeline"),
+    binary: resolve20(layout.binDir, "beeline"),
     version: published.version ?? releaseId
   };
 }
@@ -19016,7 +19820,7 @@ function providerEnvironment(selection) {
   };
 }
 async function writePrivateJson(path, value) {
-  await mkdir11(dirname10(path), { recursive: true, mode: 448 });
+  await mkdir12(dirname10(path), { recursive: true, mode: 448 });
   await writeFile9(path, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
   await chmod4(path, 384);
@@ -19025,8 +19829,8 @@ async function writeProviderEnv(selection, agentPubkey) {
   const values = providerEnvironment(selection);
   if (Object.keys(values).length === 0)
     return void 0;
-  const path = resolve19(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
-  await mkdir11(dirname10(path), { recursive: true, mode: 448 });
+  const path = resolve20(defaultSupervisorRoot(process.env), "beeline", "connect", `${agentPubkey}.env`);
+  await mkdir12(dirname10(path), { recursive: true, mode: 448 });
   const contents = Object.entries(values).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join("\n");
   await writeFile9(path, `${contents}
 `, { mode: 384 });
@@ -19090,7 +19894,7 @@ async function runConnectWizard(code, fetchImpl) {
   const grant = { ...claimed, agent_name: await confirmSeededName(baseUrl, pairingCode, claimed, fetchImpl) };
   const installedRelease = await brassSpinner("Installing the Beeline daemon\u2026", () => installCurrentRelease(fetchImpl), (release) => `Installed Beeline helper ${release.version}`);
   const llmEnvFile = await writeProviderEnv(selection, grant.agent_pubkey);
-  const grantPath = resolve19(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
+  const grantPath = resolve20(defaultSupervisorRoot(process.env), "beeline", "connect", `grant-${process.pid}-${Date.now()}.json`);
   await writePrivateJson(grantPath, {
     agentSecretKey: grant.agent_secret_key,
     bodySecretKey: grant.body_secret_key,
@@ -19169,12 +19973,12 @@ async function runConnectFinishCommand(path) {
     throw new Error("connect-finish may run only from the canonical installed Beeline launcher");
   }
   try {
-    const grant = JSON.parse(await readFile9(resolve19(path), "utf8"));
+    const grant = JSON.parse(await readFile10(resolve20(path), "utf8"));
     if (!isDevicePairingGrant(grant))
       throw new Error("device connection grant is invalid");
     const connected = await completeDevicePairing(grant);
-    await unlink2(resolve19(path));
-    const providerEnv = grant.llmEnvFile ? await readFile9(grant.llmEnvFile, "utf8").catch(() => "") : "";
+    await unlink2(resolve20(path));
+    const providerEnv = grant.llmEnvFile ? await readFile10(grant.llmEnvFile, "utf8").catch(() => "") : "";
     const apiKey = (/^OPENROUTER_API_KEY=(\S+)/m.exec(providerEnv)?.[1] ?? "").replace(/^["']|["']$/g, "");
     const model = openRouterModelId(grant.model, { OPENROUTER_API_KEY: apiKey });
     if (model) {
@@ -19202,19 +20006,19 @@ init_self_update_manifest();
 // apps/body/dist/managed-update.js
 init_self_update();
 import { spawn as spawn6 } from "node:child_process";
-import { mkdir as mkdir13, rm as rm5, stat as stat2, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname12, resolve as resolve21 } from "node:path";
+import { mkdir as mkdir14, rm as rm6, stat as stat2, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname12, resolve as resolve22 } from "node:path";
 
 // apps/body/dist/update-rollback-alert.js
-import { mkdir as mkdir12, readFile as readFile10, rename as rename4, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname11, resolve as resolve20 } from "node:path";
+import { mkdir as mkdir13, readFile as readFile11, rename as rename4, writeFile as writeFile10 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve21 } from "node:path";
 function updateRollbackAlertPath(runtimeDir) {
-  return resolve20(runtimeDir, "update-rollback-alert.json");
+  return resolve21(runtimeDir, "update-rollback-alert.json");
 }
 async function writeAlert(runtimeDir, alert) {
   const path = updateRollbackAlertPath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir12(dirname11(path), { recursive: true });
+  await mkdir13(dirname11(path), { recursive: true });
   await writeFile10(staged, `${JSON.stringify(alert, null, 2)}
 `, { mode: 384 });
   await rename4(staged, path);
@@ -19227,7 +20031,7 @@ async function queueUpdateRollbackAlert(runtimeDir, releaseId, now2 = Date.now()
 }
 async function readUpdateRollbackAlert(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile10(updateRollbackAlertPath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile11(updateRollbackAlertPath(runtimeDir), "utf8"));
     if (value.version !== 1 || typeof value.releaseId !== "string")
       return void 0;
     return value;
@@ -19252,13 +20056,13 @@ var LOCK_STALE_MS = UPDATE_WORKER_DEADLINE_MS + 5 * 6e4;
 var DEFAULT_UPDATE_INITIAL_DELAY_MS = 0;
 async function withInstallLock(layout, work, options = {}) {
   const now2 = options.now ?? Date.now;
-  const lock = resolve21(layout.releasesRoot, ".state", "install.lock");
+  const lock = resolve22(layout.releasesRoot, ".state", "install.lock");
   const deadline = now2() + (options.waitMs ?? 1e4);
-  await mkdir13(dirname12(lock), { recursive: true });
+  await mkdir14(dirname12(lock), { recursive: true });
   for (; ; ) {
     try {
-      await mkdir13(lock);
-      await writeFile11(resolve21(lock, "owner"), `${process.pid}
+      await mkdir14(lock);
+      await writeFile11(resolve22(lock, "owner"), `${process.pid}
 ${now2()}
 `, "utf8");
       break;
@@ -19267,7 +20071,7 @@ ${now2()}
         throw error;
       const age = now2() - await stat2(lock).then((value) => value.mtimeMs).catch(() => now2());
       if (age > LOCK_STALE_MS) {
-        await rm5(lock, { recursive: true, force: true });
+        await rm6(lock, { recursive: true, force: true });
         continue;
       }
       if (now2() >= deadline)
@@ -19278,7 +20082,7 @@ ${now2()}
   try {
     return await work();
   } finally {
-    await rm5(lock, { recursive: true, force: true });
+    await rm6(lock, { recursive: true, force: true });
   }
 }
 var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
@@ -19381,7 +20185,7 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
       if (!attempt || attempt.releaseId !== desiredRelease || attempt.status !== "pending") {
         const from = await readInstalledBundleIdentity({
           ...this.#layout,
-          libDir: resolve21(this.#layout.releasesRoot, this.#loadedRelease)
+          libDir: resolve22(this.#layout.releasesRoot, this.#loadedRelease)
         }).catch(() => void 0) ?? {};
         const to = await readInstalledBundleIdentity(this.#layout).catch(() => void 0) ?? {};
         const record2 = {
@@ -19668,7 +20472,7 @@ async function proveLoadedReleaseReady(layout, runtimeDir, loadedRelease, option
   });
   if (!accepted)
     return false;
-  await writeFile11(resolve21(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
+  await writeFile11(resolve22(runtimeDir, "daemon-ready.json"), `${JSON.stringify({
     readyAt: (options.now ?? Date.now)(),
     loadedRelease,
     functionalProof: options.functionalProof
@@ -19873,16 +20677,16 @@ async function runUpdateCommand(args) {
 init_self_update();
 
 // apps/body/dist/daemon-failure.js
-import { mkdir as mkdir14, readFile as readFile11, rename as rename5, rm as rm6, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname13, resolve as resolve22 } from "node:path";
+import { mkdir as mkdir15, readFile as readFile12, rename as rename5, rm as rm7, writeFile as writeFile12 } from "node:fs/promises";
+import { dirname as dirname13, resolve as resolve23 } from "node:path";
 var DAEMON_FAILURE_LIMIT = 3;
 var DAEMON_FAILURE_WINDOW_MS = 5 * 6e4;
 function daemonFailurePath(runtimeDir) {
-  return resolve22(runtimeDir, "daemon-distress.json");
+  return resolve23(runtimeDir, "daemon-distress.json");
 }
 async function readFailureRecord(runtimeDir) {
   try {
-    const value = JSON.parse(await readFile11(daemonFailurePath(runtimeDir), "utf8"));
+    const value = JSON.parse(await readFile12(daemonFailurePath(runtimeDir), "utf8"));
     if (value.version !== 1 || !Array.isArray(value.failures) || value.failures.some((failure) => typeof failure !== "number") || typeof value.lastError !== "string") {
       return void 0;
     }
@@ -19894,7 +20698,7 @@ async function readFailureRecord(runtimeDir) {
 async function writeFailureRecord(runtimeDir, record2) {
   const path = daemonFailurePath(runtimeDir);
   const staged = `${path}.${process.pid}.tmp`;
-  await mkdir14(dirname13(path), { recursive: true, mode: 448 });
+  await mkdir15(dirname13(path), { recursive: true, mode: 448 });
   await writeFile12(staged, `${JSON.stringify(record2, null, 2)}
 `, { mode: 384 });
   await rename5(staged, path);
@@ -19913,13 +20717,13 @@ async function recordDaemonStartFailure(runtimeDir, error, now2 = Date.now()) {
   return { distressed, count: failures.length, path: daemonFailurePath(runtimeDir) };
 }
 async function clearDaemonStartFailures(runtimeDir) {
-  await rm6(daemonFailurePath(runtimeDir), { force: true });
+  await rm7(daemonFailurePath(runtimeDir), { force: true });
 }
 
 // apps/body/dist/update-functional-probe.js
-import { mkdir as mkdir15, rm as rm7 } from "node:fs/promises";
+import { mkdir as mkdir16, rm as rm8 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { resolve as resolve23 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 var UPDATE_PROBE_SESSION_TIMEOUT_MS = 1e4;
 var UPDATE_PROBE_SESSION_OPEN_TIMEOUT_MS = 2e4;
 var UPDATE_PROBE_TURN_TIMEOUT_MS = 45e3;
@@ -19965,11 +20769,11 @@ async function runUpdateFunctionalProbe(input) {
   if (input.sandboxRequired && !input.config.bwrapPath) {
     throw new UpdateFunctionalProbeError("sandbox-unavailable", "the configured bubblewrap boundary did not pass its startup self-test");
   }
-  const root = input.probeRoot ?? resolve23(input.runtimeDir, "update-functional-probe");
-  const cwd = resolve23(root, "checkout");
-  const homeRoot = resolve23(root, "agent-home");
-  await rm7(root, { recursive: true, force: true });
-  await mkdir15(cwd, { recursive: true, mode: 448 });
+  const root = input.probeRoot ?? resolve24(input.runtimeDir, "update-functional-probe");
+  const cwd = resolve24(root, "checkout");
+  const homeRoot = resolve24(root, "agent-home");
+  await rm8(root, { recursive: true, force: true });
+  await mkdir16(cwd, { recursive: true, mode: 448 });
   let client;
   try {
     const agentEnv = {
@@ -19978,6 +20782,7 @@ async function runUpdateFunctionalProbe(input) {
         root: homeRoot,
         operatorHome: input.config.operatorHome ?? homedir10(),
         sharedSkills: input.config.sharedSkills ?? [],
+        ...input.config.agentKind ? { agentKind: input.config.agentKind } : {},
         skillReleaseId: input.releaseId,
         failClosed: true,
         ...openRouterRoutingInput({ ...input.config, openRouterRoutingCacheDir: openRouterRoutingCacheDir(input.runtimeDir) }, input.config.modelSelection)
@@ -19997,7 +20802,7 @@ async function runUpdateFunctionalProbe(input) {
       const { stateDirs, tmpDir } = harnessStateDirsFromEnv(agentEnv);
       const operatorHome = input.config.operatorHome ?? homedir10();
       const homeStateDirs = harnessHomeStateDirs(command, agentEnv.HOME ?? operatorHome);
-      await Promise.all(homeStateDirs.map((dir) => mkdir15(dir, { recursive: true })));
+      await Promise.all(homeStateDirs.map((dir) => mkdir16(dir, { recursive: true })));
       spawnCommand = wrapAgentCommand({
         bwrapPath: input.config.bwrapPath,
         spec: {
@@ -20086,13 +20891,13 @@ async function runUpdateFunctionalProbe(input) {
     };
   } finally {
     await client?.stop().catch(() => void 0);
-    await rm7(root, { recursive: true, force: true }).catch(() => void 0);
+    await rm8(root, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 
 // apps/body/dist/current-release-probe.js
 import { spawn as spawn7 } from "node:child_process";
-import { dirname as dirname14, join as join7 } from "node:path";
+import { dirname as dirname14, join as join8 } from "node:path";
 init_self_update();
 var CURRENT_RELEASE_PROBE_TIMEOUT_MS = 8e4;
 var UPDATE_PROBE_COMMAND = "update-probe";
@@ -20127,13 +20932,13 @@ function outcomeFromReport(report) {
   }
 }
 async function probeReleaseInSubprocess(input) {
-  const bundleDir = join7(input.layout.releasesRoot, input.releaseId);
+  const bundleDir = join8(input.layout.releasesRoot, input.releaseId);
   const entrypoint = await resolveBundleEntrypoint(bundleDir);
   if (!entrypoint) {
     return { kind: "unavailable", reason: `release ${input.releaseId} has no runnable CLI entrypoint` };
   }
   const timeoutMs = input.timeoutMs ?? CURRENT_RELEASE_PROBE_TIMEOUT_MS;
-  return new Promise((resolve26) => {
+  return new Promise((resolve27) => {
     const child = spawn7(input.execPath ?? process.execPath, [entrypoint, UPDATE_PROBE_COMMAND, "--config", input.runtimeConfigPath], { env: input.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout6 = "";
     let stderr = "";
@@ -20143,7 +20948,7 @@ async function probeReleaseInSubprocess(input) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve26(outcome);
+      resolve27(outcome);
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
@@ -20190,7 +20995,7 @@ async function runUpdateProbeCommand(args, options = {}) {
   const runtime = await readRuntimeRecord(configPath);
   const agent = runtimeAgentCommand(runtime);
   const config = loadBodyConfig({
-    workspaceRoot: join7(dirname14(configPath), "workspace"),
+    workspaceRoot: join8(dirname14(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env: { ...env, BUZZ_AGENT_BIN: agent.command, BUZZ_DEV_MCP_BIN: runtime.mcpBinary },
     agent
@@ -20215,15 +21020,15 @@ async function runUpdateProbeCommand(args, options = {}) {
     releaseId,
     sandboxRequired: runtime.sandbox !== "off",
     // The successor's probe still holds `<runtimeDir>/update-functional-probe`.
-    probeRoot: join7(runtimeDir, "current-release-probe")
+    probeRoot: join8(runtimeDir, "current-release-probe")
   }));
   const report = outcome.kind === "served" ? { probe: "served" } : outcome.kind === "refused" ? { probe: "refused", status: outcome.status, reason: outcome.reason } : { probe: "failed", reason: outcome.reason };
   write(JSON.stringify(report));
 }
 
 // apps/body/dist/release-status.js
-import { readFile as readFile12, readdir as readdir4, rename as rename6, writeFile as writeFile13 } from "node:fs/promises";
-import { resolve as resolve24 } from "node:path";
+import { readFile as readFile13, readdir as readdir5, rename as rename6, writeFile as writeFile13 } from "node:fs/promises";
+import { resolve as resolve25 } from "node:path";
 var DAEMON_RELEASE_STATUS_FILE = "release-status.json";
 var RELEASE_VERSION = /^v\d+\.\d+\.\d+$/;
 var SOURCE_SHA = /^[0-9a-f]{7,64}$/;
@@ -20240,7 +21045,7 @@ async function writeDaemonReleaseStatus(runtimeDir, agentPubkey, identity, optio
     pid: options.pid ?? process.pid,
     readyAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
   };
-  const target = resolve24(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
+  const target = resolve25(runtimeDir, DAEMON_RELEASE_STATUS_FILE);
   const temporary = `${target}.${status.pid}.tmp`;
   await writeFile13(temporary, `${JSON.stringify(status, null, 2)}
 `, { mode: 384 });
@@ -20295,7 +21100,7 @@ async function runStoredDaemon(pathOrPointer) {
   runtime = activated.runtime;
   const daemonApi = activated.client;
   const agent = runtimeAgentCommand(runtime);
-  await writeFile14(resolve25(dirname15(configPath), "daemon.pid"), `${process.pid}
+  await writeFile14(resolve26(dirname15(configPath), "daemon.pid"), `${process.pid}
 `, { mode: 384 });
   const env = {
     ...process.env,
@@ -20303,7 +21108,7 @@ async function runStoredDaemon(pathOrPointer) {
     BUZZ_DEV_MCP_BIN: runtime.mcpBinary
   };
   const config = loadBodyConfig({
-    workspaceRoot: resolve25(dirname15(configPath), "workspace"),
+    workspaceRoot: resolve26(dirname15(configPath), "workspace"),
     llmEnvFile: runtime.llmEnvFile,
     env,
     agent
@@ -20473,8 +21278,8 @@ async function runStoredDaemon(pathOrPointer) {
     throw error;
   } finally {
     await notifier.stopping(stoppingStatus).catch(() => void 0);
-    const pidPath = resolve25(dirname15(configPath), "daemon.pid");
-    const recorded = Number((await readFile13(pidPath, "utf8").catch(() => "")).trim());
+    const pidPath = resolve26(dirname15(configPath), "daemon.pid");
+    const recorded = Number((await readFile14(pidPath, "utf8").catch(() => "")).trim());
     if (recorded === process.pid) {
       await unlink3(pidPath).catch(() => void 0);
     }
@@ -20537,7 +21342,7 @@ async function main() {
     }
     if (!configPath)
       throw new Error("daemon requires --config <runtime.json> or --agent <pubkey>");
-    await runStoredDaemon(resolve25(configPath));
+    await runStoredDaemon(resolve26(configPath));
     return;
   }
   if (command === "update") {