agent-log-viewer 1.0.2 → 1.0.3

package/dist/runtime-host.mjs

@@ -3344,7 +3344,7 @@ function freshSpecFor(engine, cwd, options = {}) {
         allowSubagents: options.allowSubagents ?? false,
         mcpServers,
         plugins: [],
-        title: null,
+        title: options.title?.trim() || null,
         project: null,
         parentConversationId: null,
         role: "worker",
@@ -3385,7 +3385,7 @@ function freshSpecFor(engine, cwd, options = {}) {
       allowSubagents: options.allowSubagents ?? false,
       mcpServers,
       plugins: [],
-      title: null,
+      title: options.title?.trim() || null,
       project: null,
       parentConversationId: null,
       role: "worker",
@@ -3584,6 +3584,97 @@ var init_cli = __esm(() => {
   CLAUDE_SHADOWED_ENV = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_BASE_URL", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "GOOGLE_APPLICATION_CREDENTIALS", "VERTEXAI_PROJECT", "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX", "LLV_TOKEN"];
 });
 
+// src/lib/proc/darwinArgv.ts
+import { createRequire as createRequire2 } from "module";
+function parseDarwinProcArgs2(buffer, bytesRead) {
+  if (bytesRead < ARGC_SIZE || bytesRead > buffer.byteLength)
+    return null;
+  const argc = buffer.readInt32LE(0);
+  if (argc <= 0 || argc > MAX_ARGC)
+    return null;
+  let cursor = buffer.indexOf(0, ARGC_SIZE);
+  if (cursor < 0 || cursor >= bytesRead)
+    return null;
+  while (cursor < bytesRead && buffer[cursor] === 0)
+    cursor += 1;
+  const argv = [];
+  while (argv.length < argc) {
+    const end = buffer.indexOf(0, cursor);
+    if (end < 0 || end >= bytesRead)
+      return null;
+    argv.push(buffer.toString("utf8", cursor, end));
+    cursor = end + 1;
+  }
+  return argv;
+}
+function loadReader2() {
+  if (cachedReader2 !== undefined)
+    return cachedReader2;
+  if (process.platform !== "darwin") {
+    cachedReader2 = null;
+    return cachedReader2;
+  }
+  try {
+    const runtimeRequire = createRequire2(import.meta.url);
+    const ffi = runtimeRequire(`bun:${"ffi"}`);
+    const library = ffi.dlopen("/usr/lib/libSystem.B.dylib", {
+      sysctl: {
+        args: [ffi.FFIType.ptr, ffi.FFIType.u32, ffi.FFIType.ptr, ffi.FFIType.ptr, ffi.FFIType.ptr, ffi.FFIType.u64],
+        returns: ffi.FFIType.i32
+      }
+    });
+    const unusedNew = Buffer.alloc(8);
+    const call = (mib, out, outLength) => Number(library.symbols.sysctl(ffi.ptr(mib), mib.byteLength / 4, ffi.ptr(out), ffi.ptr(outLength), ffi.ptr(unusedNew), BigInt(0)));
+    cachedReader2 = (pid, buffer) => {
+      const mib = Buffer.alloc(12);
+      mib.writeInt32LE(CTL_KERN, 0);
+      mib.writeInt32LE(KERN_PROCARGS2, 4);
+      mib.writeInt32LE(pid, 8);
+      const length = Buffer.alloc(8);
+      length.writeBigUInt64LE(BigInt(buffer.byteLength));
+      if (call(mib, buffer, length) !== 0)
+        return -1;
+      const written = Number(length.readBigUInt64LE());
+      return Number.isSafeInteger(written) ? written : -1;
+    };
+    cachedBuffer = Buffer.alloc(readArgMax(call));
+  } catch {
+    cachedReader2 = null;
+  }
+  return cachedReader2;
+}
+function readArgMax(call) {
+  const mib = Buffer.alloc(8);
+  mib.writeInt32LE(CTL_KERN, 0);
+  mib.writeInt32LE(KERN_ARGMAX, 4);
+  const value = Buffer.alloc(4);
+  const length = Buffer.alloc(8);
+  length.writeBigUInt64LE(BigInt(value.byteLength));
+  if (call(mib, value, length) !== 0)
+    return DEFAULT_ARG_MAX;
+  const argMax = value.readInt32LE(0);
+  return argMax >= MIN_ARG_MAX && argMax <= MAX_ARG_MAX ? argMax : DEFAULT_ARG_MAX;
+}
+function darwinProcessArgv(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return null;
+  const reader = loadReader2();
+  const buffer = cachedBuffer;
+  if (!reader || !buffer)
+    return null;
+  try {
+    return parseDarwinProcArgs2(buffer, reader(pid, buffer));
+  } catch {
+    return null;
+  }
+}
+var CTL_KERN = 1, KERN_ARGMAX = 8, KERN_PROCARGS2 = 49, ARGC_SIZE = 4, DEFAULT_ARG_MAX, MIN_ARG_MAX, MAX_ARG_MAX, MAX_ARGC = 4096, cachedReader2, cachedBuffer = null;
+var init_darwinArgv = __esm(() => {
+  DEFAULT_ARG_MAX = 1024 * 1024;
+  MIN_ARG_MAX = 4 * 1024;
+  MAX_ARG_MAX = 32 * 1024 * 1024;
+});
+
 // src/lib/accounts/claudeLogin.ts
 import { spawn } from "child_process";
 import crypto7 from "crypto";
@@ -3596,13 +3687,18 @@ function procStartToken(pid) {
     return null;
   }
 }
-async function waitForProcessExit(pid, startToken) {
-  while (procStartToken(pid) === startToken) {
-    await new Promise((resolve) => setTimeout(resolve, 25));
-  }
+function exitPoller(startTokenOf) {
+  return async function waitForProcessExit(pid, startToken) {
+    while (startTokenOf(pid) === startToken) {
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  };
 }
 function isExpectedClaudeLoginCommand(commandLine) {
-  const args = commandLine.split("\x00").filter(Boolean);
+  return isExpectedClaudeLoginArgv(commandLine.split("\x00"));
+}
+function isExpectedClaudeLoginArgv(argv) {
+  const args = argv.filter(Boolean);
   const direct = /(?:^|\/)claude$/.test(args[0] ?? "") && args.length === 4;
   const wrapped = /(?:^|\/)(?:node|bun)$/.test(args[0] ?? "") && /claude/i.test(args[1] ?? "") && args.length === 5;
   const shimmed = /(?:^|\/)(?:sh|dash|bash)$/.test(args[0] ?? "") && /(?:^|\/)claude$/.test(args[1] ?? "") && args.length === 5;
@@ -3616,6 +3712,46 @@ function expectedClaude(pid) {
     return false;
   }
 }
+function sleepThrough(ms) {
+  try {
+    Atomics.wait(execWindowLatch, 0, 0, ms);
+  } catch {
+    const until = Date.now() + ms;
+    while (Date.now() < until) {}
+  }
+}
+function sameArguments(left, right) {
+  return right !== null && left.length === right.length && left.every((entry, index) => entry === right[index]);
+}
+function executedArgv(pid, readers) {
+  if (pid === process.pid)
+    return readers.argv(pid);
+  const forking = readers.argv(process.pid);
+  const deadline = Date.now() + EXEC_WINDOW_MS;
+  for (;; ) {
+    const argv = readers.argv(pid);
+    if (argv !== null && !sameArguments(argv, forking))
+      return argv;
+    if (argv === null && readers.startToken(pid) === null)
+      return null;
+    if (Date.now() >= deadline)
+      return argv;
+    sleepThrough(EXEC_POLL_MS);
+  }
+}
+function identityPortsFrom(readers) {
+  return {
+    pidStartToken: readers.startToken,
+    isExpectedClaude: (pid) => {
+      const argv = executedArgv(pid, readers);
+      return argv !== null && isExpectedClaudeLoginArgv(argv);
+    },
+    waitForExit: exitPoller(readers.startToken)
+  };
+}
+function processIdentityPorts(platform = process.platform, darwin = darwinIdentityReaders) {
+  return platform === "darwin" ? identityPortsFrom(darwin) : { pidStartToken: procStartToken, isExpectedClaude: expectedClaude, waitForExit: exitPoller(procStartToken) };
+}
 function isSupervisedClaudeHome(home) {
   return isManagedClaudeHome(home) || home === legacyClaudeHome();
 }
@@ -4137,10 +4273,12 @@ class ClaudeLoginSupervisor {
 function osHome() {
   return process.env.HOME || "/";
 }
-var OUTPUT_LIMIT, CODE_LIMIT, LOGIN_TIMEOUT_MS, TERM_GRACE_MS = 2000, URL_HOSTS, ANSI, URL_PATTERN, realClaudeLoginPorts, fileClaudeLoginStore, LIVE_CLAUDE_LOGIN_PHASES, defaultClaudeLoginSupervisor, claudeLoginSupervisor;
+var OUTPUT_LIMIT, CODE_LIMIT, LOGIN_TIMEOUT_MS, TERM_GRACE_MS = 2000, URL_HOSTS, ANSI, URL_PATTERN, darwinIdentityReaders, EXEC_WINDOW_MS = 1000, EXEC_POLL_MS = 2, execWindowLatch, realClaudeLoginPorts, fileClaudeLoginStore, LIVE_CLAUDE_LOGIN_PHASES, defaultClaudeLoginSupervisor, claudeLoginSupervisor;
 var init_claudeLogin = __esm(() => {
   init_cli();
   init_configDir();
+  init_darwinArgv();
+  init_darwinIdentity();
   init_accountMutation();
   init_claude();
   OUTPUT_LIMIT = 64 * 1024;
@@ -4149,6 +4287,11 @@ var init_claudeLogin = __esm(() => {
   URL_HOSTS = new Set(["claude.ai", "claude.com", "platform.claude.com", "console.anthropic.com"]);
   ANSI = /\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\))/g;
   URL_PATTERN = /https:\/\/[^\s"'<>]+/g;
+  darwinIdentityReaders = {
+    startToken: darwinProcessIdentity,
+    argv: darwinProcessArgv
+  };
+  execWindowLatch = new Int32Array(new SharedArrayBuffer(4));
   realClaudeLoginPorts = {
     spawn: (command, args, options) => spawn(command, args, options),
     kill: (pid, signal) => {
@@ -4160,9 +4303,7 @@ var init_claudeLogin = __esm(() => {
         } catch {}
       }
     },
-    pidStartToken: procStartToken,
-    isExpectedClaude: expectedClaude,
-    waitForExit: waitForProcessExit,
+    ...processIdentityPorts(),
     status: structuredStatus,
     now: Date.now,
     setTimeout,
@@ -5120,6 +5261,58 @@ function unavailableLimits() {
   return { state: "unavailable", session: null, weekly: null, checkedAt: null };
 }
 
+// src/lib/title.ts
+function compactPath(value) {
+  return value.replace(/(?:\/[^\s)]+){3,}/g, (match) => {
+    if (match.length <= 40)
+      return match;
+    const parts = match.split("/").filter(Boolean);
+    return parts.length >= 2 ? ".../" + parts.slice(-2).join("/") : match;
+  });
+}
+function cleanTitle(value, maxLength = 160) {
+  const stripped = value.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/[*_~#>]+/g, "").replace(/\s+/g, " ").trim();
+  const compacted = compactPath(stripped).replace(/\s+/g, " ").trim();
+  return compacted.length > maxLength ? compacted.slice(0, maxLength - 1).trimEnd() + "\u2026" : compacted;
+}
+function genericSessionTitleKey(value) {
+  return value.toLocaleLowerCase().replace(/[\p{P}\p{S}\s]+/gu, " ").trim();
+}
+function isGenericSessionTitle(value) {
+  return typeof value === "string" && GENERIC_SESSION_TITLES.has(genericSessionTitleKey(value));
+}
+function durableSemanticTitle(value, maxLength = 160) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  const cleaned = cleanTitle(trimmed, maxLength);
+  if (!trimmed || !/[\p{L}\p{N}]/u.test(cleaned) || isGenericSessionTitle(trimmed))
+    return null;
+  return trimmed.length > maxLength ? trimmed.slice(0, maxLength - 1).trimEnd() + "\u2026" : trimmed;
+}
+function semanticTitle(value, maxLength = 160) {
+  const durable = durableSemanticTitle(value, maxLength);
+  return durable ? cleanTitle(durable, maxLength) : null;
+}
+function firstPromptLine(value, maxLength = 60) {
+  const firstLine = value?.split(/\r?\n/, 1)[0] ?? "";
+  return semanticTitle(firstLine, maxLength);
+}
+function derivedSpawnTitle(role, prompt, fallback = "New task") {
+  const semanticRole = typeof role === "string" ? cleanTitle(role, 40) || "agent" : "agent";
+  const semanticPrompt = firstPromptLine(prompt, 60) ?? semanticTitle(fallback, 60) ?? "New task";
+  return cleanTitle(`${semanticRole} \xB7 ${semanticPrompt}`, 120);
+}
+var GENERIC_SESSION_TITLES, SPAWN_TITLE_REQUIRED_ERROR = "title is required for every new spawn";
+var init_title = __esm(() => {
+  GENERIC_SESSION_TITLES = new Set([
+    "codex session",
+    "claude session",
+    "codex",
+    "claude"
+  ]);
+});
+
 // src/lib/accounts/migration/contracts.ts
 function validExplicitProject(value) {
   if (typeof value !== "string")
@@ -5163,6 +5356,12 @@ function emptyLaunchProfile(overrides = {}, policy) {
     plugins: grantedPlugins(overrides.plugins)
   };
 }
+function migrationSuccessorLaunchProfile(profile) {
+  return emptyLaunchProfile({
+    ...profile,
+    title: durableSemanticTitle(profile.title, 120) ?? derivedSpawnTitle("migration successor", profile.goal?.objective ?? profile.cwd, "Conversation migration")
+  });
+}
 function sameProcessIdentity(left, right) {
   return left.pid === right.pid && left.startIdentity === right.startIdentity;
 }
@@ -5182,6 +5381,7 @@ var PROJECT_KEY_PATTERN;
 var init_contracts2 = __esm(() => {
   init_mcpAllowlist();
   init_pluginAllowlist();
+  init_title();
   PROJECT_KEY_PATTERN = /^-?[A-Za-z0-9][A-Za-z0-9._-]{0,126}$/;
 });
 
@@ -5225,6 +5425,403 @@ var init_intentLiveness = __esm(() => {
   COMMITTED_MIGRATION_DELIVERY_REASON = `${MIGRATION_DELIVERY_CANCELLATION_PREFIX} its owning account migration committed; send again to authorize a fresh delivery action`;
 });
 
+// src/lib/agent/identityWaveMigration.ts
+function canonicalConversationId(file, conversationId) {
+  if (!conversationId.startsWith("conversation_"))
+    return null;
+  let current = conversationId;
+  const seen = new Set;
+  while (file.conversationAliases[current] && !seen.has(current)) {
+    seen.add(current);
+    current = file.conversationAliases[current];
+  }
+  return seen.has(current) ? null : current;
+}
+function semanticEvidence(value) {
+  if (typeof value !== "string")
+    return null;
+  const firstNonEmptyLine = value.split(/\r?\n/).find((line) => line.trim());
+  return semanticTitle(firstNonEmptyLine, 120);
+}
+function receiptTitles(file) {
+  const titles = new Map;
+  const byLaunchFirst = Object.values(file.receipts).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).sort((left, right) => Number(right.purpose === "launch") - Number(left.purpose === "launch"));
+  for (const receipt of byLaunchFirst) {
+    const conversationId = canonicalConversationId(file, receipt.conversationId);
+    const title = semanticEvidence(receipt.launchDisplay?.prompt);
+    if (conversationId && title && !titles.has(conversationId))
+      titles.set(conversationId, title);
+  }
+  return titles;
+}
+function placeholderTitle(value) {
+  return typeof value === "string" && semanticTitle(value) === null;
+}
+function newestSemanticConversationTitle(conversation) {
+  for (let index = conversation.generations.length - 1;index >= 0; index -= 1) {
+    const title = durableSemanticTitle(conversation.generations[index].launchProfile.title);
+    if (title)
+      return title;
+  }
+  return null;
+}
+function conversationNeedsTitleCleanup(file, conversation) {
+  if (conversation.generations.some((generation) => placeholderTitle(generation.launchProfile.title)))
+    return true;
+  const ownedPaths = new Set(conversation.generations.map((generation) => generation.path));
+  if (Object.values(file.entries).some((entry) => ownedPaths.has(entry.artifactPath) && placeholderTitle(entry.launchProfile?.title)))
+    return true;
+  return Object.values(file.receipts).some((receipt) => canonicalConversationId(file, receipt.conversationId) === conversation.id && placeholderTitle(receipt.launchProfile.title));
+}
+function safeSharedPath(input, pathname) {
+  try {
+    const candidate = input.sharedPathForLegacy(pathname);
+    if (!candidate)
+      return { kind: "absent" };
+    if (candidate.sharedPath === pathname)
+      return { kind: "absent" };
+    return { kind: "found", value: candidate };
+  } catch (error) {
+    return { kind: "failed", error };
+  }
+}
+function safeTranscriptTitle(input, pathname, engine) {
+  try {
+    const title = semanticEvidence(input.transcriptTitle(pathname, engine));
+    return title ? { kind: "found", value: title } : { kind: "absent" };
+  } catch (error) {
+    return { kind: "failed", error };
+  }
+}
+function evidenceValue(resolution) {
+  if (resolution.kind === "failed")
+    throw resolution.error;
+  return resolution.kind === "found" ? resolution.value : null;
+}
+function resolveConversationEvidence(file, input) {
+  const evidence = new Map;
+  for (const conversation of Object.values(file.conversations)) {
+    const generation = conversation.generations.at(-1);
+    if (!generation)
+      continue;
+    const conversationTitle = newestSemanticConversationTitle(conversation);
+    const needsTitleCleanup = conversationNeedsTitleCleanup(file, conversation);
+    const pathRekeys = conversation.generations.flatMap((ownedGeneration) => {
+      const candidate = evidenceValue(safeSharedPath(input, ownedGeneration.path));
+      return candidate ? [{ legacyPath: ownedGeneration.path, ...candidate }] : [];
+    });
+    evidence.set(conversation.id, { conversationTitle, needsTitleCleanup, pathRekeys, transcriptTitle: null });
+  }
+  return evidence;
+}
+function resolveRekeyOwnership(file, evidence) {
+  const owners = new Map;
+  const generationPaths = new Map;
+  const generationOwners = new Map;
+  const rememberOwner = (map, pathname, conversationId) => {
+    const pathOwners = map.get(pathname) ?? new Set;
+    pathOwners.add(conversationId);
+    map.set(pathname, pathOwners);
+  };
+  for (const conversation of Object.values(file.conversations)) {
+    for (const generation of conversation.generations) {
+      rememberOwner(owners, generation.path, conversation.id);
+      rememberOwner(generationPaths, generation.path, conversation.id);
+      rememberOwner(generationOwners, `${conversation.engine}:${generation.id}`, conversation.id);
+    }
+    for (const pathname of conversation.continuityPaths)
+      rememberOwner(owners, pathname, conversation.id);
+  }
+  for (const receipt of Object.values(file.receipts)) {
+    if (!receipt.artifactPath)
+      continue;
+    rememberOwner(owners, receipt.artifactPath, canonicalConversationId(file, receipt.conversationId) ?? `receipt:${receipt.launchId}`);
+  }
+  for (const entry of Object.values(file.entries)) {
+    const entryOwners = generationOwners.get(`${entry.key.engine}:${entry.key.sessionId}`);
+    if (entryOwners?.size) {
+      for (const conversationId of entryOwners)
+        rememberOwner(owners, entry.artifactPath, conversationId);
+    } else {
+      rememberOwner(owners, entry.artifactPath, `entry:${entry.key.engine}:${entry.key.sessionId}`);
+    }
+  }
+  const targetSources = new Map;
+  const rekeys = [];
+  let quarantined = 0;
+  for (const [conversationId, conversationEvidence] of evidence) {
+    const owned = [];
+    for (const rekey of conversationEvidence.pathRekeys) {
+      if (!rekey.identityEquivalent) {
+        quarantined += 1;
+        continue;
+      }
+      const pathOwners = owners.get(rekey.sharedPath);
+      const sourceOwners = owners.get(rekey.legacyPath);
+      const generationOwners2 = generationPaths.get(rekey.sharedPath);
+      const priorSource = targetSources.get(rekey.sharedPath);
+      if (!sourceOwners || sourceOwners.size !== 1 || !sourceOwners.has(conversationId) || pathOwners && [...pathOwners].some((owner) => owner !== conversationId) || generationOwners2 && rekey.sharedPath !== rekey.legacyPath || priorSource && priorSource !== rekey.legacyPath) {
+        quarantined += 1;
+        continue;
+      }
+      targetSources.set(rekey.sharedPath, rekey.legacyPath);
+      owned.push(rekey);
+      rekeys.push({ legacyPath: rekey.legacyPath, sharedPath: rekey.sharedPath });
+    }
+    conversationEvidence.pathRekeys = owned;
+  }
+  return { rekeys, quarantined };
+}
+function resolveTranscriptEvidence(file, input, titlesByReceipt, evidence) {
+  for (const conversation of Object.values(file.conversations)) {
+    const generation = conversation.generations.at(-1);
+    const conversationEvidence = evidence.get(conversation.id);
+    if (!generation || !conversationEvidence?.needsTitleCleanup || conversationEvidence.conversationTitle !== null || titlesByReceipt.has(conversation.id))
+      continue;
+    const transcriptPath = conversationEvidence.pathRekeys.find((rekey) => rekey.legacyPath === generation.path)?.sharedPath ?? generation.path;
+    conversationEvidence.transcriptTitle = evidenceValue(safeTranscriptTitle(input, transcriptPath, conversation.engine));
+  }
+}
+function rekeyProviderReceipt(receipt, legacyPath, sharedPath) {
+  if (receipt.path === legacyPath)
+    receipt.path = sharedPath;
+  receipt.continuityPaths = [...new Set(receipt.continuityPaths.map((pathname) => pathname === legacyPath ? sharedPath : pathname))];
+}
+function rekeyArtifactReferences(file, legacyPath, sharedPath) {
+  for (const entry of Object.values(file.entries)) {
+    if (entry.artifactPath === legacyPath)
+      entry.artifactPath = sharedPath;
+  }
+  for (const receipt of Object.values(file.receipts)) {
+    if (receipt.artifactPath === legacyPath)
+      receipt.artifactPath = sharedPath;
+    if (receipt.resumeSourcePath === legacyPath)
+      receipt.resumeSourcePath = sharedPath;
+  }
+  for (const edge of Object.values(file.lineageEdges)) {
+    if (edge.childArtifactPath === legacyPath)
+      edge.childArtifactPath = sharedPath;
+    if (edge.parentArtifactPath === legacyPath)
+      edge.parentArtifactPath = sharedPath;
+  }
+  for (const delivery of Object.values(file.heldDeliveries)) {
+    delivery.artifactPaths = [...new Set(delivery.artifactPaths.map((pathname) => pathname === legacyPath ? sharedPath : pathname))];
+  }
+  for (const conversation of Object.values(file.conversations)) {
+    const migration = conversation.migration;
+    if (!migration)
+      continue;
+    if (migration.providerReceipt)
+      rekeyProviderReceipt(migration.providerReceipt, legacyPath, sharedPath);
+    migration.pendingContinuityPaths = [...new Set(migration.pendingContinuityPaths.map((pathname) => pathname === legacyPath ? sharedPath : pathname))];
+  }
+  for (const pending of Object.values(file.pendingSuccessorCleanups)) {
+    rekeyProviderReceipt(pending.receipt, legacyPath, sharedPath);
+  }
+  const resumePane = file.legacyResumePanes.panes[legacyPath];
+  if (resumePane) {
+    file.legacyResumePanes.panes[sharedPath] ??= resumePane;
+    delete file.legacyResumePanes.panes[legacyPath];
+  }
+}
+function stampOrchestratorLineage(file, seat, createdAt) {
+  const conversationId = seat.conversationId ? canonicalConversationId(file, seat.conversationId) : null;
+  const conversation = conversationId ? file.conversations[conversationId] : null;
+  if (!conversationId || !conversation)
+    return { changed: false, engine: null };
+  const predecessorId = seat.predecessorConversationId ? canonicalConversationId(file, seat.predecessorConversationId) : null;
+  const predecessor = predecessorId && predecessorId !== conversationId ? file.conversations[predecessorId] : null;
+  const lineageWouldCycle = predecessorId && predecessor ? wouldCreateLineageCycle(file, conversationId, predecessorId) : false;
+  const lineagePredecessorId = lineageWouldCycle ? null : predecessorId;
+  const lineagePredecessor = lineageWouldCycle ? null : predecessor;
+  const rows = file.memberships[conversationId] ??= [];
+  let changed = false;
+  if (!rows.some((row) => row.kind === "orchestrator" && row.containerId === seat.project && row.slot === `seat:${seat.seatEpoch}`)) {
+    rows.push({
+      conversationId,
+      kind: "orchestrator",
+      containerId: seat.project,
+      role: "orchestrator",
+      slot: `seat:${seat.seatEpoch}`,
+      stageId: null,
+      stageOrder: null,
+      round: null,
+      parentConversationId: lineagePredecessor ? lineagePredecessorId : null,
+      runtime: null,
+      createdAt
+    });
+    changed = true;
+  }
+  if (conversation.agentRole !== "orchestrator") {
+    conversation.agentRole = "orchestrator";
+    changed = true;
+  }
+  if (conversation.delegationDepth !== 0) {
+    conversation.delegationDepth = 0;
+    changed = true;
+  }
+  if (lineagePredecessor && !file.lineageEdges[conversationId]) {
+    const generation = conversation.generations.at(-1);
+    const parentGeneration = lineagePredecessor.generations.at(-1);
+    const edge = {
+      childConversationId: conversationId,
+      parentConversationId: lineagePredecessorId,
+      childSessionKey: generation ? sessionKeyFromTranscript(conversation.engine, generation.path) : null,
+      parentSessionKey: parentGeneration ? sessionKeyFromTranscript(lineagePredecessor.engine, parentGeneration.path) : null,
+      childArtifactPath: generation?.path ?? null,
+      parentArtifactPath: parentGeneration?.path ?? null,
+      kind: "spawn",
+      role: "orchestrator",
+      reviewsConversationId: null,
+      source: "viewer-spawn",
+      evidence: { launchId: null, clientAttemptId: null, parentSource: null },
+      createdAt
+    };
+    file.lineageEdges[conversationId] = edge;
+    changed = true;
+  }
+  if (changed)
+    conversation.updatedAt = createdAt;
+  return { changed, engine: conversation.engine };
+}
+function stampPendingOrchestratorLineage(file, seat) {
+  const conversationId = seat.conversationId ? canonicalConversationId(file, seat.conversationId) : null;
+  if (!conversationId || file.conversations[conversationId])
+    return { changed: false, engine: null };
+  const receipt = Object.values(file.receipts).find((candidate) => canonicalConversationId(file, candidate.conversationId) === conversationId);
+  if (!receipt)
+    return { changed: false, engine: null };
+  const pending = {
+    project: seat.project,
+    seatEpoch: seat.seatEpoch,
+    conversationId,
+    predecessorConversationId: seat.predecessorConversationId ? canonicalConversationId(file, seat.predecessorConversationId) : null,
+    designatedAt: seat.designatedAt,
+    activatedAt: seat.activatedAt,
+    path: seat.path ?? null
+  };
+  if (JSON.stringify(receipt.pendingOrchestratorSeatIdentity) === JSON.stringify(pending)) {
+    return { changed: false, engine: receipt.engine };
+  }
+  receipt.pendingOrchestratorSeatIdentity = pending;
+  return { changed: true, engine: receipt.engine };
+}
+function wouldCreateLineageCycle(file, childConversationId, parentConversationId) {
+  const visited = new Set;
+  let cursor = parentConversationId;
+  while (cursor) {
+    if (cursor === childConversationId || visited.has(cursor))
+      return true;
+    visited.add(cursor);
+    const parent = file.lineageEdges[cursor]?.parentConversationId;
+    cursor = parent ? canonicalConversationId(file, parent) : null;
+  }
+  return false;
+}
+function applyIdentityWaveMigration(source, input) {
+  const dryRun = input.dryRun === true;
+  const file = dryRun ? structuredClone(source) : source;
+  if (file.identityMigrations[IDENTITY_WAVE_MIGRATION]) {
+    return { dryRun, alreadyCompleted: true, retitled: 0, rekeyed: 0, quarantinedRekeys: 0, edgesStamped: 0 };
+  }
+  const titlesByReceipt = receiptTitles(file);
+  const evidenceByConversation = resolveConversationEvidence(file, input);
+  const ownership = resolveRekeyOwnership(file, evidenceByConversation);
+  resolveTranscriptEvidence(file, input, titlesByReceipt, evidenceByConversation);
+  if (!dryRun && ownership.rekeys.length > 0) {
+    input.commitExternalPathRekeys?.(ownership.rekeys);
+  }
+  const changedEngines = new Set;
+  let retitled = 0;
+  let rekeyed = 0;
+  let edgesStamped = 0;
+  for (const conversation of Object.values(file.conversations)) {
+    const generation = conversation.generations.at(-1);
+    if (!generation)
+      continue;
+    let conversationChanged = false;
+    const evidence = evidenceByConversation.get(conversation.id);
+    const pathRekeys = evidence?.pathRekeys ?? [];
+    if (pathRekeys.length > 0) {
+      for (const { legacyPath, sharedPath } of pathRekeys) {
+        if (!conversation.continuityPaths.includes(legacyPath))
+          conversation.continuityPaths.push(legacyPath);
+        conversation.continuityPaths = conversation.continuityPaths.filter((pathname) => pathname !== sharedPath);
+        for (const ownedGeneration of conversation.generations) {
+          if (ownedGeneration.path === legacyPath)
+            ownedGeneration.path = sharedPath;
+        }
+        rekeyArtifactReferences(file, legacyPath, sharedPath);
+      }
+      rekeyed += 1;
+      conversationChanged = true;
+    }
+    if (evidence?.needsTitleCleanup) {
+      const replacement = evidence.conversationTitle ?? titlesByReceipt.get(conversation.id) ?? evidence?.transcriptTitle ?? null;
+      for (const ownedGeneration of conversation.generations) {
+        if (placeholderTitle(ownedGeneration.launchProfile.title)) {
+          ownedGeneration.launchProfile.title = replacement;
+        }
+      }
+      const ownedPaths = new Set(conversation.generations.map((ownedGeneration) => ownedGeneration.path));
+      for (const entry of Object.values(file.entries)) {
+        if (ownedPaths.has(entry.artifactPath) && entry.launchProfile && placeholderTitle(entry.launchProfile.title)) {
+          entry.launchProfile.title = replacement;
+        }
+      }
+      for (const receipt of Object.values(file.receipts)) {
+        if (canonicalConversationId(file, receipt.conversationId) === conversation.id && placeholderTitle(receipt.launchProfile.title)) {
+          receipt.launchProfile.title = replacement;
+          if (replacement)
+            receipt.identityWaveTitleBackfill = true;
+        }
+      }
+      if (replacement)
+        retitled += 1;
+      conversationChanged = true;
+    }
+    if (conversationChanged) {
+      conversation.updatedAt = input.now;
+      changedEngines.add(conversation.engine);
+    }
+  }
+  for (const seat of input.orchestratorSeats) {
+    const stamped = stampOrchestratorLineage(file, seat, seat.activatedAt ?? seat.designatedAt ?? input.now);
+    const pending = stamped.engine ? { changed: false, engine: null } : stampPendingOrchestratorLineage(file, seat);
+    const changed = stamped.changed || pending.changed;
+    const engine = stamped.engine ?? pending.engine;
+    if (!changed || !engine)
+      continue;
+    edgesStamped += 1;
+    changedEngines.add(engine);
+  }
+  for (const engine of changedEngines) {
+    file.conversationRevision[engine] += 1;
+  }
+  if (!dryRun) {
+    file.identityMigrations[IDENTITY_WAVE_MIGRATION] = {
+      completedAt: input.now,
+      retitled,
+      rekeyed,
+      quarantinedRekeys: ownership.quarantined,
+      edgesStamped
+    };
+  }
+  return {
+    dryRun,
+    alreadyCompleted: false,
+    retitled,
+    rekeyed,
+    quarantinedRekeys: ownership.quarantined,
+    edgesStamped
+  };
+}
+var IDENTITY_WAVE_MIGRATION = "identity-wave-a-d-913";
+var init_identityWaveMigration = __esm(() => {
+  init_sessionKey();
+  init_title();
+});
+
 // src/lib/agent/accountLiveness.ts
 function futureRetryAt(value, now) {
   if (!value)
@@ -6455,6 +7052,7 @@ var init_sqliteRegistryStore = __esm(() => {
   META_FIELDS = [
     "importedResumePanes",
     "legacyResumePanes",
+    "identityMigrations",
     "conversationRevision",
     "engineRouting",
     "autoBalance",
@@ -6693,7 +7291,7 @@ function mergeResumeLaunchProfile(current, requested) {
     allowSubagents: current.allowSubagents || requested.allowSubagents,
     mcpServers: current.mcpServers,
     plugins: current.plugins ?? [],
-    title: requested.title ?? current.title,
+    title: durableSemanticTitle(current.title) ?? durableSemanticTitle(requested.title),
     project: requested.project ?? current.project,
     parentConversationId: requested.parentConversationId ?? current.parentConversationId,
     role: current.role === "root" || requested.role === "root" ? "root" : "worker",
@@ -6757,6 +7355,7 @@ function conversationMigrationForIntent(conversation, source, intent, phase, cha
     errorCode: null,
     operationId: crypto9.randomUUID(),
     sourceGenerationId: source.id,
+    successorLaunchProfile: null,
     providerReceipt: null,
     pendingContinuityPaths,
     boardProject,
@@ -6999,7 +7598,7 @@ function normalizeMemberships(value) {
       if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
         return [];
       const row = candidate;
-      if (row.kind !== "flow" && row.kind !== "pipeline" || typeof row.containerId !== "string" || !row.containerId || typeof row.role !== "string" || !row.role || typeof row.slot !== "string" || !row.slot)
+      if (row.kind !== "flow" && row.kind !== "pipeline" && row.kind !== "orchestrator" || typeof row.containerId !== "string" || !row.containerId || typeof row.role !== "string" || !row.role || typeof row.slot !== "string" || !row.slot)
         return [];
       const runtime2 = row.runtime && typeof row.runtime === "object" && (row.runtime.engine === "claude" || row.runtime.engine === "codex") ? {
         engine: row.runtime.engine,
@@ -7025,6 +7624,25 @@ function normalizeMemberships(value) {
   }
   return normalized;
 }
+function normalizeIdentityMigrations(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).flatMap(([key2, candidate]) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate))
+      return [];
+    const marker = candidate;
+    const quarantinedRekeys = marker.quarantinedRekeys ?? 0;
+    if (typeof marker.completedAt !== "string" || !Number.isSafeInteger(marker.retitled) || marker.retitled < 0 || !Number.isSafeInteger(marker.rekeyed) || marker.rekeyed < 0 || !Number.isSafeInteger(quarantinedRekeys) || quarantinedRekeys < 0 || !Number.isSafeInteger(marker.edgesStamped) || marker.edgesStamped < 0)
+      return [];
+    return [[key2, {
+      completedAt: marker.completedAt,
+      retitled: marker.retitled,
+      rekeyed: marker.rekeyed,
+      quarantinedRekeys,
+      edgesStamped: marker.edgesStamped
+    }]];
+  }));
+}
 function normalizeProviderReceipt(value) {
   if (!value || typeof value !== "object")
     return null;
@@ -7064,12 +7682,14 @@ function normalizeConversation(value, policy) {
   const current = generations.at(-1);
   const legacyContinuity = value.migration?.continuityPaths;
   const providerReceipt = normalizeProviderReceipt(value.migration?.providerReceipt);
+  const successorLaunchProfile = value.migration?.successorLaunchProfile && typeof value.migration.successorLaunchProfile === "object" && !Array.isArray(value.migration.successorLaunchProfile) ? emptyLaunchProfile(value.migration.successorLaunchProfile, policy) : null;
   const pendingContinuityPaths = Array.isArray(value.migration?.pendingContinuityPaths) ? value.migration.pendingContinuityPaths.filter((pathname) => typeof pathname === "string") : value.migration?.phase !== "committed" && providerReceipt ? [...new Set([...providerReceipt.continuityPaths, providerReceipt.path])] : [];
   const migration = value.migration && typeof value.migration === "object" ? {
     ...value.migration,
     errorCode: value.migration.errorCode ?? null,
     operationId: value.migration.operationId ?? `${value.migration.intentId}:${value.id}:${value.migration.revision}`,
     sourceGenerationId: value.migration.sourceGenerationId ?? current?.id ?? "",
+    successorLaunchProfile,
     providerReceipt,
     pendingContinuityPaths,
     boardProject: typeof value.migration.boardProject === "string" ? value.migration.boardProject : null,
@@ -7671,13 +8291,13 @@ function commitPendingSupersedenceInFile(file) {
   }
 }
 function recordMembership(file, conversationId, input, createdAt) {
-  if (input.kind !== "flow" && input.kind !== "pipeline" || !input.containerId.trim() || !input.role.trim() || !input.slot.trim()) {
+  if (input.kind !== "flow" && input.kind !== "pipeline" && input.kind !== "orchestrator" || !input.containerId.trim() || !input.role.trim() || !input.slot.trim()) {
     throw new Error("durable membership is invalid");
   }
-  const canonicalConversationId = resolveConversationAlias(file, conversationId);
+  const canonicalConversationId2 = resolveConversationAlias(file, conversationId);
   const parentConversationId = input.parentConversationId ? resolveConversationAlias(file, input.parentConversationId) : null;
   const membership = {
-    conversationId: canonicalConversationId,
+    conversationId: canonicalConversationId2,
     kind: input.kind,
     containerId: input.containerId,
     role: input.role,
@@ -7689,7 +8309,7 @@ function recordMembership(file, conversationId, input, createdAt) {
     runtime: input.runtime ? { ...input.runtime } : null,
     createdAt
   };
-  const rows = file.memberships[canonicalConversationId] ?? [];
+  const rows = file.memberships[canonicalConversationId2] ?? [];
   const existing = rows.find((row) => row.kind === membership.kind && row.containerId === membership.containerId && row.slot === membership.slot);
   if (existing) {
     const immutableShape = ({ createdAt: createdAt2, ...row }) => {
@@ -7701,9 +8321,38 @@ function recordMembership(file, conversationId, input, createdAt) {
     return existing;
   }
   rows.push(membership);
-  file.memberships[canonicalConversationId] = rows;
+  file.memberships[canonicalConversationId2] = rows;
   return membership;
 }
+function readOnlyConversationLookupFromSnapshot(snapshot2) {
+  return snapshotConversationLookup(snapshot2, (conversation) => conversation);
+}
+function snapshotConversationLookup(snapshot2, materialize) {
+  const byPath = new Map;
+  for (const conversation of Object.values(snapshot2.conversations)) {
+    for (const generation of conversation.generations) {
+      if (!byPath.has(generation.path))
+        byPath.set(generation.path, conversation);
+    }
+    for (const pathname of conversation.continuityPaths) {
+      if (!byPath.has(pathname))
+        byPath.set(pathname, conversation);
+    }
+  }
+  return {
+    conversationForPath(artifactPath) {
+      const conversation = byPath.get(artifactPath);
+      return conversation ? materialize(conversation) : null;
+    },
+    canonicalConversationId(id) {
+      return resolveConversationAlias(snapshot2, id);
+    },
+    conversation(id) {
+      const conversation = snapshot2.conversations[resolveConversationAlias(snapshot2, id)];
+      return conversation ? materialize(conversation) : null;
+    }
+  };
+}
 function adoptProvisionalOwner(file, owner, target, pathname) {
   if (!scannerAllocatedProvisionalOwner(owner, pathname))
     return false;
@@ -7895,6 +8544,22 @@ function normalizeQueuedPinnedSpawn(value, policy) {
     pipelineSourceConversationId: typeof candidate.pipelineSourceConversationId === "string" && candidate.pipelineSourceConversationId.startsWith("conversation_") ? candidate.pipelineSourceConversationId : null
   };
 }
+function normalizePendingOrchestratorSeatIdentity(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const seat = value;
+  if (typeof seat.project !== "string" || !seat.project || !Number.isInteger(seat.seatEpoch) || (seat.seatEpoch ?? 0) < 1 || typeof seat.conversationId !== "string" || !seat.conversationId.startsWith("conversation_") || seat.predecessorConversationId !== null && typeof seat.predecessorConversationId !== "string" || typeof seat.designatedAt !== "string" || seat.activatedAt !== null && typeof seat.activatedAt !== "string")
+    return null;
+  return {
+    project: seat.project,
+    seatEpoch: seat.seatEpoch,
+    conversationId: seat.conversationId,
+    predecessorConversationId: seat.predecessorConversationId ?? null,
+    designatedAt: seat.designatedAt,
+    activatedAt: seat.activatedAt ?? null,
+    path: typeof seat.path === "string" ? seat.path : null
+  };
+}
 function normalizeReceipt(value, policy) {
   const state = value.state === "completed" || value.state === "failed" || value.state === "pane-bound" || value.state === "host-verified" || value.state === "prompt-delivered" || value.state === "path-pending" || value.state === "conflicted" ? value.state : "starting";
   const pane = value.pane && typeof value.pane === "object" && typeof value.pane.paneId === "string" && typeof value.pane.target === "string" ? { ...value.pane, display: typeof value.pane.display === "string" ? value.pane.display : value.pane.target, target: value.pane.paneId } : null;
@@ -7902,6 +8567,8 @@ function normalizeReceipt(value, policy) {
     ...value,
     clientAttemptId: typeof value.clientAttemptId === "string" ? value.clientAttemptId : null,
     requestDigest: typeof value.requestDigest === "string" ? value.requestDigest : null,
+    ...value.identityWaveTitleBackfill === true ? { identityWaveTitleBackfill: true } : {},
+    pendingOrchestratorSeatIdentity: normalizePendingOrchestratorSeatIdentity(value.pendingOrchestratorSeatIdentity),
     transport: value.transport === "tmux" || value.transport === "structured" ? value.transport : null,
     admissionOwner: value.admissionOwner && Number.isInteger(value.admissionOwner.pid) && value.admissionOwner.pid > 0 ? {
       pid: value.admissionOwner.pid,
@@ -8040,6 +8707,7 @@ function normalizeRegistry2(value, policy) {
     receipts: Object.fromEntries(Object.entries(parsed.receipts).map(([id, receipt]) => [id, normalizeReceipt(receipt, policy)])),
     lineageEdges: parsed.lineageEdges && typeof parsed.lineageEdges === "object" ? Object.fromEntries(Object.entries(parsed.lineageEdges).map(([id, edge]) => [id, normalizeLineageEdge(edge)])) : {},
     memberships: normalizeMemberships(parsed.memberships),
+    identityMigrations: normalizeIdentityMigrations(parsed.identityMigrations),
     importedResumePanes: parsed.importedResumePanes === true,
     legacyResumePanes: legacy && typeof legacy === "object" && "panes" in legacy ? { serverPid: typeof legacy.serverPid === "number" ? legacy.serverPid : null, panes: legacy.panes ?? {} } : { serverPid: null, panes: {} },
     conversations: parsed.conversations && typeof parsed.conversations === "object" ? Object.fromEntries(Object.entries(parsed.conversations).map(([id, conversation]) => [id, normalizeConversation(conversation, policy)])) : {},
@@ -8779,8 +9447,22 @@ class AgentRegistry {
       if (sqlite && !changed)
         this.assertSqliteParity();
       if (sqlite && changed) {
-        this.beforeDualWriteMutationReplace?.();
-        const replacement = this.sqliteStore.replace(file, sqlite.revision);
+        let replacement;
+        try {
+          this.beforeDualWriteMutationReplace?.();
+          replacement = this.sqliteStore.replace(file, sqlite.revision);
+        } catch (error) {
+          const durableSqlite = this.sqliteStore.snapshot();
+          if (durableSqlite.revision === sqlite.revision) {
+            if (original.payload === null)
+              writeAtomic(this.filename, original.file, sqlite.revision);
+            else
+              writeAtomicPayload(this.filename, original.payload);
+          } else {
+            this.mirrorSqliteSnapshot(durableSqlite);
+          }
+          throw error;
+        }
         if (!replacement.replaced) {
           this.mirrorSqliteSnapshot(replacement);
           throw new RegistryParityError(`agent registry SQLite revision changed during dual-write mutation: expected ${sqlite.revision}, current ${replacement.revision}`);
@@ -8895,9 +9577,11 @@ class AgentRegistry {
           throw new Error("a conversation cannot supersede itself");
       }
       const existingConversation = conversationId ? file.conversations[conversationId] : null;
+      const requestedTitle = input.launchProfile?.title;
       const requestedProfile = emptyLaunchProfile({
         cwd: input.cwd,
         ...input.launchProfile ?? {},
+        title: durableSemanticTitle(requestedTitle),
         ...explicitProject ? { project: explicitProject } : {},
         parentConversationId
       });
@@ -8916,10 +9600,39 @@ class AgentRegistry {
       if (input.clientAttemptId) {
         const existing = Object.values(file.receipts).find((receipt2) => receipt2.clientAttemptId === input.clientAttemptId);
         if (existing) {
-          const compatible = existing.requestDigest === (input.requestDigest ?? null) && existing.engine === input.engine && existing.cwd === input.cwd && existing.transport === (input.transport ?? null) && existing.accountPin === (input.accountPin === true) && existing.explicitProject === explicitProject && (existing.supersedes?.conversationId ?? null) === supersedes && existing.launchProfile.permissionMode === profile.permissionMode;
+          const existingTitle = durableSemanticTitle(existing.launchProfile.title);
+          const requestedTitle2 = durableSemanticTitle(profile.title);
+          const titleCompatible = !existingTitle || !requestedTitle2 || existingTitle === requestedTitle2;
+          const compatible = existing.requestDigest === (input.requestDigest ?? null) && existing.engine === input.engine && existing.cwd === input.cwd && existing.transport === (input.transport ?? null) && existing.accountPin === (input.accountPin === true) && existing.explicitProject === explicitProject && (existing.supersedes?.conversationId ?? null) === supersedes && existing.launchProfile.permissionMode === profile.permissionMode && titleCompatible;
+          if (compatible && !existingTitle && requestedTitle2) {
+            existing.launchProfile.title = requestedTitle2;
+            const existingConversationId = resolveConversationAlias(file, existing.conversationId);
+            const titledConversation = file.conversations[existingConversationId];
+            if (titledConversation) {
+              const ownedPaths = new Set(titledConversation.generations.map((generation) => generation.path));
+              for (const generation of titledConversation.generations) {
+                if (!durableSemanticTitle(generation.launchProfile.title))
+                  generation.launchProfile.title = requestedTitle2;
+              }
+              for (const entry of Object.values(file.entries)) {
+                if (ownedPaths.has(entry.artifactPath) && entry.launchProfile && !durableSemanticTitle(entry.launchProfile.title)) {
+                  entry.launchProfile.title = requestedTitle2;
+                }
+              }
+              for (const receipt2 of Object.values(file.receipts)) {
+                if (resolveConversationAlias(file, receipt2.conversationId) === existingConversationId && !durableSemanticTitle(receipt2.launchProfile.title)) {
+                  receipt2.launchProfile.title = requestedTitle2;
+                }
+              }
+              titledConversation.updatedAt = now();
+              file.conversationRevision[titledConversation.engine] += 1;
+            }
+          }
           return { kind: compatible ? "replay" : "conflict", receipt: clone(existing) };
         }
       }
+      if (!durableSemanticTitle(profile.title))
+        throw new Error(SPAWN_TITLE_REQUIRED_ERROR);
       const purpose = input.purpose ?? "launch";
       const successorIdentity = purpose !== "launch" || input.origin?.kind === "successor";
       const resolvedOrigin = !successorIdentity && input.origin ? resolveSpawnOrigin(file, input.origin) : null;
@@ -8979,6 +9692,7 @@ class AgentRegistry {
         launchId: crypto9.randomUUID(),
         clientAttemptId: input.clientAttemptId ?? null,
         requestDigest: input.requestDigest ?? null,
+        pendingOrchestratorSeatIdentity: null,
         transport: input.transport ?? null,
         admissionOwner: input.transport === "structured" || input.ownStartingActuation === true ? { pid: process.pid, startIdentity: procBackend.processIdentity(process.pid) } : null,
         spawnCapabilityDigest: typeof input.spawnCapabilityDigest === "string" && /^[0-9a-f]{64}$/.test(input.spawnCapabilityDigest) ? input.spawnCapabilityDigest : null,
@@ -9147,6 +9861,29 @@ class AgentRegistry {
   rememberMembership(conversationId, membership) {
     return this.mutate((file) => clone(recordMembership(file, conversationId, membership, now())));
   }
+  runIdentityWaveMigration(input) {
+    if (input.dryRun) {
+      return applyIdentityWaveMigration(clone(this.readOnlySnapshot()), { ...input, dryRun: true });
+    }
+    return withAccountMutationLock(() => this.mutate((file) => applyIdentityWaveMigration(file, input)));
+  }
+  stampOrchestratorSeatIdentity(seat) {
+    return this.mutate((file) => {
+      const stamped = stampOrchestratorLineage(file, seat, seat.activatedAt ?? seat.designatedAt);
+      if (stamped.changed && stamped.engine)
+        file.conversationRevision[stamped.engine] += 1;
+      if (stamped.engine)
+        return stamped.changed;
+      const receipt = Object.values(file.receipts).find((candidate) => candidate.conversationId === seat.conversationId);
+      if (!receipt)
+        return false;
+      const pending = normalizePendingOrchestratorSeatIdentity(seat);
+      if (!pending || isDeepStrictEqual2(receipt.pendingOrchestratorSeatIdentity, pending))
+        return false;
+      receipt.pendingOrchestratorSeatIdentity = pending;
+      return true;
+    });
+  }
   beginSpawn(engine, cwd, launchProfile = {}) {
     const result2 = this.beginSpawnRequest({ engine, cwd, launchProfile });
     if (result2.kind !== "created")
@@ -9405,6 +10142,13 @@ class AgentRegistry {
       file.conversationRevision[conversation.engine] += 1;
       file.engineRouting[conversation.engine].revision += 1;
     }
+    const settledGeneration = conversation.generations.find((generation) => generation.path === entry.artifactPath);
+    const receiptTitle = durableSemanticTitle(receipt.launchProfile.title, 120);
+    if (settledGeneration && receiptTitle && !durableSemanticTitle(settledGeneration.launchProfile.title, 120)) {
+      settledGeneration.launchProfile.title = receiptTitle;
+      file.conversationRevision[conversation.engine] += 1;
+      file.engineRouting[conversation.engine].revision += 1;
+    }
     const activeIntent = Object.values(file.migrationIntents).find((intent) => intent.engine === conversation.engine && engineScopedIntent(intent) && migrationIntentCanEnroll(file, intent, Date.parse(createdAt)));
     const source = conversation.generations.at(-1);
     if (activeIntent && !conversation.pinnedAccountId && source && source.accountId !== activeIntent.targetId && !conversation.migration) {
@@ -9417,6 +10161,7 @@ class AgentRegistry {
         errorCode: null,
         operationId: crypto9.randomUUID(),
         sourceGenerationId: source.id,
+        successorLaunchProfile: null,
         providerReceipt: null,
         pendingContinuityPaths: [],
         boardProject: null,
@@ -9436,6 +10181,13 @@ class AgentRegistry {
     file.entries[sessionKeyId(entry.key)] = full;
     receipt.key = entry.key;
     receipt.artifactPath = entry.artifactPath;
+    if (receipt.pendingOrchestratorSeatIdentity) {
+      const pendingSeat = receipt.pendingOrchestratorSeatIdentity;
+      const stamped = stampOrchestratorLineage(file, pendingSeat, pendingSeat.activatedAt ?? pendingSeat.designatedAt);
+      receipt.pendingOrchestratorSeatIdentity = null;
+      if (stamped.changed && stamped.engine)
+        file.conversationRevision[stamped.engine] += 1;
+    }
     const lineage = file.lineageEdges[receipt.conversationId];
     if (lineage) {
       lineage.childSessionKey = entry.key;
@@ -9727,12 +10479,15 @@ class AgentRegistry {
       return clone(entry);
     });
   }
-  terminateStructuredHost(key2) {
+  terminateStructuredHost(key2, expected) {
     return this.mutate((file) => {
       const keyId = sessionKeyId(key2);
       const entry = file.entries[keyId];
       if (!entry)
         return false;
+      const current = entry.structuredHost?.process ?? null;
+      if (expected && current && (current.pid !== expected.pid || current.startIdentity !== expected.startIdentity))
+        return false;
       const replacement = {
         ...entry,
         host: null,
@@ -10107,7 +10862,10 @@ class AgentRegistry {
               id: nativeGenerationId(observation.path),
               path: observation.path,
               accountId: observation.accountId,
-              launchProfile: emptyLaunchProfile(observation.launchProfile),
+              launchProfile: emptyLaunchProfile({
+                ...observation.launchProfile,
+                title: durableSemanticTitle(observation.launchProfile.title)
+              }),
               historyHash: null,
               host: null,
               createdAt,
@@ -10152,7 +10910,7 @@ class AgentRegistry {
           permissionMode: generation.launchProfile.permissionMode ?? observation.launchProfile.permissionMode,
           readOnly: generation.launchProfile.readOnly ?? observation.launchProfile.readOnly,
           mcpServers: generation.launchProfile.mcpServers,
-          title: generation.launchProfile.title ?? observation.launchProfile.title,
+          title: durableSemanticTitle(generation.launchProfile.title) ?? durableSemanticTitle(observation.launchProfile.title),
           project: observation.launchProfile.project ?? generation.launchProfile.project,
           parentConversationId: lineage?.source === "viewer-spawn" ? lineage.parentConversationId : observedParentConversationId ?? generation.launchProfile.parentConversationId,
           role: generation.launchProfile.role === "root" || observation.launchProfile.role === "root" ? "root" : "worker",
@@ -10668,6 +11426,7 @@ class AgentRegistry {
         errorCode: migration.errorCode ?? null,
         operationId: migration.operationId ?? `${migration.intentId}:${canonicalId3}:${migration.revision}`,
         sourceGenerationId: migration.sourceGenerationId ?? source?.id ?? "",
+        successorLaunchProfile: migration.successorLaunchProfile ?? null,
         providerReceipt: migration.providerReceipt ?? null,
         pendingContinuityPaths: migration.pendingContinuityPaths ?? [],
         boardProject: migration.boardProject ?? null,
@@ -10809,6 +11568,7 @@ class AgentRegistry {
         revision: intent.revision,
         operationId: current.errorCode === "codex-fork-outcome-unknown" || current.revision === intent.revision ? current.operationId : crypto9.randomUUID(),
         sourceGenerationId: source.id,
+        successorLaunchProfile: current.revision === intent.revision ? current.successorLaunchProfile ?? null : null,
         providerReceipt: null,
         pendingContinuityPaths: current.phase === "committed" ? [] : current.pendingContinuityPaths,
         boardProject: current.boardProject,
@@ -11347,9 +12107,11 @@ var STRUCTURED_CLAIM_PREFIX = "structured-host:", SpawnChildLimitError, Supersed
 var init_registry = __esm(() => {
   init_configDir();
   init_proc();
+  init_title();
   init_accountMutation();
   init_contracts2();
   init_intentLiveness();
+  init_identityWaveMigration();
   init_mcpAllowlist();
   init_accountLiveness();
   init_nestingPolicy();
@@ -11405,6 +12167,7 @@ var init_registry = __esm(() => {
     receipts: {},
     lineageEdges: {},
     memberships: {},
+    identityMigrations: {},
     importedResumePanes: false,
     legacyResumePanes: { serverPid: null, panes: {} },
     conversations: {},
@@ -13403,8 +14166,10 @@ function projectIdentityFromDirectory(cwd) {
   if (!base || resolved === path24.sep)
     return null;
   const displayName = resolved === os7.homedir() ? `home-${base}` : base;
-  const digest = crypto12.createHash("sha256").update(`dir:${resolved}`).digest("hex").slice(0, 32);
-  return { project: `dir-${digest}`, displayName };
+  return { project: directoryProjectId(resolved), displayName };
+}
+function directoryProjectId(resolvedPath) {
+  return `dir-${crypto12.createHash("sha256").update(`dir:${resolvedPath}`).digest("hex").slice(0, 32)}`;
 }
 function displayNameFromProjectIdentity(project) {
   if (project === UNRESOLVED_PROJECT)
@@ -14448,11 +15213,26 @@ function claudeTasksRoot() {
     return legacyCandidate;
   return tmpdirCandidate;
 }
+function openclawStateDir() {
+  const configured = process.env.OPENCLAW_STATE_DIR?.trim();
+  return configured ? path27.resolve(configured) : path27.join(os8.homedir(), ".openclaw");
+}
+function openclawSessionRoots() {
+  const agents = path27.join(openclawStateDir(), "agents");
+  let entries;
+  try {
+    entries = fs28.readdirSync(agents, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) && !entry.name.startsWith(".")).map((entry) => path27.join(agents, entry.name, "sessions")).sort();
+}
 function scanRootEntries() {
   const entries = [
     ...codexSessionRoots().map((root) => ["codex-sessions", root]),
     ...claudeProjectRoots().map((root) => ["claude-projects", root]),
-    ["claude-tasks", ROOTS["claude-tasks"]]
+    ["claude-tasks", ROOTS["claude-tasks"]],
+    ...openclawSessionRoots().map((root) => ["openclaw-sessions", root])
   ];
   const seen = new Set;
   return entries.filter(([, root]) => {
@@ -14498,7 +15278,8 @@ var init_roots = __esm(() => {
   ROOTS = {
     "codex-sessions": path27.join(HOME, ".codex/sessions"),
     "claude-projects": path27.join(HOME, ".claude/projects"),
-    "claude-tasks": claudeTasksRoot()
+    "claude-tasks": claudeTasksRoot(),
+    "openclaw-sessions": path27.join(HOME, ".openclaw/agents")
   };
   EXTS = [".log", ".jsonl", ".output", ".txt"];
   MAX_CHUNK = 768 * 1024;
@@ -14512,6 +15293,12 @@ var init_spawnParent = __esm(() => {
   init_roots();
 });
 
+// src/lib/board/types.ts
+var DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES = 120, MAX_BOARD_IDLE_COLLAPSE_MINUTES;
+var init_types2 = __esm(() => {
+  MAX_BOARD_IDLE_COLLAPSE_MINUTES = 30 * 24 * 60;
+});
+
 // src/lib/board/keys.ts
 function resolveThrough(pathname, aliases) {
   const seen = new Set;
@@ -14570,11 +15357,15 @@ function boardKeysChanged(before, after) {
     keys.add(VIEW_MODE_KEY);
   if (before.prefs.taskPanelOpen !== after.prefs.taskPanelOpen)
     keys.add(TASK_PANEL_KEY);
+  const beforeIdle = before.prefs.idleCollapseMinutes === undefined ? DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES : before.prefs.idleCollapseMinutes;
+  const afterIdle = after.prefs.idleCollapseMinutes === undefined ? DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES : after.prefs.idleCollapseMinutes;
+  if (beforeIdle !== afterIdle)
+    keys.add(IDLE_COLLAPSE_KEY);
   return keys;
 }
 function liveBoardKeys(board) {
   const aliases = board.pathAliases ?? {};
-  const keys = new Set([VIEW_MODE_KEY, TASK_PANEL_KEY]);
+  const keys = new Set([VIEW_MODE_KEY, TASK_PANEL_KEY, IDLE_COLLAPSE_KEY]);
   for (const canonical of canonicalPlacements(board, aliases).keys())
     keys.add(pathKey(canonical));
   for (const id of board.prefs.favorites ?? [])
@@ -14625,12 +15416,17 @@ function stampKeyRevisions(before, after, revision, inherited = []) {
   }
   return { keyRevisions, keyRevisionFloor };
 }
-var VIEW_MODE_KEY = "viewMode", TASK_PANEL_KEY = "taskPanelOpen", PATH_PREFIX = "path:", pathKey = (pathname) => `${PATH_PREFIX}${pathname}`, favoriteKey = (id) => `favorite:${id}`, foldKey = (id) => `fold:${id}`, trayKey = (parentId) => `tray:${parentId}`, ROLE_RANK, MAX_RETIRED_KEY_REVISIONS = 512;
+var VIEW_MODE_KEY = "viewMode", TASK_PANEL_KEY = "taskPanelOpen", IDLE_COLLAPSE_KEY = "idleCollapseMinutes", PATH_PREFIX = "path:", pathKey = (pathname) => `${PATH_PREFIX}${pathname}`, favoriteKey = (id) => `favorite:${id}`, foldKey = (id) => `fold:${id}`, trayKey = (parentId) => `tray:${parentId}`, ROLE_RANK, MAX_RETIRED_KEY_REVISIONS = 512;
 var init_keys = __esm(() => {
+  init_types2();
   ROLE_RANK = { absent: 0, manual: 1, pinned: 2, expanded: 3, hidden: 4 };
 });
 
 // src/lib/board/mutations.ts
+function boundedSeenAt(stamps) {
+  const entries = Object.entries(stamps).sort((left, right) => right[1] - left[1]);
+  return Object.fromEntries(entries.slice(0, MAX_SEEN_STAMPS));
+}
 function unique(paths) {
   return [...new Set(paths)];
 }
@@ -14675,7 +15471,9 @@ function normalize2(board, aliases = aliasesOf(board)) {
       expanded: visible(board.prefs.expanded),
       favorites: unique(board.prefs.favorites ?? []),
       foldedEngineChildIds: unique(board.prefs.foldedEngineChildIds ?? []),
-      expandedEngineTrayParentIds: unique(board.prefs.expandedEngineTrayParentIds ?? [])
+      expandedEngineTrayParentIds: unique(board.prefs.expandedEngineTrayParentIds ?? []),
+      seenAt: boundedSeenAt(board.prefs.seenAt ?? {}),
+      idleCollapseMinutes: board.prefs.idleCollapseMinutes === undefined ? DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES : board.prefs.idleCollapseMinutes
     }
   };
 }
@@ -14765,6 +15563,12 @@ function applyBoardMutations(board, mutations) {
       next = normalize2({ ...next, prefs: { ...next.prefs, favorites } });
       continue;
     }
+    if (mutation.kind === "mark-seen") {
+      const current = next.prefs.seenAt ?? {};
+      const at = Math.max(current[mutation.id] ?? 0, Math.floor(mutation.at));
+      next = normalize2({ ...next, prefs: { ...next.prefs, seenAt: { ...current, [mutation.id]: at } } });
+      continue;
+    }
     if (mutation.kind === "set-engine-child-fold") {
       const currentFolded = next.prefs.foldedEngineChildIds ?? [];
       const foldedEngineChildIds = mutation.folded ? unique([...currentFolded, mutation.id]) : currentFolded.filter((item) => item !== mutation.id);
@@ -14793,7 +15597,8 @@ function applyBoardMutations(board, mutations) {
         prefs: {
           ...next.prefs,
           ...mutation.viewMode === undefined ? {} : { viewMode: mutation.viewMode },
-          ...mutation.taskPanelOpen === undefined ? {} : { taskPanelOpen: mutation.taskPanelOpen }
+          ...mutation.taskPanelOpen === undefined ? {} : { taskPanelOpen: mutation.taskPanelOpen },
+          ...mutation.idleCollapseMinutes === undefined ? {} : { idleCollapseMinutes: mutation.idleCollapseMinutes }
         }
       });
       continue;
@@ -14812,6 +15617,10 @@ function applyBoardMutations(board, mutations) {
   }
   return preserveDurableHiddenSpellings(board, next);
 }
+var MAX_SEEN_STAMPS = 512;
+var init_mutations = __esm(() => {
+  init_types2();
+});
 
 // src/lib/board/store.ts
 import crypto15 from "crypto";
@@ -14825,6 +15634,11 @@ function aliases(value) {
     return false;
   return Object.values(value).every((item) => typeof item === "string");
 }
+function seenStamps(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return Object.values(value).every((item) => typeof item === "number" && Number.isFinite(item) && item >= 0);
+}
 function keyRevisions(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
@@ -14835,7 +15649,15 @@ function projectState(value) {
     return false;
   const state = value;
   const prefs = state.prefs;
-  return state.schemaVersion === 1 && Number.isInteger(state.revision) && state.revision >= 0 && typeof state.updatedAt === "string" && Boolean(prefs) && stringArray2(prefs.manual) && stringArray2(prefs.hidden) && stringArray2(prefs.expanded) && (prefs.favorites === undefined || stringArray2(prefs.favorites)) && (prefs.foldedEngineChildIds === undefined || stringArray2(prefs.foldedEngineChildIds)) && (prefs.expandedEngineTrayParentIds === undefined || stringArray2(prefs.expandedEngineTrayParentIds)) && (state.explicitManual === undefined || stringArray2(state.explicitManual)) && (state.pathAliases === undefined || aliases(state.pathAliases)) && (state.keyRevisions === undefined || keyRevisions(state.keyRevisions)) && (state.keyRevisionFloor === undefined || Number.isInteger(state.keyRevisionFloor) && state.keyRevisionFloor >= 0) && (prefs.viewMode === null || prefs.viewMode === "scheme" || prefs.viewMode === "list") && typeof prefs.taskPanelOpen === "boolean";
+  return state.schemaVersion === 1 && Number.isInteger(state.revision) && state.revision >= 0 && typeof state.updatedAt === "string" && Boolean(prefs) && stringArray2(prefs.manual) && stringArray2(prefs.hidden) && stringArray2(prefs.expanded) && (prefs.favorites === undefined || stringArray2(prefs.favorites)) && (prefs.foldedEngineChildIds === undefined || stringArray2(prefs.foldedEngineChildIds)) && (prefs.expandedEngineTrayParentIds === undefined || stringArray2(prefs.expandedEngineTrayParentIds)) && (prefs.seenAt === undefined || seenStamps(prefs.seenAt)) && (prefs.idleCollapseMinutes === undefined || prefs.idleCollapseMinutes === null || Number.isInteger(prefs.idleCollapseMinutes) && prefs.idleCollapseMinutes > 0 && prefs.idleCollapseMinutes <= MAX_BOARD_IDLE_COLLAPSE_MINUTES) && (state.explicitManual === undefined || stringArray2(state.explicitManual)) && (state.pathAliases === undefined || aliases(state.pathAliases)) && (state.keyRevisions === undefined || keyRevisions(state.keyRevisions)) && (state.keyRevisionFloor === undefined || Number.isInteger(state.keyRevisionFloor) && state.keyRevisionFloor >= 0) && (prefs.viewMode === null || prefs.viewMode === "scheme" || prefs.viewMode === "list") && typeof prefs.taskPanelOpen === "boolean";
+}
+function mergeSeenAt(maps) {
+  const merged = {};
+  for (const map of maps) {
+    for (const [id, at] of Object.entries(map ?? {}))
+      merged[id] = Math.max(merged[id] ?? 0, at);
+  }
+  return merged;
 }
 function emptyBoard() {
   return { schemaVersion: 1, revision: 0, updatedAt: new Date(0).toISOString(), pathAliases: {}, explicitManual: [], keyRevisions: {}, keyRevisionFloor: 0, prefs: { ...EMPTY_PREFS, manual: [], hidden: [], expanded: [] } };
@@ -14870,7 +15692,9 @@ function read(filePath) {
         ...state.prefs,
         favorites: state.prefs.favorites ?? [],
         foldedEngineChildIds: state.prefs.foldedEngineChildIds ?? [],
-        expandedEngineTrayParentIds: state.prefs.expandedEngineTrayParentIds ?? []
+        expandedEngineTrayParentIds: state.prefs.expandedEngineTrayParentIds ?? [],
+        seenAt: state.prefs.seenAt ?? {},
+        idleCollapseMinutes: state.prefs.idleCollapseMinutes === undefined ? DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES : state.prefs.idleCollapseMinutes
       }
     }])) };
   } catch (error) {
@@ -15111,6 +15935,7 @@ function mergedBoards(states) {
     favorites: [...new Set(ordered.flatMap((state) => state.prefs.favorites ?? []))],
     foldedEngineChildIds: [...new Set(ordered.flatMap((state) => state.prefs.foldedEngineChildIds ?? []))],
     expandedEngineTrayParentIds: [...new Set(ordered.flatMap((state) => state.prefs.expandedEngineTrayParentIds ?? []))],
+    seenAt: mergeSeenAt(ordered.map((state) => state.prefs.seenAt)),
     viewMode,
     taskPanelOpen
   };
@@ -15169,8 +15994,10 @@ var init_store3 = __esm(() => {
   init_proc();
   init_aliases();
   init_keys();
+  init_mutations();
+  init_types2();
   BOARD_FILE = statePath("board.json");
-  EMPTY_PREFS = { manual: [], hidden: [], expanded: [], favorites: [], foldedEngineChildIds: [], expandedEngineTrayParentIds: [], viewMode: null, taskPanelOpen: false };
+  EMPTY_PREFS = { manual: [], hidden: [], expanded: [], favorites: [], foldedEngineChildIds: [], expandedEngineTrayParentIds: [], seenAt: {}, idleCollapseMinutes: DEFAULT_BOARD_IDLE_COLLAPSE_MINUTES, viewMode: null, taskPanelOpen: false };
   BoardStoreError = class BoardStoreError extends Error {
     constructor(message = "board state unavailable") {
       super(message);
@@ -15246,6 +16073,9 @@ function argvEngine(argv) {
   }
   return null;
 }
+function structuredHostStamp() {
+  return statePath();
+}
 function isHelperArgv(argv) {
   return argv.some((token) => HELPER_ARGS.has(token));
 }
@@ -15268,8 +16098,9 @@ function agentProcesses(fresh = false) {
   agentMemo = { at: now2, list };
   return list;
 }
-var HOLDERS_TTL_MS = 12000, MAX_PATH_HOLDER_CANDIDATES = 256, outputMemo = null, pathMemo = null, agentMemo = null, HELPER_ARGS;
+var HOLDERS_TTL_MS = 12000, MAX_PATH_HOLDER_CANDIDATES = 256, outputMemo = null, pathMemo = null, agentMemo = null, STRUCTURED_HOST_STAMP_ENV = "LLV_STRUCTURED_HOST", HELPER_ARGS;
 var init_process = __esm(() => {
+  init_configDir();
   init_proc();
   init_roots();
   HELPER_ARGS = new Set(["daemon", "--bg-pty-host", "--bg-spare"]);
@@ -15321,6 +16152,27 @@ var init_json = __esm(() => {
   jsonCache = globalCache("json-v3");
 });
 
+// src/lib/scanner/openclawNative.ts
+function isOpenclawTranscript(basename) {
+  if (!basename.endsWith(".jsonl"))
+    return false;
+  return !NON_TRANSCRIPT_SEGMENTS.some((segment) => basename.includes(segment));
+}
+function openclawMessage(record3) {
+  return record3.type === "message" ? recordValue(record3.message) : null;
+}
+function openclawProviderAssistant(record3) {
+  const message = openclawMessage(record3);
+  if (!message || message.role !== "assistant")
+    return null;
+  return stringValue(message.provider) === OPENCLAW_SYNTHETIC_PROVIDER ? null : message;
+}
+var OPENCLAW_SYNTHETIC_PROVIDER = "openclaw", NON_TRANSCRIPT_SEGMENTS;
+var init_openclawNative = __esm(() => {
+  init_json();
+  NON_TRANSCRIPT_SEGMENTS = [".trajectory.", ".checkpoint.", ".acp-stream.", ".deleted.", ".bak"];
+});
+
 // src/lib/accounts/migration/turnState.ts
 function timestamp2(record3) {
   const value = record3.timestamp;
@@ -15370,8 +16222,30 @@ function claudeRecoveryTailRelease(records) {
   }
   return null;
 }
-function turnStateFromRecords(records, codex, authoritative = false) {
-  if (codex) {
+function openclawTurnState(records) {
+  for (let index = records.length - 1;index >= 0; index -= 1) {
+    const record3 = records[index];
+    const message = openclawMessage(record3);
+    if (!message)
+      continue;
+    if (message.role === "assistant") {
+      if (!openclawProviderAssistant(record3))
+        continue;
+      const stop = stringValue(message.stopReason);
+      if (stop === "stop" || stop === "error" || stop === "aborted") {
+        return { state: "terminal", source: "lifecycle", terminalAt: timestamp2(record3) };
+      }
+      return { state: "busy", source: "assistant", terminalAt: null };
+    }
+    if (message.role === "user")
+      return { state: "busy", source: "lifecycle", terminalAt: null };
+  }
+  return { state: "unknown", source: "empty", terminalAt: null };
+}
+function turnStateFromRecords(records, engine, authoritative = false) {
+  if (engine === "openclaw")
+    return openclawTurnState(records);
+  if (engine === "codex") {
     let turnOpen = false;
     let terminalAt = null;
     let terminalSeen = false;
@@ -15461,6 +16335,7 @@ function turnStateFromRecords(records, codex, authoritative = false) {
 }
 var TERMINAL_API_ERRORS, SYNTHETIC_NO_OP_TEXT, INTERRUPT_SENTINEL_TEXT;
 var init_turnState = __esm(() => {
+  init_openclawNative();
   init_json();
   TERMINAL_API_ERRORS = new Set(["authentication_failed", "rate_limit"]);
   SYNTHETIC_NO_OP_TEXT = /^no response requested\.?$/i;
@@ -15519,15 +16394,22 @@ function storeTurnEvidence(pathname, evidence) {
   }
   turnEvidenceCache.set(key2, evidence);
 }
-function recoveryRelease(turn, records, codex, authoritative) {
-  if (codex || !authoritative || turn.state !== "terminal")
+function recoveryRelease(turn, records, engine, authoritative) {
+  if (engine !== "claude" || !authoritative || turn.state !== "terminal")
     return false;
   return claudeRecoveryTailRelease(records) !== null;
 }
-function transcriptTurnResult(pathname, size, mtimeMs, codex, authoritative = true) {
+function transcriptEngineForRoot(root) {
+  if (root === "codex-sessions")
+    return "codex";
+  if (root === "openclaw-sessions")
+    return "openclaw";
+  return "claude";
+}
+function transcriptTurnResult(pathname, size, mtimeMs, engine, authoritative = true) {
   const key2 = `${authoritative ? "authoritative" : "activity"}:${pathname}`;
   const cached3 = turnEvidenceCache.get(key2);
-  if (cached3 && cached3.size === size && cached3.mtimeMs === mtimeMs && cached3.codex === codex) {
+  if (cached3 && cached3.size === size && cached3.mtimeMs === mtimeMs && cached3.engine === engine) {
     storeTurnEvidence(pathname, cached3);
     return {
       turn: { ...cached3.turn },
@@ -15537,31 +16419,31 @@ function transcriptTurnResult(pathname, size, mtimeMs, codex, authoritative = tr
     };
   }
   const tail = tailRecordsResult(pathname, size, mtimeMs);
-  const turn = turnStateFromRecords(tail.records, codex, authoritative);
-  const recoveryReleased = tail.complete && recoveryRelease(turn, tail.records, codex, authoritative);
+  const turn = turnStateFromRecords(tail.records, engine, authoritative);
+  const recoveryReleased = tail.complete && recoveryRelease(turn, tail.records, engine, authoritative);
   if (tail.complete) {
-    storeTurnEvidence(pathname, { size, mtimeMs, codex, authoritative, turn, composerReleased: false, recoveryReleased });
+    storeTurnEvidence(pathname, { size, mtimeMs, engine, authoritative, turn, composerReleased: false, recoveryReleased });
     const companionAuthoritative = !authoritative;
     const companionKey = `${companionAuthoritative ? "authoritative" : "activity"}:${pathname}`;
     const cachedCompanion = turnEvidenceCache.get(companionKey);
-    const companionComposerReleased = cachedCompanion?.size === size && cachedCompanion.mtimeMs === mtimeMs && cachedCompanion.codex === codex && cachedCompanion.composerReleased;
-    const companionTurn = turnStateFromRecords(tail.records, codex, companionAuthoritative);
+    const companionComposerReleased = cachedCompanion?.size === size && cachedCompanion.mtimeMs === mtimeMs && cachedCompanion.engine === engine && cachedCompanion.composerReleased;
+    const companionTurn = turnStateFromRecords(tail.records, engine, companionAuthoritative);
     storeTurnEvidence(pathname, {
       size,
       mtimeMs,
-      codex,
+      engine,
       authoritative: companionAuthoritative,
       turn: companionTurn,
       composerReleased: companionComposerReleased,
-      recoveryReleased: recoveryRelease(companionTurn, tail.records, codex, companionAuthoritative)
+      recoveryReleased: recoveryRelease(companionTurn, tail.records, engine, companionAuthoritative)
     });
   }
   return { turn, complete: tail.complete, composerReleased: false, recoveryReleased };
 }
-function cachedTranscriptTurn(pathname, size, mtimeMs, codex) {
+function cachedTranscriptTurn(pathname, size, mtimeMs, engine) {
   for (const key2 of [`activity:${pathname}`, `authoritative:${pathname}`]) {
     const cached3 = turnEvidenceCache.get(key2);
-    if (cached3 && cached3.size === size && cached3.mtimeMs === mtimeMs && cached3.codex === codex) {
+    if (cached3 && cached3.size === size && cached3.mtimeMs === mtimeMs && cached3.engine === engine) {
       return { ...cached3.turn };
     }
   }
@@ -15637,7 +16519,7 @@ function activityVerdict(root, pathname, mtime, size) {
   let complete = true;
   if (pathname.endsWith(".jsonl")) {
     const mtimeMs = mtime * 1000;
-    const turn = transcriptTurnResult(pathname, size, mtimeMs, root.startsWith("codex"), false);
+    const turn = transcriptTurnResult(pathname, size, mtimeMs, transcriptEngineForRoot(root), false);
     const state = turn.turn.state === "terminal" ? "done" : turn.turn.state === "busy" ? "busy" : null;
     complete = turn.complete;
     if (state === "busy") {
@@ -15661,7 +16543,8 @@ var init_activity = __esm(() => {
   init_turnState();
   globalCache("turn").clear();
   globalCache("turn-evidence-v1").clear();
-  turnEvidenceCache = globalCache("turn-evidence-v2");
+  globalCache("turn-evidence-v2").clear();
+  turnEvidenceCache = globalCache("turn-evidence-v3");
   tailCache = globalCache("tail-v3");
   headCache2 = globalCache("head-records-v2");
   HEAD_CACHE_BYTE_CAP2 = 16 * 1024 * 1024;
@@ -15974,12 +16857,7 @@ function runtimeSettingsCapability(engine) {
   return { perTurnEffort: engine === "codex", perTurnModel: false };
 }
 function runtimeCompactCapability(engine) {
-  return engine === "codex" ? { control: "compact", engine, supported: true } : {
-    control: "compact",
-    engine,
-    supported: false,
-    reason: "The Claude stream-json protocol has no client-originated compact control; only interrupt is exposed."
-  };
+  return engine === "codex" ? { control: "compact", engine, supported: true, confirmation: "observed" } : { control: "compact", engine, supported: true, confirmation: "best-effort" };
 }
 function canonicalRuntimeKind(kind) {
   return KIND_ALIASES[kind] ?? kind;
@@ -16418,7 +17296,6 @@ var init_compactText = __esm(() => {
   init_review();
   SCAN_BYTES = 1024 * 1024;
 });
-
 // src/lib/runtime/voiceDelivery.ts
 function record3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -16875,11 +17752,22 @@ class FileRuntimeEventStore {
     return path31.join(this.directory, `${encodeURIComponent(threadId)}.jsonl`);
   }
 }
-var MAX_CACHED_LEDGER_BYTES, MAX_CACHED_LEDGERS = 64, eventStoreGlobals, MAX_DIAGNOSTIC_SESSION_ID_LENGTH = 160;
+var MAX_CACHED_LEDGER_BYTES, MAX_CACHED_LEDGERS = 64, eventStoreGlobals, MAX_DIAGNOSTIC_SESSION_ID_LENGTH = 160, EVENT_TAIL_STEP_BYTES, EVENT_TAIL_MAX_RECORD_BYTES;
 var init_eventStore = __esm(() => {
   init_configDir();
   MAX_CACHED_LEDGER_BYTES = 64 * 1024 * 1024;
   eventStoreGlobals = globalThis;
+  EVENT_TAIL_STEP_BYTES = 64 * 1024;
+  EVENT_TAIL_MAX_RECORD_BYTES = 32 * 1024 * 1024;
+});
+
+// src/lib/runtime/hostActivityFlags.ts
+var NATIVE_MULTI_AGENT_DENY_FLAG, CAPABILITY_FLAGS;
+var init_hostActivityFlags = __esm(() => {
+  init_spawnPolicy();
+  init_structuredContent();
+  NATIVE_MULTI_AGENT_DENY_FLAG = `native-multi-agent-deny:${NATIVE_MULTI_AGENT_TOOLS.join(",")}`;
+  CAPABILITY_FLAGS = new Set([STRUCTURED_IMAGE_CAPABILITY]);
 });
 
 // src/lib/runtime/runtimeImageStore.ts
@@ -17909,6 +18797,7 @@ function subscriptionEnv(source, claudeConfigDir, forwardGitHubConfig = false) {
     env.GH_CONFIG_DIR = source.GH_CONFIG_DIR;
   if (claudeConfigDir)
     env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+  env[STRUCTURED_HOST_STAMP_ENV] = structuredHostStamp();
   return env;
 }
 function claudeCliProbe(binary, args, cwd, env) {
@@ -18069,10 +18958,13 @@ class ClaudeStreamBrokerHost {
   eventStore;
   deliveryLedger;
   readImage;
+  compactEvidenceTimeoutMs;
   requestTimeoutMs;
   shutdownGraceMs;
   onEventCursorRecovery;
   signalProcess;
+  processIdentity;
+  childStartIdentity;
   subscribers = new Set;
   events = [];
   deliveries = [];
@@ -18080,6 +18972,7 @@ class ClaudeStreamBrokerHost {
   attentions = new Map;
   pendingControls = new Map;
   pendingAnswers = new Map;
+  compactions = new Map;
   interruptedTurns = new Set;
   partialTurns = new Set;
   pendingDeliveries = new Map;
@@ -18102,6 +18995,7 @@ class ClaudeStreamBrokerHost {
   releaseCleanup;
   terminationTimer = null;
   terminationStarted = false;
+  releaseFence = null;
   reapedPromise;
   resolveReaped;
   launchFlags;
@@ -18111,10 +19005,13 @@ class ClaudeStreamBrokerHost {
     this.eventStore = options.eventStore ?? new FileRuntimeEventStore;
     this.deliveryLedger = options.deliveryLedger ?? new FileClaudeDeliveryLedger;
     this.readImage = options.readImage ?? ((ref) => runtimeImageStore().read(ref));
+    this.compactEvidenceTimeoutMs = options.compactEvidenceTimeoutMs ?? DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS2;
     this.shutdownGraceMs = options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS2;
     this.onEventCursorRecovery = options.onEventCursorRecovery;
     this.signalProcess = options.signalProcess ?? process.kill;
+    this.processIdentity = options.processIdentity ?? ((pid) => procBackend.processIdentity(pid));
+    this.childStartIdentity = child.pid ? this.processIdentity(child.pid) : null;
     this.releaseCleanup = options.releaseCleanup ?? null;
     this.cursor = options.initialEventCursor ?? 0;
     this.protocolVersion = auth.version ?? null;
@@ -18375,6 +19272,66 @@ class ClaudeStreamBrokerHost {
       this.write({ type: "control_request", request_id: requestId, request: { subtype: "interrupt" } });
     });
   }
+  async compact(request) {
+    const existing = this.compactions.get(request.operationId);
+    if (existing)
+      return existing.promise;
+    if (this.unavailable())
+      throw new StructuredCompactError("Claude stream host is unavailable", "refused");
+    if (request.threadId && request.threadId !== this.identity.sessionId) {
+      throw new StructuredCompactError("compact target session is not the session this host owns", "refused");
+    }
+    if (this.activeTurnId) {
+      throw new StructuredCompactError("a turn is active; compaction would race it", "refused");
+    }
+    if ([...this.compactions.values()].some((compaction2) => !compaction2.settled)) {
+      throw new StructuredCompactError("a compaction is already running on this conversation", "refused");
+    }
+    let resolveOutcome;
+    let rejectOutcome;
+    const promise = new Promise((resolve, reject) => {
+      resolveOutcome = resolve;
+      rejectOutcome = reject;
+    });
+    const compaction = {
+      promise,
+      resolve: (outcome) => resolveOutcome(outcome),
+      reject: (error) => rejectOutcome(error),
+      settled: false,
+      timer: null
+    };
+    this.compactions.set(request.operationId, compaction);
+    promise.catch(() => {
+      return;
+    });
+    this.write({
+      type: "user",
+      session_id: this.identity.sessionId,
+      message: { role: "user", content: [{ type: "text", text: CLAUDE_COMPACT_COMMAND }] }
+    });
+    compaction.timer = setTimeout(() => {
+      this.settleCompaction(compaction, new StructuredCompactError(CLAUDE_COMPACT_UNOBSERVED_REASON, "unverified"));
+    }, this.compactEvidenceTimeoutMs);
+    return promise;
+  }
+  settleCompaction(compaction, outcome) {
+    if (compaction.settled)
+      return;
+    compaction.settled = true;
+    if (compaction.timer)
+      clearTimeout(compaction.timer);
+    compaction.timer = null;
+    if (outcome instanceof StructuredCompactError)
+      compaction.reject(outcome);
+    else
+      compaction.resolve(outcome);
+  }
+  settlePendingCompactions(outcome) {
+    for (const compaction of this.compactions.values()) {
+      if (!compaction.settled)
+        this.settleCompaction(compaction, outcome);
+    }
+  }
   async answer(attentionRef, value) {
     if (this.unavailable())
       throw new Error("Claude stream host is unavailable");
@@ -18426,6 +19383,19 @@ class ClaudeStreamBrokerHost {
     }
     return this.releasePromise;
   }
+  async releaseIfOwned(expected) {
+    const pid = this.child.pid;
+    if (this.released || this.releasing || this.releasePromise !== null || !pid || expected.startIdentity === null || pid !== expected.pid || this.childStartIdentity !== expected.startIdentity || this.processIdentity(pid) !== expected.startIdentity)
+      return false;
+    this.releaseFence = expected;
+    try {
+      await this.release();
+      return true;
+    } finally {
+      if (this.releaseFence === expected)
+        this.releaseFence = null;
+    }
+  }
   unavailable() {
     if (this.dead || this.releasing || this.released)
       return true;
@@ -18443,7 +19413,7 @@ class ClaudeStreamBrokerHost {
       sessionKey: this.identity.sessionId,
       endpoint: pid ? `stdio:${pid}` : "stdio:released",
       pid,
-      processStartIdentity: pid ? procBackend.processIdentity(pid) : null,
+      processStartIdentity: pid ? this.processIdentity(pid) : null,
       eventCursor: this.cursor,
       protocolVersion: this.protocolVersion,
       activeTurnRef: this.activeTurnId,
@@ -18572,6 +19542,10 @@ class ClaudeStreamBrokerHost {
         return this.fail(new Error("Claude stream process did not use subscription OAuth"));
       return;
     }
+    if (type === "system" && message.subtype === "compact_boundary") {
+      this.settlePendingCompactions({ compactionId: stringField(message, "uuid") });
+      return;
+    }
     if (type === "user") {
       const content = messageContent(message);
       const directUserEcho = stringField(message.message, "role") === "user" && content !== null;
@@ -18680,8 +19654,10 @@ class ClaudeStreamBrokerHost {
   }
   acceptResult(message) {
     const turnId = this.turnQueue.shift() ?? this.activeTurnId;
-    if (!turnId)
+    if (!turnId) {
+      this.settlePendingCompactions(new StructuredCompactError(CLAUDE_COMPACT_DECLINED_REASON, "refused"));
       return;
+    }
     this.partialTurns.delete(turnId);
     const interrupted = this.interruptedTurns.delete(turnId);
     const status = interrupted || message.subtype === "interrupted" ? "interrupted" : message.subtype === "success" ? "completed" : "error";
@@ -18715,9 +19691,15 @@ class ClaudeStreamBrokerHost {
   async releaseAndReap() {
     this.releasing = true;
     this.rejectPending(new Error("Claude stream host released"));
-    this.startTermination();
+    if (!this.startTermination() && this.releaseFence) {
+      this.releasing = false;
+      throw new Error("Claude child identity changed before signalling");
+    }
     if (!await this.waitForReap(this.shutdownGraceMs * 2)) {
-      signalDetachedProcessGroup(this.child, "SIGKILL", this.signalProcess);
+      if (!this.signalReleaseGroup("SIGKILL") && this.releaseFence) {
+        this.releasing = false;
+        throw new Error("Claude child identity changed before signalling");
+      }
       if (!await this.waitForReap(this.shutdownGraceMs)) {
         const leaderExited = this.child.pid === undefined || (this.child.exitCode ?? null) !== null || (this.child.signalCode ?? null) !== null;
         if (!leaderExited)
@@ -18798,20 +19780,31 @@ class ClaudeStreamBrokerHost {
     this.closeSubscribers();
     this.startTermination();
   }
+  signalReleaseGroup(signal2) {
+    const expected = this.releaseFence;
+    if (expected) {
+      const pid = this.child.pid;
+      if (!pid || expected.startIdentity === null || pid !== expected.pid || this.childStartIdentity !== expected.startIdentity || this.processIdentity(pid) !== expected.startIdentity)
+        return false;
+    }
+    return signalDetachedProcessGroup(this.child, signal2, this.signalProcess);
+  }
   startTermination() {
     if (this.terminationStarted || this.reaped)
-      return;
-    this.terminationStarted = true;
+      return true;
     try {
       this.child.stdin.end();
     } catch {}
-    signalDetachedProcessGroup(this.child, "SIGTERM", this.signalProcess);
+    if (!this.signalReleaseGroup("SIGTERM"))
+      return false;
+    this.terminationStarted = true;
     this.terminationTimer = setTimeout(() => {
       this.terminationTimer = null;
       if (this.reaped)
         return;
-      signalDetachedProcessGroup(this.child, "SIGKILL", this.signalProcess);
+      this.signalReleaseGroup("SIGKILL");
     }, this.shutdownGraceMs);
+    return true;
   }
   rejectPending(error) {
     for (const pending of this.pendingDeliveries.values()) {
@@ -18829,6 +19822,7 @@ class ClaudeStreamBrokerHost {
       pending.reject(new Error(safeError(error)));
     }
     this.pendingAnswers.clear();
+    this.settlePendingCompactions(new StructuredCompactError(CLAUDE_COMPACT_UNOBSERVED_REASON, "unverified"));
   }
   closeSubscribers() {
     for (const subscriber of this.subscribers) {
@@ -18842,16 +19836,18 @@ class ClaudeStreamBrokerHost {
       listener(state);
   }
 }
-var CHILD_ENV_ALLOWLIST, DEFAULT_TIMEOUT_MS2 = 30000, DEFAULT_SHUTDOWN_GRACE_MS2 = 1000, NATIVE_MULTI_AGENT_DENY_FLAG, MAX_REPLAY_ENVELOPE_BYTES, MAX_LINE_BYTES, TERMINAL_EXIT_MATCH_BYTES = 512, TERMINAL_CLI_EXIT_SIGNATURES, safeError, MAX_AUTH_PROBE_STDOUT_BYTES;
+var CHILD_ENV_ALLOWLIST, DEFAULT_TIMEOUT_MS2 = 30000, DEFAULT_SHUTDOWN_GRACE_MS2 = 1000, CLAUDE_COMPACT_COMMAND = "/compact", CLAUDE_COMPACT_UNOBSERVED_REASON = "compact-sent-unobserved", CLAUDE_COMPACT_DECLINED_REASON = "compact-declined", DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS, MAX_REPLAY_ENVELOPE_BYTES, MAX_LINE_BYTES, TERMINAL_EXIT_MATCH_BYTES = 512, TERMINAL_CLI_EXIT_SIGNATURES, safeError, MAX_AUTH_PROBE_STDOUT_BYTES;
 var init_claudeStreamBrokerHost = __esm(() => {
   init_configDir();
   init_cli();
   init_spawnPolicy();
   init_transcript();
   init_proc();
+  init_process();
   init_compactText();
   init_engineHost();
   init_eventStore();
+  init_hostActivityFlags();
   init_runtimeImageStore();
   init_telegramConnectorEnv();
   init_structuredContent();
@@ -18880,7 +19876,7 @@ var init_claudeStreamBrokerHost = __esm(() => {
     "SSL_CERT_DIR",
     "LLV_SPAWN_CAPABILITY"
   ];
-  NATIVE_MULTI_AGENT_DENY_FLAG = `native-multi-agent-deny:${NATIVE_MULTI_AGENT_TOOLS.join(",")}`;
+  DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS = 5 * 60000;
   MAX_REPLAY_ENVELOPE_BYTES = 256 * 1024;
   MAX_LINE_BYTES = MAX_STRUCTURED_IMAGE_ENCODED_BYTES + MAX_REPLAY_ENVELOPE_BYTES;
   TERMINAL_CLI_EXIT_SIGNATURES = [
@@ -18929,7 +19925,13 @@ function decodeCodexStructuredUserText(value) {
         senderRole = messageOriginRole(attribute);
     }
     const origin = originKind ? { kind: originKind, ...originKind === "agent" && senderRole ? { role: senderRole } : {} } : null;
-    return { text: value.slice(marker[0].length), structured: true, contentDigest, selectedContext, origin };
+    return {
+      text: value.slice(marker[0].length),
+      structured: true,
+      contentDigest,
+      selectedContext,
+      origin
+    };
   }
   if (!value.startsWith(STRUCTURED_USER_MARKER)) {
     return { text: value, structured: false, contentDigest: null, selectedContext: null, origin: null };
@@ -19445,6 +20447,7 @@ function subscriptionEnv2(source, codexHome, desktopSession = false, forwardGitH
     env.GH_CONFIG_DIR = source.GH_CONFIG_DIR;
   if (codexHome)
     env.CODEX_HOME = codexHome;
+  env[STRUCTURED_HOST_STAMP_ENV] = structuredHostStamp();
   return env;
 }
 function threadFromResult(value, method) {
@@ -19714,7 +20717,7 @@ class CodexAppServerHost {
     this.realtimePersonaTimeoutMs = options.realtimePersonaTimeoutMs ?? REALTIME_PERSONA_TIMEOUT_MS;
     this.realtimeStartTimeoutMs = options.realtimeStartTimeoutMs ?? REALTIME_START_TIMEOUT_MS;
     this.deliveryConfirmationTimeoutMs = options.deliveryConfirmationTimeoutMs ?? DEFAULT_DELIVERY_CONFIRMATION_TIMEOUT_MS;
-    this.compactEvidenceTimeoutMs = options.compactEvidenceTimeoutMs ?? DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS;
+    this.compactEvidenceTimeoutMs = options.compactEvidenceTimeoutMs ?? DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS2;
     this.shutdownGraceMs = options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS3;
     this.eventStore = options.eventStore ?? new FileRuntimeEventStore;
     this.effort = options.effort;
@@ -20583,6 +21586,13 @@ class CodexAppServerHost {
     }
     return this.releasePromise;
   }
+  async releaseIfOwned(expected) {
+    const pid = this.child.pid;
+    if (this.released || this.releasing || this.releasePromise !== null || !pid || expected.startIdentity === null || pid !== expected.pid || this.childStartIdentity !== expected.startIdentity || this.childProcessOwnership() !== "owned")
+      return false;
+    await this.release();
+    return true;
+  }
   async releaseAndReap() {
     this.realtimeDeliveryEpoch += 1;
     if (this.realtimeSessionId) {
@@ -21669,10 +22679,11 @@ class CodexAppServerHost {
     pending.reject(new Error(safeError2(error)));
   }
 }
-var CHILD_ENV_ALLOWLIST2, DESKTOP_ENV_ALLOWLIST, DEFAULT_TIMEOUT_MS3 = 30000, DEFAULT_DELIVERY_CONFIRMATION_TIMEOUT_MS, DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS, ACTIVE_THREAD_READ_TIMEOUT_MULTIPLIER = 3, LATE_THREAD_READ_RESPONSE_TTL_MULTIPLIER = 3, MIN_LATE_THREAD_READ_RESPONSE_TTL_MS = 1000, MAX_LATE_THREAD_READ_RESPONSES = 32, DEFAULT_SHUTDOWN_GRACE_MS3 = 1000, REALTIME_START_TIMEOUT_MS = 90000, REALTIME_PERSONA_TIMEOUT_MS = 3000, REALTIME_HANGUP_TIMEOUT_MS = 2000, REALTIME_LIVE_MODEL = "gpt-live-1-codex", MAX_REALTIME_SDP_BYTES, MAX_REALTIME_SPEECH_BYTES, MAX_REALTIME_CONTEXT_ITEMS = 12, MAX_REALTIME_CONTEXT_ITEM_BYTES, MAX_REALTIME_CONTEXT_BYTES, MAX_REPLAY_ENVELOPE_BYTES2, MAX_LINE_BYTES2, REPLAY_ENVELOPE_METHODS, REPLAY_REDUCTION_THRESHOLD_BYTES, REPLAY_STRING_UNITS, MAX_REPLAY_RAW_UNITS, REPLAY_STREAM_OUTPUT_UNITS, MAX_TRACKED_REPLAY_ENVELOPE_REQUESTS = 64, REPLAY_RESPONSE_PREFIX, REPLAY_FRAME_BUDGETS, MAX_STDERR_TAIL_BYTES, MAX_PRE_RESTORE_FRAMES = 256, MAX_PRE_RESTORE_BYTES, MUTATING_RPC_METHODS, safeError2;
+var CHILD_ENV_ALLOWLIST2, DESKTOP_ENV_ALLOWLIST, DEFAULT_TIMEOUT_MS3 = 30000, DEFAULT_DELIVERY_CONFIRMATION_TIMEOUT_MS, DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS2, ACTIVE_THREAD_READ_TIMEOUT_MULTIPLIER = 3, LATE_THREAD_READ_RESPONSE_TTL_MULTIPLIER = 3, MIN_LATE_THREAD_READ_RESPONSE_TTL_MS = 1000, MAX_LATE_THREAD_READ_RESPONSES = 32, DEFAULT_SHUTDOWN_GRACE_MS3 = 1000, REALTIME_START_TIMEOUT_MS = 90000, REALTIME_PERSONA_TIMEOUT_MS = 3000, REALTIME_HANGUP_TIMEOUT_MS = 2000, REALTIME_LIVE_MODEL = "gpt-live-1-codex", MAX_REALTIME_SDP_BYTES, MAX_REALTIME_SPEECH_BYTES, MAX_REALTIME_CONTEXT_ITEMS = 12, MAX_REALTIME_CONTEXT_ITEM_BYTES, MAX_REALTIME_CONTEXT_BYTES, MAX_REPLAY_ENVELOPE_BYTES2, MAX_LINE_BYTES2, REPLAY_ENVELOPE_METHODS, REPLAY_REDUCTION_THRESHOLD_BYTES, REPLAY_STRING_UNITS, MAX_REPLAY_RAW_UNITS, REPLAY_STREAM_OUTPUT_UNITS, MAX_TRACKED_REPLAY_ENVELOPE_REQUESTS = 64, REPLAY_RESPONSE_PREFIX, REPLAY_FRAME_BUDGETS, MAX_STDERR_TAIL_BYTES, MAX_PRE_RESTORE_FRAMES = 256, MAX_PRE_RESTORE_BYTES, MUTATING_RPC_METHODS, safeError2;
 var init_codexAppServerHost = __esm(() => {
   init_efforts();
   init_proc();
+  init_process();
   init_codexHeadlessConfig();
   init_pluginAllowlist();
   init_compactText();
@@ -21719,7 +22730,7 @@ var init_codexAppServerHost = __esm(() => {
     "DESKTOP_SESSION"
   ];
   DEFAULT_DELIVERY_CONFIRMATION_TIMEOUT_MS = 5 * 60000;
-  DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS = 5 * 60000;
+  DEFAULT_COMPACT_EVIDENCE_TIMEOUT_MS2 = 5 * 60000;
   MAX_REALTIME_SDP_BYTES = 512 * 1024;
   MAX_REALTIME_SPEECH_BYTES = 8 * 1024;
   MAX_REALTIME_CONTEXT_ITEM_BYTES = 8 * 1024;
@@ -25913,7 +26924,7 @@ function candidateFor(registry, request, durableProfileWins = false) {
     return null;
   const terminal2 = entry?.status === "dead" || entry?.status === "unhosted";
   const publishReady = Boolean(structuredHostProcessAlive(entry?.structuredHost?.process ?? null) && entry?.claimOwner && entry.pendingAction === null && !terminal2);
-  const profile = emptyLaunchProfile(durableProfileWins ? {
+  const inheritedProfile = emptyLaunchProfile(durableProfileWins ? {
     ...entry?.launchProfile ?? {},
     ...generation.launchProfile,
     cwd: generation.launchProfile.cwd || entry?.launchProfile?.cwd || entry?.cwd
@@ -25922,6 +26933,11 @@ function candidateFor(registry, request, durableProfileWins = false) {
     ...entry?.launchProfile ?? {},
     cwd: entry?.launchProfile?.cwd || generation.launchProfile.cwd || entry?.cwd
   });
+  const inheritedTitle = durableSemanticTitle(generation.launchProfile.title, 120) ?? durableSemanticTitle(entry?.launchProfile?.title, 120);
+  const profile = emptyLaunchProfile({
+    ...inheritedProfile,
+    title: inheritedTitle ?? derivedSpawnTitle("recovery", inheritedProfile.goal?.objective ?? inheritedProfile.cwd, "Conversation recovery")
+  });
   const recordedParent = snapshot2.lineageEdges[conversation.id]?.parentConversationId ?? profile.parentConversationId;
   const parentConversationId = recordedParent && recordedParent !== conversation.id ? registry.canonicalConversationId(recordedParent) : null;
   return {
@@ -26070,6 +27086,7 @@ var init_structuredRecovery = __esm(() => {
   init_registry();
   init_sessionKey();
   init_proc();
+  init_title();
   init_client();
   init_registry3();
   init_structuredSpawn();
@@ -26687,11 +27704,13 @@ var init_structuredDeliveryController = __esm(() => {
     activeRegistry: null,
     activeHosts: null,
     registerActiveHost: null,
+    activeRegistrations: null,
     republishActiveHost: null,
     releaseActiveHost: null,
     terminateActiveHost: null,
     completeActive: null,
-    stopActive: () => {}
+    stopActive: () => {},
+    everPublished: false
   };
   StructuredDeliveryControllerUnavailableError = class StructuredDeliveryControllerUnavailableError extends Error {
     code = CONTROLLER_UNAVAILABLE_CODE;
@@ -26771,7 +27790,7 @@ function completeProviderTurnObservation(conversation, source, virtualSource, re
   } catch (error) {
     return virtualSource && error.code === "ENOENT";
   }
-  const observed = transcriptTurnResult(source.path, before.size, before.mtimeMs, conversation.engine === "codex");
+  const observed = transcriptTurnResult(source.path, before.size, before.mtimeMs, conversation.engine);
   if (!observed.complete)
     return false;
   let after;
@@ -26957,13 +27976,21 @@ async function advanceConversationMigration(conversationId, registry = agentRegi
         throw new Error("conversation has no source generation");
       if (!completeProviderTurnObservation(conversation, source2, successorProvider.virtualSource === true, registry))
         return restoreCreationFence(conversation);
+      if (!migration.successorLaunchProfile) {
+        conversation = registry.transitionConversationMigration(conversation.id, migration.revision, ["successor-starting"], { successorLaunchProfile: migrationSuccessorLaunchProfile(source2.launchProfile) });
+        migration = conversation.migration;
+      }
       const conversationId2 = conversation.id;
       const creationOwner = { operationId: migration.operationId, revision: migration.revision };
+      const successorSource = {
+        ...source2,
+        launchProfile: migration.successorLaunchProfile
+      };
       receipt = await successorProvider.create({
         engine: conversation.engine,
         operationId: creationOwner.operationId,
         conversationId: conversationId2,
-        source: source2,
+        source: successorSource,
         targetAccountId: migration.targetId,
         recordContinuityPath(pathname) {
           registry.recordMigrationContinuityPath(conversationId2, pathname, creationOwner);
@@ -26978,9 +28005,10 @@ async function advanceConversationMigration(conversationId, registry = agentRegi
     const source = conversation.generations.find((generation) => generation.id === migration.sourceGenerationId) ?? conversation.generations.at(-1);
     if (!source)
       throw new Error("conversation has no source generation");
+    const successorProfile = migration.successorLaunchProfile ?? migrationSuccessorLaunchProfile(source.launchProfile);
     if (!receipt || receipt.operationId !== migration.operationId)
       throw new Error("persisted successor receipt operation does not match");
-    await successorProvider.verify(receipt, { engine: conversation.engine, targetAccountId: migration.targetId, launchProfile: source.launchProfile });
+    await successorProvider.verify(receipt, { engine: conversation.engine, targetAccountId: migration.targetId, launchProfile: successorProfile });
     const publicationConversationId = conversation.id;
     const publicationReceipt = receipt;
     const publicationRevision = migration.revision;
@@ -27007,7 +28035,7 @@ async function advanceConversationMigration(conversationId, registry = agentRegi
       engine: conversation.engine,
       conversationId: publicationConversationId,
       targetAccountId: migration.targetId,
-      launchProfile: source.launchProfile,
+      launchProfile: successorProfile,
       ownsOperation: ownsPublication
     });
     publishOwner = registry.conversation(publicationConversationId);
@@ -27025,7 +28053,7 @@ async function advanceConversationMigration(conversationId, registry = agentRegi
       id: publicationReceipt.nativeId,
       path: publicationReceipt.path,
       accountId: migration.targetId,
-      launchProfile: source.launchProfile,
+      launchProfile: successorProfile,
       historyHash: publicationReceipt.historyHash,
       host: publicationReceipt.host
     }, publicationRevision, publicationOperationId, publicationReceipt);
@@ -27087,6 +28115,7 @@ var init_coordinator = __esm(() => {
   init_activity();
   init_codexNative();
   init_process();
+  init_title();
   init_structuredDeliveryController();
   init_contracts2();
   init_provider();
@@ -27297,21 +28326,6 @@ var init_pauseResumeActor = __esm(() => {
   OPERATOR_PAUSE_RESUME_ACTOR = { kind: "operator" };
 });
 
-// src/lib/title.ts
-function compactPath(value) {
-  return value.replace(/(?:\/[^\s)]+){3,}/g, (match) => {
-    if (match.length <= 40)
-      return match;
-    const parts = match.split("/").filter(Boolean);
-    return parts.length >= 2 ? ".../" + parts.slice(-2).join("/") : match;
-  });
-}
-function cleanTitle(value, maxLength = 160) {
-  const stripped = value.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/[*_~#>]+/g, "").replace(/\s+/g, " ").trim();
-  const compacted = compactPath(stripped).replace(/\s+/g, " ").trim();
-  return compacted.length > maxLength ? compacted.slice(0, maxLength - 1).trimEnd() + "\u2026" : compacted;
-}
-
 // src/lib/scanner/projectState.ts
 import crypto23 from "crypto";
 import fs46 from "fs";
@@ -27442,6 +28456,7 @@ var init_projectState = __esm(() => {
 
 // src/lib/scanner/describe.ts
 import fs47 from "fs";
+import os10 from "os";
 import path43 from "path";
 function subagentSidecarPath(rootName, pathname) {
   if (rootName !== "claude-projects" || !path43.basename(pathname).startsWith("agent-") || !pathname.endsWith(".jsonl")) {
@@ -27737,6 +28752,17 @@ function persistedProjects(stateKey = projectResolutionStateKey()) {
   persistedProjectCache.set("state", [Date.now() + PERSISTED_PROJECT_TTL_MS, dir, stateKey, maps]);
   return maps;
 }
+function projectInfoFromOpenclawWorkspace(cwd) {
+  const resolved = path43.resolve(cwd);
+  if (path43.basename(resolved) !== "workspace")
+    return null;
+  const state2 = path43.dirname(resolved);
+  const configured = process.env.OPENCLAW_STATE_DIR?.trim();
+  const recognized = configured !== undefined && configured !== "" && path43.resolve(configured) === state2 || path43.dirname(state2) === os10.homedir() && OPENCLAW_STATE_DIRECTORY.test(path43.basename(state2));
+  if (!recognized)
+    return null;
+  return { project: directoryProjectId(resolved), displayName: "OpenClaw" };
+}
 function projectInfoFromCwd(cwd, requestedState) {
   if (!cwd.trim())
     return null;
@@ -27749,6 +28775,11 @@ function projectInfoFromCwd(cwd, requestedState) {
     projectInfoCwdCache.set(cwd, [Date.now() + PROJECT_INFO_CWD_TTL_MS, resolutionState, scratchpad]);
     return scratchpad;
   }
+  const openclawWorkspace = projectInfoFromOpenclawWorkspace(cwd);
+  if (openclawWorkspace) {
+    projectInfoCwdCache.set(cwd, [Date.now() + PROJECT_INFO_CWD_TTL_MS, resolutionState, openclawWorkspace]);
+    return openclawWorkspace;
+  }
   const codexWorktree = worktreeFromCodexPath(cwd);
   let worktree = worktreeFromPath(cwd) ?? worktreeFromNested(cwd) ?? (codexWorktree ? worktreeFromGitFile(cwd) ?? codexWorktree : worktreeFromGitFile(cwd));
   if (!worktree && !hasGitMarker(cwd)) {
@@ -27784,6 +28815,8 @@ function projectRootForCwd(cwd) {
   const scratchpad = projectInfoFromClaudeTaskCwd(cwd);
   if (scratchpad)
     return scratchpad.repo;
+  if (projectInfoFromOpenclawWorkspace(cwd))
+    return;
   const worktree = worktreeFromPath(cwd) ?? worktreeFromNested(cwd) ?? (worktreeFromCodexPath(cwd) ? worktreeFromGitFile(cwd) ?? worktreeFromCodexPath(cwd) : null) ?? worktreeFromGitFile(cwd) ?? worktreeFromMemory(cwd);
   return worktree?.repo || repositoryRootForPath(cwd) || undefined;
 }
@@ -27866,8 +28899,18 @@ function goodTitle(text2) {
   const val = typeof text2 === "string" ? text2.trim() : "";
   return val && !skipTitlePrefixes.some((prefix) => val.startsWith(prefix)) ? val : null;
 }
-function userPromptFromRecord(obj, wantCodex) {
-  if (wantCodex) {
+function userPromptFromRecord(obj, engine) {
+  if (engine === "openclaw") {
+    const message = openclawMessage(obj);
+    if (!message || message.role !== "user")
+      return null;
+    const content = message.content;
+    if (typeof content === "string")
+      return content.trim() || null;
+    const text2 = recordsValue(content).filter((part) => part.type === "text").map((part) => stringValue(part.text) ?? "").join(" ").trim();
+    return text2 || null;
+  }
+  if (engine === "codex") {
     const payload = recordValue(obj.payload) ?? {};
     if (payload.type === "user_message") {
       const prompt = typeof payload.message === "string" ? payload.message.trim() : "";
@@ -27886,7 +28929,7 @@ function userPromptFromRecord(obj, wantCodex) {
   }
   return null;
 }
-function titleFromLines(lines, wantCodex) {
+function titleFromLines(lines, engine) {
   for (const line of lines) {
     let obj;
     try {
@@ -27907,7 +28950,7 @@ function titleFromLines(lines, wantCodex) {
       if (title2)
         return title2;
     }
-    const title = goodTitle(userPromptFromRecord(obj, wantCodex));
+    const title = goodTitle(userPromptFromRecord(obj, engine));
     if (title)
       return title;
   }
@@ -27998,7 +29041,7 @@ function projectInfoFromSlug(slug, stateKey) {
   const persisted = persistedProjects(stateKey).bySlug.get(slug);
   return persisted ? aliasedProjectInfo(persisted.project, persisted.worktree, persisted.repo) : null;
 }
-function scanJsonlTitle(pathname, st, wantCodex) {
+function scanJsonlTitle(pathname, st, engine) {
   const cached3 = titleCache.get(pathname);
   if (cached3?.size === st.size && cached3.mtimeMs === st.mtimeMs) {
     return { value: cached3.value, complete: true, headPreserved: true };
@@ -28014,7 +29057,7 @@ function scanJsonlTitle(pathname, st, wantCodex) {
     }
   }
   const title = titleFromLines(head.value.text.split(`
-`).slice(0, 151), wantCodex);
+`).slice(0, 151), engine);
   titleCache.set(pathname, cacheHeadMetadata(st, head.value, title));
   return { value: title, complete: true, headPreserved: false };
 }
@@ -28050,7 +29093,7 @@ function deriveTranscriptMetadata(rootName, pathname, st, identity) {
     kind = "session";
     fmt = "codex";
     if (complete) {
-      const titleRead = scanJsonlTitle(pathname, st, true);
+      const titleRead = scanJsonlTitle(pathname, st, "codex");
       complete &&= titleRead.complete;
       title = titleRead.value;
     }
@@ -28073,7 +29116,7 @@ function deriveTranscriptMetadata(rootName, pathname, st, identity) {
       const meta = sidecar.value ?? {};
       title = stringValue(meta.description) ?? stringValue(meta.name) ?? null;
       if (!title && complete) {
-        const titleRead = scanJsonlTitle(pathname, st, false);
+        const titleRead = scanJsonlTitle(pathname, st, "claude");
         complete &&= titleRead.complete;
         title = titleRead.value;
       }
@@ -28081,12 +29124,31 @@ function deriveTranscriptMetadata(rootName, pathname, st, identity) {
     } else {
       kind = "session";
       if (complete) {
-        const titleRead = scanJsonlTitle(pathname, st, false);
+        const titleRead = scanJsonlTitle(pathname, st, "claude");
         complete &&= titleRead.complete;
         title = titleRead.value;
       }
       title ??= "Claude session";
     }
+  } else if (rootName === "openclaw-sessions") {
+    const cwdRead = complete ? transcriptCwd(pathname, st) : { value: null, complete: false, headPreserved: false };
+    complete &&= cwdRead.complete;
+    cwdComplete = cwdRead.complete;
+    cwd = cwdRead.value ?? undefined;
+    if (complete) {
+      const startedAtRead = transcriptStartedAt(pathname, st);
+      complete &&= startedAtRead.complete;
+      sessionStartedAt = startedAtRead.value;
+    }
+    engine = "openclaw";
+    kind = "session";
+    fmt = "openclaw";
+    if (complete) {
+      const titleRead = scanJsonlTitle(pathname, st, "openclaw");
+      complete &&= titleRead.complete;
+      title = titleRead.value;
+    }
+    title ??= "OpenClaw session";
   } else if (rootName === "claude-tasks") {
     engine = "shell";
     kind = "background";
@@ -28126,6 +29188,8 @@ function resolveProjectOverlay(rootName, root, pathname, cwd, cwdAuthoritative,
     const slug = rel.split(path43.sep)[0] ?? "";
     const worktreeInfo = worktreeFromSlug(slug);
     info = (cwd ? projectInfoFromCwd(cwd, stateKey) : null) ?? projectInfoFromTranscript(pathname, stateKey) ?? (worktreeInfo ? aliasedProjectInfo(worktreeInfo.project, worktreeInfo.worktree, worktreeInfo.repo) : aliasedProjectInfo(projectFromSlug(slug)));
+  } else if (rootName === "openclaw-sessions") {
+    info = (cwd ? projectInfoFromCwd(cwd, stateKey) : null) ?? projectInfoFromTranscript(pathname, stateKey);
   } else if (rootName === "claude-tasks") {
     const rel = path43.relative(root, pathname);
     const slug = rel.split(path43.sep)[0] ?? "";
@@ -28192,16 +29256,18 @@ function describeFile(rootName, root, pathname, st, stateKey = projectResolution
 function describe(rootName, root, pathname, st, stateKey = projectResolutionStateKey(), identity = fileDescriptionIdentity(rootName, pathname, st)) {
   return describeFile(rootName, root, pathname, st, stateKey, identity).description;
 }
-var transcriptMetaCache, projectOverlayCache, titleCache, repoSlugCache, cwdCache, sessionStartedAtCache, HEAD_BYTES2, skipTitlePrefixes, worktreeGitCache, WORKTREE_TTL_MS = 60000, projectInfoCwdCache, PROJECT_INFO_CWD_TTL_MS = 1e4, persistedProjectCache, PERSISTED_PROJECT_TTL_MS = 1e4, WORKTREE_MAP_FILE = "worktree-map.json", worktreeMemory = null, worktreeMemoryDirty = false;
+var transcriptMetaCache, projectOverlayCache, titleCache, repoSlugCache, cwdCache, sessionStartedAtCache, HEAD_BYTES2, skipTitlePrefixes, worktreeGitCache, WORKTREE_TTL_MS = 60000, projectInfoCwdCache, PROJECT_INFO_CWD_TTL_MS = 1e4, persistedProjectCache, PERSISTED_PROJECT_TTL_MS = 1e4, WORKTREE_MAP_FILE = "worktree-map.json", worktreeMemory = null, worktreeMemoryDirty = false, OPENCLAW_STATE_DIRECTORY;
 var init_describe = __esm(() => {
   init_configDir();
   init_aliases();
   init_sqliteStateStore();
   init_identity();
+  init_title();
   init_caches();
   init_codexNative();
   init_head();
   init_json();
+  init_openclawNative();
   init_projectState();
   globalCache("meta-v4").clear();
   globalCache("title-v2").clear();
@@ -28220,6 +29286,7 @@ var init_describe = __esm(() => {
   worktreeGitCache = globalCache("worktree-git");
   projectInfoCwdCache = globalCache("project-info-cwd-v2");
   persistedProjectCache = globalCache("persisted-project-v2");
+  OPENCLAW_STATE_DIRECTORY = /^\.openclaw(?:-[A-Za-z0-9._-]+)?$/;
 });
 
 // src/lib/pipelines/controllerSignal.ts
@@ -28418,7 +29485,7 @@ function scanEventStream(stdout) {
   }
   return { sessionId, lastAgentMessage };
 }
-function reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, claudeAccount, spawnCapability) {
+function reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, claudeAccount, spawnCapability, options = {}) {
   if (role.engine === "claude") {
     const sessionId = crypto24.randomUUID();
     const args2 = [
@@ -28441,7 +29508,17 @@ function reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, cla
     const baseEnv = claudeAccount?.managed ? claudeManagedEnvironment(claudeAccount.home) : process.env;
     return { command: resolveBinary("claude"), args: args2, env: reviewerEnvironment(baseEnv, spawnCapability), stdin: null, outputPath: null, sessionId, reviewerPath: claudeTranscriptPath(cwd, sessionId, claudeAccount?.projectsDir) };
   }
-  const args = ["--disable", "multi_agent", "exec", "--ignore-user-config", "-", "--json", "--output-last-message", outputPath, "--dangerously-bypass-approvals-and-sandbox"];
+  const args = [
+    "--disable",
+    "multi_agent",
+    "exec",
+    "--ignore-user-config",
+    "-",
+    "--json",
+    "--output-last-message",
+    outputPath,
+    ...options.sandbox === "read-only" ? ["-s", "read-only", "--skip-git-repo-check"] : ["--dangerously-bypass-approvals-and-sandbox"]
+  ];
   if (codexAccount?.managed)
     args.unshift("-c", "cli_auth_credentials_store=file");
   if (role.model)
@@ -28458,34 +29535,29 @@ function reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, cla
     reviewerPath: null
   };
 }
-function startHeadlessReview(flowId, round, role, cwd, reviewRequest, timeoutMs = DEFAULT_TIMEOUT_MS4, codexAccount, claudeAccount, runtime2, spawnCapability) {
-  const key2 = runKey(flowId, round);
-  if (runs.has(key2))
-    return { pid: null, identity: null, sessionId: null, reviewerPath: null };
-  const outputPath = outputPathFor(flowId, round);
-  fs48.mkdirSync(path44.dirname(outputPath), { recursive: true });
-  clearHeadlessReviewArtifacts(flowId, round);
-  const built = reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, claudeAccount, spawnCapability);
-  const stdoutFd = fs48.openSync(stdoutPathFor(flowId, round), "w");
-  const stderrFd = fs48.openSync(stderrPathFor(flowId, round), "w");
+function launchDetached(input) {
+  if (runs.has(input.key))
+    return null;
+  const stdoutFd = fs48.openSync(input.stdoutPath, "w");
+  const stderrFd = fs48.openSync(input.stderrPath, "w");
   let child;
   try {
-    child = spawn6(runtime2?.command ?? built.command, built.args, {
-      cwd,
-      env: built.env,
+    child = spawn6(input.runtime?.command ?? input.built.command, input.built.args, {
+      cwd: input.cwd,
+      env: input.built.env,
       detached: true,
-      stdio: [built.stdin === null ? "ignore" : "pipe", stdoutFd, stderrFd]
+      stdio: [input.built.stdin === null ? "ignore" : "pipe", stdoutFd, stderrFd]
     });
-    if (built.stdin !== null && child.stdin) {
+    if (input.built.stdin !== null && child.stdin) {
       child.stdin.on("error", () => {});
-      child.stdin.end(built.stdin, "utf8");
+      child.stdin.end(input.built.stdin, "utf8");
     }
   } finally {
     fs48.closeSync(stdoutFd);
     fs48.closeSync(stderrFd);
   }
   child.unref();
-  const identityOf = runtime2?.processIdentity ?? procBackend.processIdentity;
+  const identityOf = input.runtime?.processIdentity ?? procBackend.processIdentity;
   const identity = child.pid ? identityOf(child.pid) : null;
   const run = {
     child,
@@ -28495,31 +29567,55 @@ function startHeadlessReview(flowId, round, role, cwd, reviewRequest, timeoutMs
     exit: null,
     terminationStarted: false,
     timer: setTimeout(() => {
+      input.onTimeout?.();
       killOwnedRun(run);
-    }, timeoutMs)
+    }, input.timeoutMs)
   };
   run.timer.unref();
-  runs.set(key2, run);
-  let completionSignaled = false;
-  const signalCompletion = () => {
-    if (completionSignaled)
-      return;
-    completionSignaled = true;
-    requestPipelineTick();
-  };
+  runs.set(input.key, run);
   child.on("error", () => {
     clearTimeout(run.timer);
     run.exit = { code: null, signal: null };
     killOwnedRun(run);
-    signalCompletion();
+    input.onExit(run);
   });
   child.on("close", (code, signal3) => {
     clearTimeout(run.timer);
     run.exit = { code, signal: signal3 };
     killOwnedRun(run);
-    signalCompletion();
+    input.onExit(run);
   });
-  return { pid: child.pid ?? null, identity, sessionId: built.sessionId, reviewerPath: built.reviewerPath };
+  return { pid: child.pid ?? null, identity };
+}
+function startHeadlessReview(flowId, round, role, cwd, reviewRequest, timeoutMs = DEFAULT_TIMEOUT_MS4, codexAccount, claudeAccount, runtime2, spawnCapability) {
+  const key2 = runKey(flowId, round);
+  const idle = { pid: null, identity: null, sessionId: null, reviewerPath: null };
+  if (runs.has(key2))
+    return idle;
+  const outputPath = outputPathFor(flowId, round);
+  fs48.mkdirSync(path44.dirname(outputPath), { recursive: true });
+  clearHeadlessReviewArtifacts(flowId, round);
+  const built = reviewerCommand(role, reviewRequest, outputPath, cwd, codexAccount, claudeAccount, spawnCapability);
+  let completionSignaled = false;
+  const signalCompletion = () => {
+    if (completionSignaled)
+      return;
+    completionSignaled = true;
+    requestPipelineTick();
+  };
+  const launched = launchDetached({
+    key: key2,
+    built,
+    cwd,
+    stdoutPath: stdoutPathFor(flowId, round),
+    stderrPath: stderrPathFor(flowId, round),
+    timeoutMs,
+    runtime: runtime2,
+    onExit: signalCompletion
+  });
+  if (!launched)
+    return idle;
+  return { pid: launched.pid, identity: launched.identity, sessionId: built.sessionId, reviewerPath: built.reviewerPath };
 }
 function clearHeadlessReviewArtifacts(flowId, round) {
   for (const artifact of [outputPathFor(flowId, round), stdoutPathFor(flowId, round), stderrPathFor(flowId, round)]) {
@@ -29924,10 +31020,14 @@ var init_provision = __esm(() => {
 });
 
 // src/lib/pipelines/durableEvidence.ts
+var CODEX_TURN_END_TYPES, CODEX_TURN_START_TYPES;
 var init_durableEvidence = __esm(() => {
   init_turnState();
   init_findings();
   init_activity();
+  init_json();
+  CODEX_TURN_END_TYPES = new Set(["task_complete", "turn_complete", "turn_completed", "turn_aborted"]);
+  CODEX_TURN_START_TYPES = new Set(["task_started", "turn_started", "user_message"]);
 });
 // src/lib/pipelines/limits.ts
 var MAX_STAGE_PROMPT_LENGTH = 8000, MAX_FAIL_EDGE_ROUNDS = 9;
@@ -29935,7 +31035,7 @@ var MAX_STAGE_PROMPT_LENGTH = 8000, MAX_FAIL_EDGE_ROUNDS = 9;
 // src/lib/pipelines/preflight.ts
 import { spawnSync as spawnSync5 } from "child_process";
 import fs53 from "fs";
-import os10 from "os";
+import os11 from "os";
 var GIT_PROBE_TIMEOUT_MS = 4000, boundedGitExec = (command, args, cwd) => {
   if (command !== "git")
     return realExec(command, args, cwd);
@@ -29949,7 +31049,7 @@ var GIT_PROBE_TIMEOUT_MS = 4000, boundedGitExec = (command, args, cwd) => {
 var init_preflight = __esm(() => {
   init_provision();
   DEFAULT_PORTS = {
-    homeDir: os10.homedir,
+    homeDir: os11.homedir,
     stat: fs53.statSync,
     access: fs53.accessSync,
     exec: boundedGitExec
@@ -29957,7 +31057,7 @@ var init_preflight = __esm(() => {
   preflightCache = new Map;
 });
 // src/lib/pipelines/types.ts
-var init_types2 = () => {};
+var init_types3 = () => {};
 
 // src/lib/pipelines/roles.ts
 var PIPELINE_ROLE_IDS;
@@ -29966,7 +31066,7 @@ var init_roles = __esm(() => {
   init_store();
   init_efforts();
   init_models();
-  init_types2();
+  init_types3();
   PIPELINE_ROLE_IDS = [
     "orchestrator",
     "reviewer",
@@ -30022,9 +31122,9 @@ var init_engine = __esm(() => {
   init_commands();
   init_findings();
   init_store2();
-  init_handoffLineage();
   init_pauseResumeActor();
   init_client();
+  init_structuredDeliveryController();
   init_redact();
   init_review();
   init_structuredSpawn();
@@ -30032,6 +31132,7 @@ var init_engine = __esm(() => {
   init_store4();
   init_roots();
   init_status();
+  init_title();
   init_tmux();
   init_provision();
   init_controllerSignal2();
@@ -30072,6 +31173,12 @@ var init_engine = __esm(() => {
   STAGE_ON_FAIL_SHAPE = `null, or {to: <existing stage id>, maxRounds?: 1\u2013${MAX_FAIL_EDGE_ROUNDS}} \u2014 run stages only`;
 });
 
+// src/lib/bridge/types.ts
+var BRIDGE_ASK_TTL_SECONDS;
+var init_types4 = __esm(() => {
+  BRIDGE_ASK_TTL_SECONDS = 2 * 3600;
+});
+
 // src/lib/displayNames.ts
 var KNOWN_ROLE_WORDS;
 var init_displayNames = __esm(() => {
@@ -30098,6 +31205,7 @@ var init_projectModel = __esm(() => {
 // src/components/attention.ts
 var STALLED_ATTENTION_TTL;
 var init_attention = __esm(() => {
+  init_types4();
   init_projectModel();
   STALLED_ATTENTION_TTL = 2 * 3600;
 });
@@ -30144,6 +31252,7 @@ var init_projectResolution = __esm(() => {
 var init_titleStore = __esm(() => {
   init_sessionKey();
   init_configDir();
+  init_title();
 });
 
 // src/lib/session/renameEligibility.ts
@@ -30153,7 +31262,7 @@ var init_renameEligibility = __esm(() => {
 });
 
 // src/lib/session/titleProjection.ts
-function canonicalConversationId(snapshot2, alias) {
+function canonicalConversationId2(snapshot2, alias) {
   let current = alias;
   const seen = new Set;
   while (!seen.has(current)) {
@@ -30203,7 +31312,7 @@ function projectRegistrySnapshot(snapshot2, signature, includeProjects = true) {
     }
   }
   for (const alias of Object.keys(snapshot2.conversationAliases)) {
-    const canonical = canonicalConversationId(snapshot2, alias);
+    const canonical = canonicalConversationId2(snapshot2, alias);
     if (canonical === alias)
       continue;
     const list = aliasesByCanonical.get(canonical);
@@ -30869,9 +31978,9 @@ function defaultPorts() {
     exec: realExec,
     startSetup,
     setupStatus,
-    spawnAgent: async (role, cwd, prompt, accountId) => {
+    spawnAgent: async (role, cwd, prompt, accountId, title) => {
       const account2 = accountManager.resolveSpawn(role.engine, accountId);
-      const spec = freshSpecFor(role.engine, cwd, { model: role.model, effort: role.effort, codexHome: account2.engine === "codex" ? account2.home : null, claudeConfigDir: account2.engine === "claude" ? account2.home : null, claudeProjectsDir: account2.engine === "claude" ? account2.transcriptRoot : null });
+      const spec = freshSpecFor(role.engine, cwd, { title, model: role.model, effort: role.effort, codexHome: account2.engine === "codex" ? account2.home : null, claudeConfigDir: account2.engine === "claude" ? account2.home : null, claudeProjectsDir: account2.engine === "claude" ? account2.transcriptRoot : null });
       const startedAtMs = Date.now();
       const pane = await spawnAgentWithPrompt(spec, prompt);
       const transcript = await resolveSpawnedTranscriptPath({
@@ -30906,6 +32015,12 @@ function defaultPorts() {
 function spawnKey(wf, run) {
   return `${wf.id}:${run.index}`;
 }
+function stageSpawnTitle(wf, run) {
+  const stage = wf.template.stages[run.index];
+  const stageLabel = stage?.kind === "review-loop" ? "review fixer" : `stage ${run.index + 1}`;
+  const suffix = ` \xB7 ${stageLabel}`;
+  return `${cleanTitle(wf.task, 120 - suffix.length)}${suffix}`;
+}
 function park(wf, detail) {
   wf.pausedState = wf.state;
   wf.state = "needs_decision";
@@ -30993,7 +32108,7 @@ async function ensureStageAgent(wf, run, role, stagePrompt, entries, ports, pers
     spawnsThisProcess2.add(spawnKey(wf, run));
     persistCheckpoint();
     try {
-      const spawned = await ports.spawnAgent(role, wf.worktreeDir, stagePrompt, run.accountId);
+      const spawned = await ports.spawnAgent(role, wf.worktreeDir, stagePrompt, run.accountId, stageSpawnTitle(wf, run));
       run.paneId = spawned.paneId;
       if (spawned.transcript) {
         run.agentPath = spawned.transcript;
@@ -31218,6 +32333,7 @@ var init_engine2 = __esm(() => {
   init_describe();
   init_status();
   init_tmux();
+  init_title();
   init_provision();
   init_store5();
   TERMINAL_STATES2 = new Set(["approved", "closed"]);
@@ -31390,15 +32506,6 @@ function isCommandCaveatText(text2) {
 function isTaskNotificationText(text2) {
   return /^<task-notification\b[^>]*>[\s\S]*<\/task-notification>$/.test(text2);
 }
-function isClaudeProtocolUser(record9) {
-  if (originKindOf(record9) === "human" || str2(record9.promptSource) === "typed")
-    return false;
-  if (record9.isMeta === true || record9.isCompactSummary === true || "interruptedMessageId" in record9 || "promptSource" in record9 || "origin" in record9) {
-    return true;
-  }
-  const text2 = claudeUserText(rec2(record9.message).content).trim();
-  return isClaudeInterruptSentinelText(text2) || isCommandCaveatText(text2) || isTaskNotificationText(text2) || /^This came from another Claude session\b[\s\S]*not typed by your user[\s\S]*$/.test(text2);
-}
 function isClaudeTurnWindowMeta(record9) {
   const originKind = originKindOf(record9);
   if (originKind === "human" || originKind === "peer" || originKind === "coordinator")
@@ -31536,8 +32643,6 @@ function recentTurnWindowsFromRecords(records, codex) {
   return windows;
 }
 function recentTurnActivityFromRecords(records, codex) {
-  const operatorActions = new Set;
-  const unprovenancedUserActions = new Set;
   const assistantMessages = new Set;
   for (const record9 of records) {
     const atMs = parseMillis(record9.timestamp);
@@ -31545,32 +32650,9 @@ function recentTurnActivityFromRecords(records, codex) {
       continue;
     if (visibleAssistantMessage(record9, codex))
       assistantMessages.add(atMs);
-    if (codex) {
-      const payload = recordValue(record9.payload) ?? {};
-      let text2 = "";
-      if (stringValue(payload.type) === "user_message") {
-        text2 = stringValue(payload.message) ?? "";
-      } else if (stringValue(payload.type) === "message" && payload.role === "user") {
-        text2 = recordsValue(payload.content).map((part) => stringValue(part.text) ?? stringValue(part.input_text) ?? "").join(`
-`);
-      }
-      if (text2 && decodeCodexStructuredUserText(text2).structured)
-        operatorActions.add(atMs);
-      continue;
-    }
-    if (!isTurnStart(record9, false))
-      continue;
-    const originKind = typeof record9.origin === "string" ? record9.origin : stringValue(recordValue(record9.origin)?.kind);
-    if (originKind === "human" || record9.promptSource === "typed") {
-      operatorActions.add(atMs);
-    } else if (!isClaudeProtocolUser(record9)) {
-      unprovenancedUserActions.add(atMs);
-    }
   }
   return {
     windows: recentTurnWindowsFromRecords(records, codex),
-    operatorActionsAtMs: [...operatorActions].sort((left, right) => left - right),
-    unprovenancedUserActionsAtMs: [...unprovenancedUserActions].sort((left, right) => left - right),
     assistantMessagesAtMs: [...assistantMessages].sort((left, right) => left - right)
   };
 }
@@ -31620,7 +32702,6 @@ function lastAssistantMessageAtFor(entry) {
 }
 var turnBoundaryCache, recentTurnWindowsCache;
 var init_turnDuration = __esm(() => {
-  init_codexStructuredUserText();
   init_activity();
   init_caches();
   init_json();
@@ -32051,11 +33132,11 @@ function readState() {
       if (!value || typeof value !== "object" || Array.isArray(value))
         continue;
       const file = value;
-      if (file.rootName !== "codex-sessions" && file.rootName !== "claude-projects" && file.rootName !== "claude-tasks" || typeof file.size !== "number" || typeof file.mtimeMs !== "number" || typeof file.stateKey !== "string" || typeof file.project !== "string" || file.projectName !== undefined && typeof file.projectName !== "string" || file.projectUnresolved !== undefined && file.projectUnresolved !== true || file.projectRoot !== undefined && file.projectRoot !== null && typeof file.projectRoot !== "string" || typeof file.kind !== "string") {
+      if (file.rootName !== "codex-sessions" && file.rootName !== "claude-projects" && file.rootName !== "claude-tasks" && file.rootName !== "openclaw-sessions" || typeof file.size !== "number" || typeof file.mtimeMs !== "number" || typeof file.stateKey !== "string" || typeof file.project !== "string" || file.projectName !== undefined && typeof file.projectName !== "string" || file.projectUnresolved !== undefined && file.projectUnresolved !== true || file.projectRoot !== undefined && file.projectRoot !== null && typeof file.projectRoot !== "string" || typeof file.kind !== "string") {
         continue;
       }
-      const engine = file.engine === "codex" || file.engine === "claude" || file.engine === "shell" ? file.engine : undefined;
-      const fmt = file.fmt === "codex" || file.fmt === "claude" || file.fmt === "plain" ? file.fmt : undefined;
+      const engine = file.engine === "codex" || file.engine === "claude" || file.engine === "shell" || file.engine === "openclaw" ? file.engine : undefined;
+      const fmt = file.fmt === "codex" || file.fmt === "claude" || file.fmt === "plain" || file.fmt === "openclaw" ? file.fmt : undefined;
       const cwd = typeof file.cwd === "string" ? file.cwd : file.cwd === null ? null : undefined;
       const sessionStartedAt = typeof file.sessionStartedAt === "string" ? file.sessionStartedAt : file.sessionStartedAt === null ? null : undefined;
       const nativeParentThreadId = typeof file.nativeParentThreadId === "string" ? file.nativeParentThreadId : file.nativeParentThreadId === null ? null : undefined;
@@ -32128,13 +33209,15 @@ function writeState(state3) {
   }
 }
 function isConversation(rootName, kind) {
-  return rootName === "codex-sessions" || rootName === "claude-projects" && (kind === "session" || kind === "subagent");
+  return rootName === "codex-sessions" || rootName === "openclaw-sessions" || rootName === "claude-projects" && (kind === "session" || kind === "subagent");
 }
 function engineForRoot(rootName) {
   if (rootName === "codex-sessions")
     return "codex";
   if (rootName === "claude-projects")
     return "claude";
+  if (rootName === "openclaw-sessions")
+    return "openclaw";
   return "shell";
 }
 function fmtForRoot(rootName) {
@@ -32142,6 +33225,8 @@ function fmtForRoot(rootName) {
     return "codex";
   if (rootName === "claude-projects")
     return "claude";
+  if (rootName === "openclaw-sessions")
+    return "openclaw";
   return "plain";
 }
 function fallbackTitle(raw, kind) {
@@ -32152,6 +33237,8 @@ function fallbackTitle(raw, kind) {
     return "Codex session";
   if (raw.rootName === "claude-projects")
     return "Claude session";
+  if (raw.rootName === "openclaw-sessions")
+    return "OpenClaw session";
   return "Background task " + filename.split(".")[0];
 }
 function storeCachedFile(state3, file) {
@@ -32439,7 +33526,7 @@ async function projectCatalogSnapshotFromRaw(raw, options = {}) {
       kind: file.kind,
       fmt: file.fmt
     });
-    if (!file.session || file.engine !== "codex" && file.engine !== "claude")
+    if (!file.session || file.engine !== "codex" && file.engine !== "claude" && file.engine !== "openclaw")
       return;
     conversationCatalog.push({
       path: file.path,
@@ -32655,6 +33742,8 @@ async function walkPaths(rootName, root, dir, limit) {
     }
     if (!entry.isFile() || !EXTS.some((ext) => entry.name.endsWith(ext)))
       return { paths: [], complete: true };
+    if (rootName === "openclaw-sessions" && !isOpenclawTranscript(entry.name))
+      return { paths: [], complete: true };
     return { paths: [{ rootName, root, path: path55.join(dir, entry.name) }], complete: true };
   }));
   return {
@@ -32724,13 +33813,13 @@ function canonicalizerFor(roots) {
 function transcriptIndexFeed(catalog, complete, projectByPath) {
   return {
     complete,
-    sources: catalog.map((entry) => ({
+    sources: catalog.flatMap((entry) => entry.engine === "openclaw" ? [] : [{
       path: entry.path,
       project: projectByPath?.get(entry.path) ?? entry.project,
       engine: entry.engine,
       size: entry.size,
       mtimeMs: entry.mtime * 1000
-    }))
+    }])
   };
 }
 function publishTranscriptIndexFeed(catalog, complete, scanToken, projectByPath, scheduler) {
@@ -32776,7 +33865,7 @@ function isLiveEntry(entry, hosted) {
     return true;
   if (!entry.path.endsWith(".jsonl"))
     return false;
-  const turn = cachedTranscriptTurn(entry.path, entry.st.size, entry.st.mtimeMs, entry.rootName === "codex-sessions");
+  const turn = cachedTranscriptTurn(entry.path, entry.st.size, entry.st.mtimeMs, transcriptEngineForRoot(entry.rootName));
   return turn?.state === "busy";
 }
 async function primeElidedOpenTurns(ranked, selected) {
@@ -32787,13 +33876,13 @@ async function primeElidedOpenTurns(ranked, selected) {
       break;
     if (selected.has(entry.path) || !entry.path.endsWith(".jsonl") || entry.st.mtimeMs <= horizon)
       continue;
-    const codex = entry.rootName === "codex-sessions";
-    if (!cachedTranscriptTurn(entry.path, entry.st.size, entry.st.mtimeMs, codex))
+    const engine = transcriptEngineForRoot(entry.rootName);
+    if (!cachedTranscriptTurn(entry.path, entry.st.size, entry.st.mtimeMs, engine))
       candidates.push(entry);
   }
   let open = false;
   await forEachCooperatively(candidates, (entry) => {
-    const turn = transcriptTurnResult(entry.path, entry.st.size, entry.st.mtimeMs, entry.rootName === "codex-sessions", false);
+    const turn = transcriptTurnResult(entry.path, entry.st.size, entry.st.mtimeMs, transcriptEngineForRoot(entry.rootName), false);
     open ||= turn.turn.state === "busy";
   });
   return open;
@@ -32822,7 +33911,7 @@ function resourceScopeFromPaths(raw, baseline) {
   const conversations = raw.filter((entry) => entry.rootName !== "claude-tasks" && entry.path.endsWith(".jsonl"));
   const files = conversations.map((entry) => {
     const previous = previousByPath.get(entry.path);
-    const engine = entry.rootName === "codex-sessions" ? "codex" : "claude";
+    const engine = entry.rootName === "codex-sessions" ? "codex" : entry.rootName === "openclaw-sessions" ? "openclaw" : "claude";
     const mtime = previous?.mtime ?? Date.now() / 1000;
     const size = previous?.size ?? 1;
     const activity = resourceActivity(previous, mtime, size);
@@ -32840,7 +33929,7 @@ function resourceScopeFromPaths(raw, baseline) {
       nativeForkSourceThreadId: previous?.nativeForkSourceThreadId,
       projectRoot: previous?.projectRoot,
       worktree: previous?.worktree,
-      title: previous?.title ?? (filename.startsWith("agent-") ? `Subagent ${filename.slice(6).split(".")[0]}` : `${engine === "codex" ? "Codex" : "Claude"} session`),
+      title: previous?.title ?? (filename.startsWith("agent-") ? `Subagent ${filename.slice(6).split(".")[0]}` : `${ENGINE_LABEL[engine]} session`),
       engine,
       kind: previous?.kind ?? (filename.startsWith("agent-") ? "subagent" : "session"),
       fmt: engine,
@@ -33020,13 +34109,14 @@ async function discoverFiles(roots = scanRootEntries(), demote, pin, hosted) {
   publishTranscriptIndexFeed(snapshot2.conversationCatalog, snapshot2.complete, scanToken, projectByPath);
   return entries.files;
 }
-var DISCOVERY_DIAGNOSTIC_MS = 60000, lastDiscoveryDiagnosticAt, OPEN_TURN_PROBE_WINDOW_MS = 180000, OPEN_TURN_PROBE_LIMIT = 32;
+var DISCOVERY_DIAGNOSTIC_MS = 60000, lastDiscoveryDiagnosticAt, OPEN_TURN_PROBE_WINDOW_MS = 180000, OPEN_TURN_PROBE_LIMIT = 32, ENGINE_LABEL;
 var init_discover = __esm(() => {
   init_cooperative();
   init_titleProjection();
   init_transcriptFeed();
   init_claudeNative();
   init_codexNative();
+  init_openclawNative();
   init_describe();
   init_projectCatalog();
   init_projectState();
@@ -33034,6 +34124,7 @@ var init_discover = __esm(() => {
   init_activity();
   init_transcriptIdentity();
   lastDiscoveryDiagnosticAt = Number.NEGATIVE_INFINITY;
+  ENGINE_LABEL = { codex: "Codex", claude: "Claude", openclaw: "OpenClaw" };
 });
 
 // src/lib/scanner/effort.ts
@@ -33050,6 +34141,9 @@ function pickEffort(entry, obj) {
     const settings = recordValue(recordValue(payload?.collaboration_mode)?.settings);
     return stringValue(settings?.reasoning_effort);
   }
+  if (entry.root === "openclaw-sessions" && obj.type === "thinking_level_change") {
+    return stringValue(obj.thinkingLevel);
+  }
   if (entry.root === "claude-projects" && obj.type === "assistant") {
     const message = recordValue(obj.message);
     const content = recordsValue(message?.content);
@@ -33077,7 +34171,7 @@ function entryEffort(entry) {
   return entryEffortResult(entry).value;
 }
 function entryEffortResult(entry) {
-  if (entry.root !== "claude-projects" && entry.root !== "codex-sessions" || !entry.path.endsWith(".jsonl")) {
+  if (entry.root !== "claude-projects" && entry.root !== "codex-sessions" && entry.root !== "openclaw-sessions" || !entry.path.endsWith(".jsonl")) {
     return { value: null, complete: true };
   }
   const argv = normalizeEffort(argvEffort(entry));
@@ -33128,7 +34222,32 @@ var init_effort = __esm(() => {
   init_json();
   init_process();
   effortCache = globalCache("effort");
-  TIERS = new Set(["minimal", "low", "medium", "high", "xhigh", "max", "ultra"]);
+  TIERS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max", "ultra", "adaptive"]);
+});
+
+// src/lib/agent/spawnProjection.ts
+function durableHandoffProvenanceForConversation(snapshot2, conversationId, lookup = readOnlyConversationLookupFromSnapshot(snapshot2)) {
+  const canonicalConversationId3 = lookup.canonicalConversationId(conversationId);
+  const edge = snapshot2.lineageEdges[canonicalConversationId3];
+  if (!edge || edge.source !== "viewer-spawn")
+    return null;
+  const receipt = edge.evidence.launchId ? snapshot2.receipts[edge.evidence.launchId] : null;
+  const parentConversationId = lookup.canonicalConversationId(edge.parentConversationId);
+  const bornAt = receipt?.createdAt ?? edge.createdAt;
+  const bornIntoContainer = (snapshot2.memberships[canonicalConversationId3] ?? []).some((membership) => membership.createdAt === bornAt && membership.parentConversationId !== null && lookup.canonicalConversationId(membership.parentConversationId) === parentConversationId);
+  const parentSource = edge.evidence.parentSource ?? receipt?.parentSource ?? null;
+  const delegatedAtBirth = receipt?.delegationDepth !== null && receipt?.delegationDepth !== undefined && receipt.delegationDepth > 0;
+  if (bornIntoContainer || parentSource === "inferred-caller" || delegatedAtBirth)
+    return "container-spawn";
+  return "operator-handoff";
+}
+var TERMINAL_SPAWN_RECENT_MS, PLACEHOLDER_RETIREMENT_MS;
+var init_spawnProjection = __esm(() => {
+  init_registry();
+  init_describe();
+  init_projectResolution();
+  TERMINAL_SPAWN_RECENT_MS = 15 * 60 * 1000;
+  PLACEHOLDER_RETIREMENT_MS = 24 * 60 * 60 * 1000;
 });
 
 // src/lib/scanner/needle.ts
@@ -33800,6 +34919,26 @@ function bgCommand(tid, transcripts, fallbackTranscripts, budget) {
   }
   return weak;
 }
+function durableHandoffLineageFromSnapshot(snapshot2) {
+  const lookup = readOnlyConversationLookupFromSnapshot(snapshot2);
+  return {
+    provenanceForChild(pathname) {
+      const conversation = lookup.conversationForPath(pathname);
+      if (!conversation)
+        return null;
+      return durableHandoffProvenanceForConversation(snapshot2, conversation.id, lookup);
+    }
+  };
+}
+function currentDurableHandoffLineage() {
+  try {
+    return durableHandoffLineageFromSnapshot(agentRegistry().readOnlySnapshot());
+  } catch (error) {
+    if (error instanceof RegistryReadError)
+      return { provenanceForChild: () => null };
+    throw error;
+  }
+}
 function loadLineage() {
   if (lineageLoaded)
     return;
@@ -33897,9 +35036,12 @@ async function attachLiveCodexParents(entries, persist) {
   if (persist)
     persistLineage();
 }
-async function attachHandoffParents(entries, persist) {
+async function attachHandoffParents(entries, persist, durableLineage) {
   const byPath = new Map(entries.map((entry) => [entry.path, entry]));
   await forEachCooperatively(entries, (entry) => {
+    const durableProvenance = durableLineage.provenanceForChild(entry.path);
+    if (durableProvenance === "container-spawn")
+      delete entry.handoff;
     if (entry.parent)
       return;
     if (entry.root !== "claude-projects" && entry.root !== "codex-sessions")
@@ -33922,7 +35064,8 @@ async function attachHandoffParents(entries, persist) {
     }
     if (parent && parent !== entry.path && byPath.has(parent)) {
       entry.parent = parent;
-      entry.handoff = true;
+      if (durableProvenance !== "container-spawn")
+        entry.handoff = true;
     }
   });
   if (persist)
@@ -33930,6 +35073,7 @@ async function attachHandoffParents(entries, persist) {
 }
 async function linkEntries(entries, options = {}) {
   const persist = options.persist !== false;
+  const durableHandoffLineage = options.durableHandoffLineage ?? currentDurableHandoffLineage();
   loadBackgroundCommands();
   loadCompactChains();
   const limit = createLimiter2(48);
@@ -33988,7 +35132,7 @@ async function linkEntries(entries, options = {}) {
   });
   await attachNativeCodexSubagentParents(entries, persist);
   await attachLiveCodexParents(entries, persist);
-  await attachHandoffParents(entries, persist);
+  await attachHandoffParents(entries, persist, durableHandoffLineage);
   await chainCompactedSessions(entries);
   const rootProject = (entry) => {
     const seen = new Set;
@@ -34018,6 +35162,8 @@ var sidSlugCache, bgcmdCache, backgroundIndexCache, chainCache, compactLinkCache
 var init_links = __esm(() => {
   init_configDir();
   init_handoffLineage();
+  init_registry();
+  init_spawnProjection();
   init_cooperative();
   init_caches();
   init_claudeNative();
@@ -34055,6 +35201,8 @@ function pickModel(entry, obj) {
     if (obj.type === "turn_context" || obj.type === "session_meta") {
       return stringValue(recordValue(obj.payload)?.model);
     }
+  } else if (entry.root === "openclaw-sessions") {
+    return stringValue(openclawProviderAssistant(obj)?.model);
   } else if (obj.type === "assistant") {
     const model = stringValue(recordValue(obj.message)?.model);
     if (model && model !== "<synthetic>")
@@ -34069,7 +35217,7 @@ function entryModelsResult(entry) {
     if (model2)
       return { value: { display: shortModel(model2), launch: model2 }, complete: true };
   }
-  if (entry.root !== "claude-projects" && entry.root !== "codex-sessions" || !entry.path.endsWith(".jsonl")) {
+  if (entry.root !== "claude-projects" && entry.root !== "codex-sessions" && entry.root !== "openclaw-sessions" || !entry.path.endsWith(".jsonl")) {
     return { value: { display: null, launch: null }, complete: true };
   }
   const mtimeMs = entry.mtime * 1000;
@@ -34103,6 +35251,7 @@ var init_model = __esm(() => {
   init_activity();
   init_caches();
   init_json();
+  init_openclawNative();
   modelCache = globalCache("model");
 });
 
@@ -34768,8 +35917,8 @@ async function listFilesInternal(includeProjectCatalog, selectedProject, options
     entry.activity = verdict.state;
     entry.activityReason = verdict.reason;
     entry.derivationComplete = verdict.complete;
-    if (entry.path.endsWith(".jsonl") && (entry.engine === "claude" || entry.engine === "codex")) {
-      const authoritative = transcriptTurnResult(entry.path, entry.size, entry.mtime * 1000, entry.engine === "codex");
+    if (entry.path.endsWith(".jsonl") && (entry.engine === "claude" || entry.engine === "codex" || entry.engine === "openclaw")) {
+      const authoritative = transcriptTurnResult(entry.path, entry.size, entry.mtime * 1000, entry.engine);
       entry.derivationComplete &&= authoritative.complete;
       if (authoritative.complete)
         entry.authoritativeTurn = authoritative.turn;
@@ -35359,6 +36508,12 @@ function beginRegistryResume(entry, spec, registry = agentRegistry()) {
     return null;
   const conversation = registry.conversationForPath(entry.path) ?? registry.ensureConversation(entry.engine, entry.path, null);
   const current = conversation.generations.at(-1);
+  const launchProfile = emptyLaunchProfile({
+    ...current?.launchProfile ?? {},
+    ...spec.launchProfile ?? {},
+    cwd: spec.launchProfile?.cwd || current?.launchProfile.cwd || spec.cwd,
+    title: durableSemanticTitle(current?.launchProfile.title, 120) ?? durableSemanticTitle(spec.launchProfile?.title, 120) ?? derivedSpawnTitle("resume", current?.launchProfile.goal?.objective ?? spec.cwd, "Conversation resume")
+  });
   const begun = registry.beginSpawnRequest({
     engine: entry.engine,
     cwd: spec.cwd,
@@ -35366,9 +36521,9 @@ function beginRegistryResume(entry, spec, registry = agentRegistry()) {
     conversationId: conversation.id,
     purpose: "resume-successor",
     origin: { kind: "successor" },
-    launchProfile: spec.launchProfile ?? current?.launchProfile
+    launchProfile
   });
-  return { receipt: begun.receipt, spec };
+  return { receipt: begun.receipt, spec: { ...spec, launchProfile } };
 }
 async function serializeRegistryDelivery(entry, task) {
   if (entry.engine !== "claude" && entry.engine !== "codex")
@@ -35385,6 +36540,7 @@ async function serializeRegistryDelivery(entry, task) {
 }
 var UUID_RE4, MAX_ANCESTRY_HOPS2 = 64, CLAIM_RANK, globalStore, TranscriptHostConflictError, runtimeResolver, readTranscriptHosts, deliverToTranscriptHost;
 var init_transcriptHost = __esm(() => {
+  init_contracts2();
   init_registry();
   init_sessionKey();
   init_proc();
@@ -35393,6 +36549,7 @@ var init_transcriptHost = __esm(() => {
   init_process();
   init_claudeNative();
   init_tmux();
+  init_title();
   UUID_RE4 = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
   CLAIM_RANK = {
     scanner: 3,
@@ -35570,6 +36727,10 @@ function reserveReviewerSpawn(flow, round, role, accountId, registry = agentRegi
   const reviewerBindingId = round.reviewerBindingId ?? crypto32.randomUUID();
   round.reviewerBindingId = reviewerBindingId;
   const correlation = crypto32.createHash("sha256").update(`${flow.id}:${round.n}:${reviewerBindingId}`).digest("hex").slice(0, 24);
+  const clientAttemptId = `flow_${flow.id}_${correlation}`;
+  const reservedTitle = durableSemanticTitle(registry.spawnReceiptForClientAttempt(clientAttemptId)?.launchProfile.title, 120);
+  const flowTitle = firstPromptLine(flow.spec ?? "", 80) ?? durableSemanticTitle(owner.generations.at(-1)?.launchProfile.title, 80) ?? semanticTitle(flow.project, 80) ?? "Review flow";
+  const reviewerTitle = reservedTitle ?? cleanTitle(`${flowTitle} \xB7 review round ${round.n}`, 120);
   const begun = registry.beginSpawnRequest({
     engine: role.engine,
     cwd: flow.cwd,
@@ -35581,6 +36742,11 @@ function reserveReviewerSpawn(flow, round, role, accountId, registry = agentRegi
     role: "reviewer",
     reviewsConversationId: owner.id,
     origin: { kind: "container", container: "flow", containerId: flow.id, creatorConversationId: null },
+    launchProfile: emptyLaunchProfile({
+      cwd: flow.cwd,
+      parentConversationId: owner.id,
+      title: reviewerTitle
+    }),
     memberships: [{
       kind: "flow",
       containerId: flow.id,
@@ -35591,7 +36757,7 @@ function reserveReviewerSpawn(flow, round, role, accountId, registry = agentRegi
       round: round.n,
       parentConversationId: owner.id
     }],
-    clientAttemptId: `flow_${flow.id}_${correlation}`,
+    clientAttemptId,
     requestDigest: crypto32.createHash("sha256").update(JSON.stringify({
       flowId: flow.id,
       round: round.n,
@@ -36442,6 +37608,7 @@ var TERMINAL_STATES3, READY_RE, UUID_RE5, store3, relayStartedThisProcess, relay
 var init_engine3 = __esm(() => {
   init_cli();
   init_manager();
+  init_contracts2();
   init_transcriptHost();
   init_registry();
   init_sessionKey();
@@ -36451,6 +37618,7 @@ var init_engine3 = __esm(() => {
   init_structuredMessageDelivery();
   init_structuredRecovery();
   init_status();
+  init_title();
   init_tmux();
   init_exec();
   init_git();
@@ -36623,11 +37791,11 @@ class PreserializedJson {
 // src/runtime-host/runtimeHostFence.ts
 import crypto33 from "crypto";
 import fs63 from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import path59 from "path";
 function flock(fd, operation) {
   if (!cachedFlock) {
-    const runtimeRequire = createRequire2(import.meta.url);
+    const runtimeRequire = createRequire3(import.meta.url);
     const ffi = runtimeRequire(`bun:${"ffi"}`);
     const library = ffi.dlopen(process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", {
       flock: {
@@ -38175,7 +39343,7 @@ class RuntimeJournal {
       if (!session || session.host !== "hosted") {
         status = "rejected";
         reason = session?.host === "dead" || session?.host === "unhosted" ? "dead-host" : "no-claim";
-      } else if (!capability.supported || session.hostKind !== "codex-app-server") {
+      } else if (!capability.supported || session.hostKind !== "codex-app-server" && session.hostKind !== "claude-broker") {
         status = "rejected";
         reason = "unsupported-capability";
       } else if (session.sessionKey.engine !== command.sessionKey.engine || session.sessionKey.sessionId !== command.sessionKey.sessionId) {
@@ -38210,6 +39378,7 @@ class RuntimeJournal {
       status = "queued";
     }
     const revision = Number(this.db.query("SELECT revision FROM scope_revisions WHERE scope = ?").get(`operation:${operationId}`)?.revision ?? 0) + 1;
+    const admittedAt = new Date(this.now()).toISOString();
     return {
       operationId,
       ...retryOfOperationId ? { retryOfOperationId } : {},
@@ -38227,7 +39396,8 @@ class RuntimeJournal {
       text: command.kind === "send" || command.kind === "steer" ? command.text.slice(0, 240) : null,
       ...command.kind === "send" || command.kind === "steer" ? { imageCount: command.images?.length ?? 0 } : {},
       ...(command.kind === "send" || command.kind === "steer") && command.runtime ? { runtime: command.runtime } : {},
-      at: new Date(this.now()).toISOString(),
+      at: admittedAt,
+      admittedAt,
       revision
     };
   }
@@ -39162,6 +40332,7 @@ class ViewerDeploymentCoordinator {
   ownerAlive;
   hostGeneration;
   onHostHandoff;
+  log;
   constructor(journal, adapter, owner, options = {}) {
     this.journal = journal;
     this.adapter = adapter;
@@ -39170,6 +40341,7 @@ class ViewerDeploymentCoordinator {
     this.ownerAlive = options.ownerAlive ?? ((candidate) => procBackend.pidAlive(candidate.pid) && (candidate.startIdentity === null || procBackend.processIdentity(candidate.pid) === candidate.startIdentity));
     this.hostGeneration = options.hostGeneration;
     this.onHostHandoff = options.onHostHandoff;
+    this.log = options.log ?? ((line) => console.error(line));
   }
   async requestViewerDeployment(request) {
     return this.runAdmissionExclusive(() => this.admit(request));
@@ -39262,12 +40434,19 @@ class ViewerDeploymentCoordinator {
     return this.journal.viewerDeployment(deploymentId);
   }
   async stageDriftedHostSuccessor(status) {
-    if (!this.hostGeneration || !status.candidate)
+    const trace = (line) => this.log(`[viewer deployment] ${status.deploymentId} host-handoff ${line}`);
+    if (!this.hostGeneration || !status.candidate) {
+      trace("skipped: this runtime host does not track its own generation, so no successor can be staged");
       return null;
+    }
     const running = this.hostGeneration();
-    if (running.revision === status.revision && running.image === status.candidate.image)
+    if (running.revision === status.revision && running.image === status.candidate.image) {
+      trace(`not required: the runtime host already runs ${status.revision}`);
       return null;
+    }
+    trace(`staging a successor for ${status.revision}; the running generation is ${running.revision ?? "untracked"}`);
     await this.adapter.stageRuntimeHostSuccessor(status.candidate);
+    trace(`staged; the successor waits for the singleton fence while this generation hands off ${status.revision}`);
     return {
       deploymentId: status.deploymentId,
       revision: status.revision,
@@ -39278,7 +40457,7 @@ class ViewerDeploymentCoordinator {
   start(status) {
     if (this.tasks.has(status.deploymentId) || status.terminal)
       return;
-    const task = this.run(status).catch((error) => console.error(`[viewer deployment] ${safeError3(error)}`)).finally(() => this.tasks.delete(status.deploymentId));
+    const task = this.run(status).catch((error) => this.log(`[viewer deployment] ${safeError3(error)}`)).finally(() => this.tasks.delete(status.deploymentId));
     this.tasks.set(status.deploymentId, task);
   }
   async run(initial) {
@@ -39339,6 +40518,9 @@ class ViewerDeploymentCoordinator {
           if (!status.candidate)
             throw new Error("candidate identity is missing");
           const publication = await this.adapter.promote(status.candidate);
+          if (publication.hotStateHandOver) {
+            this.log(`[viewer deployment] ${status.deploymentId} promote hot-state hand-over: ${publication.hotStateHandOver}`);
+          }
           const runtime2 = mcpRuntimeStatus(status);
           status = this.journal.updateViewerDeployment(status.deploymentId, {
             phase: "post-promotion-health",
@@ -39405,6 +40587,7 @@ class ViewerDeploymentCoordinator {
       const message = safeError3(error);
       const latest = this.journal.viewerDeployment(status.deploymentId) ?? status;
       if (latest.phase === "host-handoff") {
+        this.log(`[viewer deployment] ${latest.deploymentId} host-handoff failed and stays retryable: ${message}`);
         this.journal.updateViewerDeployment(latest.deploymentId, {
           error: message,
           phase: "host-handoff",
@@ -39458,15 +40641,24 @@ var init_deployment = __esm(() => {
   init_contracts3();
 });
 
+// src/runtime-host/deploymentHotState.ts
+var HOT_STATE_ACTIVATION_TIMEOUT_MS = 180000, INCUMBENT_RELEASE_TIMEOUT_MS = 15000, CONTAINER_INSPECTION_TIMEOUT_MS = 5000, PROMOTE_PUBLICATION_BUDGET_MS = 60000, HAND_OVER_BUDGET_MS, PROMOTE_ACTION_TIMEOUT_MS, INSPECTION_EXPIRED;
+var init_deploymentHotState = __esm(() => {
+  init_hotStateAuthority();
+  HAND_OVER_BUDGET_MS = INCUMBENT_RELEASE_TIMEOUT_MS + HOT_STATE_ACTIVATION_TIMEOUT_MS;
+  PROMOTE_ACTION_TIMEOUT_MS = HAND_OVER_BUDGET_MS + PROMOTE_PUBLICATION_BUDGET_MS + 2 * CONTAINER_INSPECTION_TIMEOUT_MS;
+  INSPECTION_EXPIRED = Symbol("container inspection expired");
+});
+
 // src/runtime-host/mcpHealthProbeAdmissionChannel.ts
 import fs66 from "fs";
 import net3 from "net";
-import { createRequire as createRequire3 } from "module";
-import os11 from "os";
+import { createRequire as createRequire4 } from "module";
+import os12 from "os";
 import path61 from "path";
 function duplicateDescriptor(fd) {
   if (!cachedDup) {
-    const runtimeRequire = createRequire3(import.meta.url);
+    const runtimeRequire = createRequire4(import.meta.url);
     const ffi = runtimeRequire(`bun:${"ffi"}`);
     const library = ffi.dlopen(process.platform === "darwin" ? "/usr/lib/libSystem.B.dylib" : "libc.so.6", {
       dup: {
@@ -39479,7 +40671,7 @@ function duplicateDescriptor(fd) {
   return cachedDup(fd);
 }
 async function createMcpHealthProbeAdmissionChannel() {
-  const directory = fs66.mkdtempSync(path61.join(os11.tmpdir(), "llv-mcp-health-channel-"));
+  const directory = fs66.mkdtempSync(path61.join(os12.tmpdir(), "llv-mcp-health-channel-"));
   const socketPath = path61.join(directory, "channel.sock");
   const server = net3.createServer({ pauseOnConnect: true });
   let accepted = null;
@@ -39734,12 +40926,50 @@ function publication(value) {
   if (item.action !== "activate" && item.action !== "restore" || typeof item.publishedAt !== "string" || item.durable !== true) {
     throw new Error("deployment adapter returned invalid MCP runtime publication evidence");
   }
-  return { ...runtime2, action: item.action, publishedAt: item.publishedAt, durable: true };
+  const hotStateHandOver = typeof item.hotStateHandOver === "string" ? item.hotStateHandOver.slice(0, 200) : null;
+  return {
+    ...runtime2,
+    action: item.action,
+    publishedAt: item.publishedAt,
+    durable: true,
+    ...hotStateHandOver ? { hotStateHandOver } : {}
+  };
+}
+function probeObservations(value) {
+  if (!Array.isArray(value))
+    throw new Error("deployment adapter returned invalid health evidence");
+  return value.map((entry) => {
+    const item = object(entry);
+    if (!PROBE_NAMES.includes(item.name) || typeof item.url !== "string" || typeof item.status !== "number" || typeof item.elapsedMs !== "number" || typeof item.expected !== "string" || typeof item.ok !== "boolean")
+      throw new Error("deployment adapter returned invalid health evidence");
+    return {
+      name: item.name,
+      url: item.url,
+      status: item.status,
+      elapsedMs: item.elapsedMs,
+      expected: item.expected,
+      ok: item.ok,
+      ...typeof item.error === "string" ? { error: item.error } : {},
+      ...typeof item.body === "string" ? { body: item.body } : {}
+    };
+  });
+}
+function readinessRecord(value) {
+  const item = object(value);
+  if (typeof item.attempts !== "number" || typeof item.maxAttempts !== "number" || typeof item.delayMs !== "number" || typeof item.elapsedMs !== "number")
+    throw new Error("deployment adapter returned invalid health evidence");
+  return {
+    attempts: item.attempts,
+    maxAttempts: item.maxAttempts,
+    delayMs: item.delayMs,
+    elapsedMs: item.elapsedMs,
+    ...typeof item.firstDetail === "string" ? { firstDetail: item.firstDetail } : {}
+  };
 }
 function evidence(value) {
   const item = object(value);
   const assets = Array.isArray(item.assets) ? item.assets.map((asset) => object(asset)) : [];
-  if (typeof item.checkedAt !== "string" || typeof item.endpoint !== "string" || typeof item.processReady !== "boolean" || typeof item.rootStatus !== "number" || item.authenticatedStatus !== null && typeof item.authenticatedStatus !== "number" || item.unauthorizedStatus !== null && typeof item.unauthorizedStatus !== "number" || typeof item.ok !== "boolean" || assets.some((asset) => typeof asset.path !== "string" || typeof asset.status !== "number"))
+  if (typeof item.checkedAt !== "string" || typeof item.endpoint !== "string" || typeof item.processReady !== "boolean" || typeof item.rootStatus !== "number" || item.authenticatedStatus !== null && typeof item.authenticatedStatus !== "number" || item.unauthorizedStatus !== null && typeof item.unauthorizedStatus !== "number" || typeof item.ok !== "boolean" || assets.some((asset) => typeof asset.path !== "string" || typeof asset.status !== "number") || item.containerLog !== undefined && (!Array.isArray(item.containerLog) || item.containerLog.some((line) => typeof line !== "string")))
     throw new Error("deployment adapter returned invalid health evidence");
   return {
     checkedAt: item.checkedAt,
@@ -39749,6 +40979,9 @@ function evidence(value) {
     authenticatedStatus: item.authenticatedStatus,
     unauthorizedStatus: item.unauthorizedStatus,
     assets: assets.map((asset) => ({ path: asset.path, status: asset.status })),
+    ...item.observations === undefined ? {} : { observations: probeObservations(item.observations) },
+    ...item.readiness === undefined ? {} : { readiness: readinessRecord(item.readiness) },
+    ...item.containerLog === undefined ? {} : { containerLog: item.containerLog },
     ...item.mcpRuntime === undefined ? {} : { mcpRuntime: mcpHealthEvidence(item.mcpRuntime) },
     ok: item.ok,
     ...typeof item.detail === "string" ? { detail: item.detail } : {}
@@ -39760,6 +40993,7 @@ function mcpHealthEvidence(value) {
   if (typeof item.checkedAt !== "string" || typeof item.revision !== "string" || !/^[0-9a-f]{40}$/.test(item.revision) || typeof item.artifactDigest !== "string" || !/^[0-9a-f]{64}$/.test(item.artifactDigest) || typeof item.processReady !== "boolean" || !Array.isArray(item.tools) || item.tools.some((tool) => typeof tool !== "string") || typeof calls.deploymentStatus !== "boolean" || typeof calls.boardSnapshot !== "boolean" || typeof item.ok !== "boolean") {
     throw new Error("deployment adapter returned invalid MCP runtime health evidence");
   }
+  const callFailures = mcpCallFailures(item.callFailures);
   return {
     checkedAt: item.checkedAt,
     revision: item.revision,
@@ -39770,10 +41004,28 @@ function mcpHealthEvidence(value) {
       deploymentStatus: calls.deploymentStatus,
       boardSnapshot: calls.boardSnapshot
     },
+    ...callFailures.length ? { callFailures } : {},
     ok: item.ok,
     ...typeof item.detail === "string" ? { detail: item.detail } : {}
   };
 }
+function mcpCallFailures(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    throw new Error("deployment adapter returned invalid MCP runtime call failures");
+  return value.map((entry) => {
+    const failure4 = object(entry);
+    if (typeof failure4.tool !== "string" || typeof failure4.error !== "string" || failure4.code !== undefined && typeof failure4.code !== "string") {
+      throw new Error("deployment adapter returned invalid MCP runtime call failures");
+    }
+    return {
+      tool: failure4.tool,
+      ...failure4.code === undefined ? {} : { code: failure4.code },
+      error: failure4.error
+    };
+  });
+}
 function reconciliation(value) {
   if (value === null)
     return null;
@@ -39797,6 +41049,8 @@ class HostCommandViewerDeploymentAdapter {
     const stateFile = options.stateFile ?? statePath("viewer-deployment-adapter-process.json");
     const phaseFile = `${stateFile}.phase`;
     const proc = options.proc ?? procBackend;
+    const log = options.log ?? console.error;
+    const phaseLogIntervalMs = Math.max(1, options.phaseLogIntervalMs ?? PHASE_LOG_INTERVAL_MS);
     const timeouts = { ...ACTION_TIMEOUTS, ...options.timeouts };
     const reconcile = async () => {
       const previous = readProcessRecord(stateFile);
@@ -39810,6 +41064,7 @@ class HostCommandViewerDeploymentAdapter {
       fs67.rmSync(phaseFile, { force: true });
     };
     const runAction = async (action, input, healthAdmissions) => {
+      const timeoutMs = Math.max(1, timeouts[action]);
       const admissionChannel = healthAdmissions ? await createMcpHealthProbeAdmissionChannel() : null;
       const stdio = admissionChannel ? ["pipe", "pipe", "pipe", admissionChannel.childFd] : ["pipe", "pipe", "pipe"];
       let child;
@@ -39820,7 +41075,8 @@ class HostCommandViewerDeploymentAdapter {
           env: {
             ...withoutWakatimeCredential(process.env),
             LLV_DEPLOYMENT_ADAPTER_PROTOCOL: "1",
-            LLV_DEPLOYMENT_ADAPTER_PHASE_FILE: phaseFile
+            LLV_DEPLOYMENT_ADAPTER_PHASE_FILE: phaseFile,
+            LLV_DEPLOYMENT_ADAPTER_ACTION_DEADLINE_MS: String(timeoutMs)
           },
           detached: true
         });
@@ -39868,8 +41124,16 @@ class HostCommandViewerDeploymentAdapter {
       const stdoutPromise = readStream(child.stdout);
       const stderrPromise = readStream(child.stderr);
       let timer = null;
+      let reportedPhase = null;
+      const phaseLog = setInterval(() => {
+        const phase = readAdapterPhase(phaseFile, action);
+        if (phase === null || phase === reportedPhase)
+          return;
+        reportedPhase = phase;
+        log(`[viewer deployment] ${action} ${phase}`);
+      }, phaseLogIntervalMs);
+      phaseLog.unref?.();
       try {
-        const timeoutMs = Math.max(1, timeouts[action]);
         const outcome = await Promise.race([
           exitPromise.then((exitCode) => ({ type: "exit", exitCode })),
           new Promise((resolve) => {
@@ -39894,6 +41158,7 @@ class HostCommandViewerDeploymentAdapter {
       } finally {
         if (timer)
           clearTimeout(timer);
+        clearInterval(phaseLog);
         closeHealthAdmission?.();
         clearProcessRecord(stateFile, record11);
         fs67.rmSync(phaseFile, { force: true });
@@ -39968,10 +41233,11 @@ class HostCommandViewerDeploymentAdapter {
     await this.run("complete-host-handoff", { generation });
   }
 }
-var ACTION_TIMEOUTS, MCP_HEALTH_PROBE_ACTIONS;
+var ACTION_TIMEOUTS, MCP_HEALTH_PROBE_ACTIONS, PHASE_LOG_INTERVAL_MS = 5000, PROBE_NAMES;
 var init_deploymentAdapter = __esm(() => {
   init_configDir();
   init_proc();
+  init_deploymentHotState();
   init_mcpHealthProbeAdmissionChannel();
   ACTION_TIMEOUTS = {
     "resolve-revision": 110000,
@@ -39981,7 +41247,7 @@ var init_deploymentAdapter = __esm(() => {
     "current-mcp-runtime": 90000,
     "reconcile-mcp-runtime": 10 * 60000,
     "verify-candidate": 90000,
-    promote: 30000,
+    promote: PROMOTE_ACTION_TIMEOUT_MS,
     "verify-promoted": 120000,
     rollback: 90000,
     retire: 60000,
@@ -39994,6 +41260,7 @@ var init_deploymentAdapter = __esm(() => {
     "verify-candidate",
     "verify-promoted"
   ]);
+  PROBE_NAMES = ["root", "authenticated", "unauthorized", "capability"];
 });
 
 // src/runtime-host/deploymentProxy.ts
@@ -40051,6 +41318,55 @@ Content-Length: 0\r
 }
 var init_deploymentProxy = () => {};
 
+// src/runtime-host/receiptSweep.ts
+var exports_receiptSweep = {};
+__export(exports_receiptSweep, {
+  RECEIPT_SWEEP_SUMMARY_INTERVAL_MS: () => RECEIPT_SWEEP_SUMMARY_INTERVAL_MS,
+  ReceiptSweepReporter: () => ReceiptSweepReporter,
+  receiptSweepDebugEnabled: () => receiptSweepDebugEnabled
+});
+function receiptSweepDebugEnabled(env = process.env) {
+  return env.LLV_RUNTIME_JOURNAL_DEBUG === "1";
+}
+
+class ReceiptSweepReporter {
+  deleted = 0;
+  cycles = 0;
+  windowStartedAt = null;
+  debug;
+  summaryIntervalMs;
+  constructor(options = {}) {
+    this.debug = options.debug ?? false;
+    this.summaryIntervalMs = Math.max(0, options.summaryIntervalMs ?? RECEIPT_SWEEP_SUMMARY_INTERVAL_MS);
+  }
+  record(pass, nowMs) {
+    if (this.debug) {
+      return pass.deleted > 0 ? `[runtime journal] receipt sweep cycle removed ${pass.deleted} stale producer receipts` : null;
+    }
+    this.windowStartedAt ??= nowMs;
+    if (pass.deleted > 0) {
+      this.deleted += pass.deleted;
+      this.cycles += 1;
+    }
+    if (this.deleted === 0) {
+      this.windowStartedAt = nowMs;
+      return null;
+    }
+    if (nowMs - this.windowStartedAt < this.summaryIntervalMs)
+      return null;
+    const minutes = Math.max(1, Math.round((nowMs - this.windowStartedAt) / 60000));
+    const line = `[runtime journal] receipt sweep removed ${this.deleted} stale producer receipts across ${this.cycles} cycles in the last ${minutes}m`;
+    this.deleted = 0;
+    this.cycles = 0;
+    this.windowStartedAt = nowMs;
+    return line;
+  }
+}
+var RECEIPT_SWEEP_SUMMARY_INTERVAL_MS;
+var init_receiptSweep = __esm(() => {
+  RECEIPT_SWEEP_SUMMARY_INTERVAL_MS = 15 * 60000;
+});
+
 // src/runtime-host/hostRelease.ts
 var exports_hostRelease = {};
 __export(exports_hostRelease, {
@@ -40162,6 +41478,66 @@ var init_hostRelease = __esm(() => {
   init_configDir();
 });
 
+// src/runtime-host/fenceWait.ts
+var exports_fenceWait = {};
+__export(exports_fenceWait, {
+  RUNTIME_HOST_FENCE_PARK_ENV: () => RUNTIME_HOST_FENCE_PARK_ENV,
+  RUNTIME_HOST_FENCE_WAIT_ENV: () => RUNTIME_HOST_FENCE_WAIT_ENV,
+  acquireRuntimeHostFence: () => acquireRuntimeHostFence,
+  runtimeHostFenceTimeoutLine: () => runtimeHostFenceTimeoutLine,
+  runtimeHostFenceWaitLine: () => runtimeHostFenceWaitLine,
+  runtimeHostFenceWaitPlan: () => runtimeHostFenceWaitPlan
+});
+function runtimeHostFenceWaitPlan(environment) {
+  if (environment[RUNTIME_HOST_FENCE_PARK_ENV] === "1")
+    return { parked: true, budgetMs: 0 };
+  const budgetMs = Number(environment[RUNTIME_HOST_FENCE_WAIT_ENV] || 0);
+  return { parked: false, budgetMs: Number.isFinite(budgetMs) && budgetMs > 0 ? budgetMs : 0 };
+}
+function seconds(milliseconds) {
+  return Math.max(0, Math.round(milliseconds / 1000));
+}
+function generation(container) {
+  return container ? `runtime-host successor ${container}` : "this runtime-host generation";
+}
+function runtimeHostFenceWaitLine(plan, container, elapsedMs) {
+  if (plan.parked) {
+    return `[runtime host] ${generation(container)} is parked on the singleton fence with no deadline` + `; waited ${seconds(elapsedMs)}s` + "; the predecessor still serves and has not been asked to exit" + "; run scripts/bootstrap-runtime-host.ts --hand-over to release it";
+  }
+  return `[runtime host] ${generation(container)} is waiting for the singleton fence` + `; waited ${seconds(elapsedMs)}s of ${seconds(plan.budgetMs)}s` + "; the predecessor has not released it yet";
+}
+function runtimeHostFenceTimeoutLine(plan, container, elapsedMs) {
+  return `${generation(container)} never acquired the singleton fence` + `; waited ${seconds(elapsedMs)}s of ${seconds(plan.budgetMs)}s` + "; the predecessor generation still holds it";
+}
+async function acquireRuntimeHostFence(options) {
+  const now2 = options.now ?? Date.now;
+  const sleep6 = options.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  const pollMs = Math.max(1, options.pollMs ?? FENCE_ACQUIRE_POLL_MS);
+  const reportEveryMs = Math.max(1, options.reportEveryMs ?? FENCE_REPORT_EVERY_MS);
+  const started = now2();
+  const deadline = started + options.plan.budgetMs;
+  let reportedAt = null;
+  for (;; ) {
+    try {
+      options.acquire();
+      return { waitedMs: now2() - started };
+    } catch (error) {
+      const elapsedMs = now2() - started;
+      if (!options.plan.parked && now2() >= deadline) {
+        if (options.plan.budgetMs <= 0)
+          throw error;
+        throw new Error(runtimeHostFenceTimeoutLine(options.plan, options.container, elapsedMs), { cause: error });
+      }
+      if (reportedAt === null || elapsedMs - reportedAt >= reportEveryMs) {
+        reportedAt = elapsedMs;
+        options.report?.(runtimeHostFenceWaitLine(options.plan, options.container, elapsedMs));
+      }
+      await sleep6(pollMs);
+    }
+  }
+}
+var RUNTIME_HOST_FENCE_WAIT_ENV = "LLV_RUNTIME_HOST_FENCE_WAIT_MS", RUNTIME_HOST_FENCE_PARK_ENV = "LLV_RUNTIME_HOST_FENCE_PARK", FENCE_ACQUIRE_POLL_MS = 500, FENCE_REPORT_EVERY_MS = 60000;
+
 // src/runtime-host/main.ts
 discardWakatimeEnvironmentCredential();
 var { statePath: statePath2 } = await Promise.resolve().then(() => (init_configDir(), exports_configDir));
@@ -40176,10 +41552,12 @@ var { serveRuntimeHost: serveRuntimeHost2 } = await Promise.resolve().then(() =>
 var { ViewerDeploymentCoordinator: ViewerDeploymentCoordinator2 } = await Promise.resolve().then(() => (init_deployment(), exports_deployment));
 var { HostCommandViewerDeploymentAdapter: HostCommandViewerDeploymentAdapter2 } = await Promise.resolve().then(() => (init_deploymentAdapter(), exports_deploymentAdapter));
 var { serveViewerDeploymentProxy: serveViewerDeploymentProxy2 } = await Promise.resolve().then(() => (init_deploymentProxy(), exports_deploymentProxy));
+var { ReceiptSweepReporter: ReceiptSweepReporter2, receiptSweepDebugEnabled: receiptSweepDebugEnabled2 } = await Promise.resolve().then(() => (init_receiptSweep(), exports_receiptSweep));
 var {
   currentRuntimeHostGeneration: currentRuntimeHostGeneration2,
   RUNTIME_HOST_CONTAINER_ENV: RUNTIME_HOST_CONTAINER_ENV2
 } = await Promise.resolve().then(() => (init_hostRelease(), exports_hostRelease));
+var { acquireRuntimeHostFence: acquireRuntimeHostFence2, runtimeHostFenceWaitPlan: runtimeHostFenceWaitPlan2 } = await Promise.resolve().then(() => exports_fenceWait);
 var { runtimeHostActivationRefusal: runtimeHostActivationRefusal2 } = await Promise.resolve().then(() => exports_flags);
 var socketPath = process.env.LLV_RUNTIME_HOST_SOCKET || statePath2("runtime-host.sock");
 var activationRefusal = runtimeHostActivationRefusal2();
@@ -40189,18 +41567,12 @@ if (process.env.LLV_RUNTIME_LEGACY_SCHEDULER === "1" && process.env.LLV_ACCOUNT_
   throw new Error("runtime legacy scheduler requires LLV_ACCOUNT_CONTROLLER_DISABLED=1 to preserve single-writer reconciliation");
 }
 var fence = new RuntimeHostFence2(`${socketPath}.lock`);
-var fenceWaitMs = Number(process.env.LLV_RUNTIME_HOST_FENCE_WAIT_MS || 0);
-var fenceDeadline = Date.now() + (Number.isFinite(fenceWaitMs) && fenceWaitMs > 0 ? fenceWaitMs : 0);
-for (;; ) {
-  try {
-    fence.acquire();
-    break;
-  } catch (error) {
-    if (Date.now() >= fenceDeadline)
-      throw error;
-    await new Promise((resolve) => setTimeout(resolve, 500));
-  }
-}
+await acquireRuntimeHostFence2({
+  acquire: () => fence.acquire(),
+  plan: runtimeHostFenceWaitPlan2(process.env),
+  container: process.env[RUNTIME_HOST_CONTAINER_ENV2],
+  report: (line) => console.error(line)
+});
 var journal = new RuntimeJournal2(process.env.LLV_RUNTIME_JOURNAL || statePath2("runtime-events.sqlite"));
 if (journal.isWritable())
   journal.claimHostEpoch();
@@ -40235,17 +41607,14 @@ var legacyScheduler = process.env.LLV_RUNTIME_LEGACY_SCHEDULER === "1" ? createL
 var legacyTimer = legacyScheduler ? setInterval(() => {
   legacyScheduler.runDue().catch(() => console.error("[runtime scheduler] tick failed; next tick will retry"));
 }, 1000) : null;
-var receiptSweepDeleted = 0;
+var receiptSweepReporter = new ReceiptSweepReporter2({ debug: receiptSweepDebugEnabled2() });
 var receiptSweepTimer = journal.isWritable() ? setInterval(() => {
   if (!journal.isWritable())
     return;
   try {
-    const pass = journal.maintainProducerReceipts();
-    receiptSweepDeleted += pass.deleted;
-    if (pass.cycled && receiptSweepDeleted > 0) {
-      console.error(`[runtime journal] receipt sweep cycle removed ${receiptSweepDeleted} stale producer receipts`);
-      receiptSweepDeleted = 0;
-    }
+    const line = receiptSweepReporter.record(journal.maintainProducerReceipts(), Date.now());
+    if (line)
+      console.error(line);
   } catch (error) {
     console.error(`[runtime journal] receipt sweep failed; next tick will retry: ${error instanceof Error ? error.message : String(error)}`);
   }