@jmanuelcorral/openteam 0.20.0 → 0.21.0

package/dist/cli.js

@@ -7,7 +7,7 @@ import { exec, execFile as execFile2 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname7, resolve as resolve9 } from "node:path";
+import { dirname as dirname7, resolve as resolve10 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 import {
   confirm as clackConfirm,
@@ -419,6 +419,72 @@ function migrateConfig(raw) {
   };
 }
 
+// src/messages/consoleDetail.ts
+var consoleDetailMessages = {
+  follow: "Follow new activity",
+  metadataOnly: "Lifecycle and telemetry stay metadata-only.",
+  filter: "Filter sessions",
+  incoming: "New activity available — show updates",
+  refreshError: "Live updates unavailable; retrying.",
+  inspectConversation: "Show messages and tool calls",
+  refresh: "Refresh conversation",
+  close: "Hide messages and tool calls",
+  title: "Recorded messages and tool calls",
+  orchestrator: "Orchestrator",
+  worker: "Worker",
+  session: "Session",
+  runStarted: "Run started",
+  sessionCreated: "Session created",
+  firstObserved: "First observed",
+  timeUnknown: "Time unknown",
+  utc: "UTC",
+  technicalID: "Technical ID",
+  currentMetadata: "Current opencode title; not historical metadata",
+  partialMetadata: "Some current session titles are unavailable or outside the bounded batch; fallback labels remain.",
+  rootCurrent: "Current whole orchestrator session; may contain multiple batches. Not a historical or batch-only transcript.",
+  recovered: "Read-only association verified from current opencode history; not an immutable lifecycle event.",
+  rootUnlinked: "Orchestrator session not recorded. Reveal to try a bounded, read-only relationship search.",
+  rootUnavailable: "Orchestrator session unavailable: no unique, verifiable relationship was found in local history.",
+  rootAmbiguous: "Orchestrator session unavailable: conflicting or copied relationships are ambiguous.",
+  searchIncomplete: "Orchestrator association search incomplete or exceeded its bounded budget. No session was guessed.",
+  prompt: "Received prompts",
+  assistant: "Visible agent responses",
+  tools: "Tool calls ({count})",
+  noPrompts: "No received prompt text retained.",
+  noOutput: "No visible agent response text retained.",
+  noTools: "No tool calls retained.",
+  arguments: "Arguments",
+  result: "Result",
+  loading: "Loading local conversation…",
+  current: "Present-day session, not a timeline reconstruction. May include later messages and tools. Refresh explicitly for updates.",
+  historical: "Historical cursor: conversation content is hidden to avoid showing future mutable text. Return to live before revealing this operation.",
+  disabled: "Content is disabled. Set console.sessionHistory.contentEnabled to true in .opencode/openteam.json and restart the Console. Then reveal content here.",
+  unavailable: "Conversation unavailable. Start an operator-owned local opencode serve against the same workspace and user history, configure console.sessionHistory.endpoint, then retry. No inference was requested.",
+  empty: "No readable user messages, assistant output or tool calls remain in this session.",
+  invalid: "This attempt has no recorded session in the selected run, or its history is incomplete.",
+  unauthorized: "Conversation access denied.",
+  pending: "Still streaming or unavailable.",
+  compacted: "Tool result was compacted by opencode.",
+  invalidEndpoint: "Expected a loopback HTTP origin without credentials, path, query or fragment.",
+  readFailed: "Local session history could not be read.",
+  oversized: "Conversation exceeds the local size limit (4 MiB). No content was loaded.",
+  truncated: "Conversation display is truncated by local safety limits; omitted content is not empty history.",
+  truncatedMarker: `
+[truncated]`,
+  terminalGap: "Live collection was interrupted; events during the gap are unavailable. This is not complete session history.",
+  terminalTrimmed: "Older live output was discarded by the local display limit."
+};
+
+// src/config/historyEndpoint.ts
+function isLocalHistoryEndpoint(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && ["127.0.0.1", "[::1]"].includes(url.hostname) && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}
+
 // src/config/schema.ts
 var ModelRefSchema = z2.object({
   providerID: z2.string().min(1),
@@ -478,6 +544,10 @@ var ConsoleConfigSchema = z2.object({
   recentRoutes: z2.number().int().positive().default(50),
   openBrowser: z2.boolean().default(false),
   remoteStorage: z2.boolean().default(false),
+  sessionHistory: z2.object({
+    contentEnabled: z2.boolean().default(false),
+    endpoint: z2.string().refine(isLocalHistoryEndpoint, consoleDetailMessages.invalidEndpoint).optional()
+  }).strict().optional(),
   terminal: z2.object({
     enabled: z2.boolean().default(true),
     pty: z2.boolean().optional()
@@ -815,11 +885,638 @@ function resolveMemorySemantic(config) {
   return config.memory?.semantic ?? MemorySemanticSchema.parse(undefined);
 }
 
+// src/console/conversation.ts
+import { isAbsolute, normalize, parse, resolve, sep } from "node:path";
+import { createOpencodeClient } from "@opencode-ai/sdk";
+import { z as z4 } from "zod";
+
+// src/console/historyBoundary.ts
+function only(keys) {
+  return (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return value;
+    const record = value;
+    return Object.fromEntries(keys.filter((key) => Object.hasOwn(record, key)).map((key) => [key, record[key]]));
+  };
+}
+
+class AssociationError extends Error {
+  reason;
+  constructor(reason) {
+    super(reason === "ambiguous" ? consoleDetailMessages.rootAmbiguous : reason === "incomplete" ? consoleDetailMessages.searchIncomplete : consoleDetailMessages.rootUnavailable);
+    this.reason = reason;
+  }
+}
+
+// src/console/labels.ts
+function labelFormatters(msg) {
+  function boundedTitle(value) {
+    if (typeof value !== "string")
+      return;
+    const title = value.replace(/\p{Cc}|[\u202a-\u202e\u2066-\u2069]/gu, " ").replace(/\s+/g, " ").trim().slice(0, 160);
+    return title || undefined;
+  }
+  function utcTime(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      return msg.timeUnknown;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? msg.timeUnknown : `${date.toISOString().slice(0, -5).replace("T", " ")} ${msg.utc}`;
+  }
+  function runLabel(run, title) {
+    return `${boundedTitle(title) ?? (run.executionAuthority === "coordinator" ? msg.orchestrator : msg.worker)} · ${msg.runStarted}: ${utcTime(run.startedAt)} · ${run.runID}`;
+  }
+  return { boundedTitle, utcTime, runLabel };
+}
+var { boundedTitle, utcTime, runLabel } = labelFormatters(consoleDetailMessages);
+var LABELS_CLIENT_JS = `
+var consoleLabels=(function(){
+  var msg=${JSON.stringify(consoleDetailMessages)};
+  var formatters=(${labelFormatters.toString()})(msg);
+  var boundedTitle=formatters.boundedTitle,utcTime=formatters.utcTime,runLabel=formatters.runLabel;
+  var sessions=new Map(),roots=new Map(),request=null,lastRun=null,lastRead=0;
+  function update(data,run){
+    (data||[]).slice(0,64).forEach(function(session){
+      if(typeof session.id!=='string'||session.id.length>256){return}
+      sessions.delete(session.id);sessions.set(session.id,{id:session.id,title:boundedTitle(session.title),createdAt:session.createdAt});
+      if(sessions.size>128){sessions.delete(sessions.keys().next().value)}
+      if(run){roots.set(run,session.id);if(roots.size>128){roots.delete(roots.keys().next().value)}}
+    });
+    apply();
+  }
+  function apply(){
+    document.querySelectorAll('[data-session-name]').forEach(function(node){
+      var label=sessions.get(node.getAttribute('data-session-name'));
+      if(!node.hasAttribute('data-label-fallback')){node.setAttribute('data-label-fallback',node.textContent)}
+      if(label){var text=label.title||node.getAttribute('data-label-fallback');if(node.textContent!==text){node.textContent=text}if(node.title!==msg.currentMetadata){node.title=msg.currentMetadata}}
+    });
+    document.querySelectorAll('[data-session-time]').forEach(function(node){
+      var label=sessions.get(node.getAttribute('data-session-time'));
+      if(!node.hasAttribute('data-label-fallback')){node.setAttribute('data-label-fallback',node.textContent)}
+      if(label){var text=utcTime(label.createdAt)!==msg.timeUnknown?msg.sessionCreated+': '+utcTime(label.createdAt):node.getAttribute('data-label-fallback');if(node.textContent!==text){node.textContent=text}}
+    });
+    document.querySelectorAll('[data-run-name]').forEach(function(node){
+      var id=roots.get(node.getAttribute('data-run-name')),label=sessions.get(id);
+      if(label&&label.title){if(node.textContent!==label.title){node.textContent=label.title}if(node.title!==msg.currentMetadata){node.title=msg.currentMetadata}}
+    });
+    document.querySelectorAll('[data-lifecycle-run-select] option').forEach(function(option){
+      var session=sessions.get(option.getAttribute('data-run-session')||roots.get(option.value));
+      var raw=option.getAttribute('data-run-started');
+      var text=runLabel({runID:option.value,startedAt:raw?Number(raw):null,executionAuthority:option.getAttribute('data-run-authority')},session&&session.title);
+      if(option.textContent!==text){option.textContent=text}
+    });
+  }
+  function load(){
+    apply();
+    var mount=document.getElementById('lifecycle-timeline-mount');
+    if(!mount||mount.getAttribute('data-conversation-transition')==='1'||mount.getAttribute('data-conversation-cursor')){return}
+    var run=mount.getAttribute('data-lifecycle-run')||null;
+    if(lastRead&&lastRun===run&&Date.now()-lastRead<30000){return}
+    if(request){request.abort()}
+    lastRun=run;lastRead=Date.now();
+    var controller=new AbortController();request=controller;
+    var timeout=setTimeout(function(){controller.abort()},15000);
+    var query=new URLSearchParams({diagnostic:'1',token:document.documentElement.getAttribute('data-token')||''});
+    if(run){query.set('run',run)}
+    fetch('/api/graph/session-labels?'+query,{signal:controller.signal,cache:'no-store'}).then(function(r){return r.json()}).then(function(data){
+      if(request===controller&&data.kind==='labels'&&data.runID===run){update(data.sessions)}
+    }).catch(function(){}).finally(function(){clearTimeout(timeout);if(request===controller){request=null}});
+  }
+  document.addEventListener('conversation-tree-committed',load);
+  document.addEventListener('console-session-metadata',function(event){update([event.detail.session],event.detail.target==='root'?event.detail.runID:null)});
+  window.addEventListener('pagehide',function(){if(request){request.abort()}});
+  return {apply:apply,refresh:load,runLabel:runLabel,utcTime:utcTime};
+})();
+`;
+
+// src/console/rootAssociation.ts
+import { z as z3 } from "zod";
+var Identity = z3.object({
+  id: z3.string().min(1).max(256),
+  sessionID: z3.string().min(1).max(256)
+}).strict();
+var ObjectField = z3.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+var Row = z3.preprocess(only(["info", "parts"]), z3.object({
+  info: z3.preprocess(only(["id", "sessionID", "role"]), Identity.extend({ role: z3.enum(["user", "assistant"]) })),
+  parts: z3.array(z3.unknown()).max(1000)
+}).strict());
+var ResultPart = z3.preprocess(only(["id", "sessionID", "messageID", "type", "tool", "callID", "state"]), Identity.extend({
+  messageID: z3.string(),
+  type: z3.literal("tool"),
+  tool: z3.literal("openteam-orchestrate"),
+  callID: z3.string().min(1),
+  state: z3.preprocess(only(["status", "input", "output", "title", "metadata", "time"]), z3.object({
+    status: z3.literal("completed"),
+    input: ObjectField,
+    output: z3.string().max(262144),
+    title: z3.string(),
+    metadata: ObjectField,
+    time: z3.preprocess(only(["start", "end", "compacted"]), z3.object({
+      start: z3.number().finite(),
+      end: z3.number().finite(),
+      compacted: z3.number().finite().optional()
+    }).strict())
+  }).strict())
+}));
+function references(raw, sessionID, expected) {
+  const rows = z3.array(Row).max(2000).parse(raw);
+  let matched = false;
+  for (const row of rows) {
+    if (row.info.sessionID !== sessionID)
+      throw new AssociationError("incomplete");
+    for (const rawPart of row.parts) {
+      const part = z3.object({ type: z3.string() }).strict().parse(only(["type"])(rawPart));
+      if (part.type !== "tool")
+        continue;
+      const identity = Identity.extend({
+        messageID: z3.string(),
+        tool: z3.string()
+      }).parse(only(["id", "sessionID", "messageID", "tool"])(rawPart));
+      if (identity.sessionID !== sessionID || identity.messageID !== row.info.id)
+        throw new AssociationError("incomplete");
+      if (row.info.role !== "assistant" || identity.tool !== "openteam-orchestrate")
+        continue;
+      const status = z3.object({
+        state: z3.preprocess(only(["status"]), z3.object({
+          status: z3.enum(["pending", "running", "completed", "error"])
+        }).strict())
+      }).strict().parse(only(["state"])(rawPart)).state.status;
+      if (status !== "completed")
+        continue;
+      const parsed = ResultPart.safeParse(rawPart);
+      if (!parsed.success || parsed.data.state.time?.compacted !== undefined)
+        throw new AssociationError("incomplete");
+      const lines = parsed.data.state.output.split(/\r?\n/);
+      const heading = /^orchestration (?:completed|incomplete) \((\d+) role\(s\)\):$/.exec(lines[0] ?? "");
+      if (!heading)
+        continue;
+      const count = Number(heading[1]);
+      if (count < expected.length || count > 64)
+        continue;
+      const actual = lines.slice(1, 1 + count).map((line) => {
+        const result = /^([A-Za-z0-9_-]+): (ok|failed) → (\S+)(?: \(session ([^\s()]+)\))?(?: \[report: [^\r\n]*\])?(?: — [^\r\n]*)?$/.exec(line);
+        return !result ? undefined : result[4] ? `${result[1]}\x00${result[2]}\x00${result[3]}\x00${result[4]}` : null;
+      });
+      if (actual.length !== count || actual.some((row2) => row2 === undefined))
+        continue;
+      const sessionRows = actual.filter((row2) => row2 !== null);
+      if (sessionRows.length === expected.length && expected.every((key) => sessionRows.filter((item) => item === key).length === 1))
+        matched = true;
+    }
+  }
+  return matched;
+}
+async function recoverRootSession(port, projection) {
+  const workers = projection.operations.filter((op) => op.parentOperationID === projection.rootOperationID && op.kind === "role");
+  const last = workers.flatMap((op) => {
+    const attempt = op.attempts.at(-1);
+    return attempt?.sessionID ? [{ op, attempt, sessionID: attempt.sessionID }] : [];
+  });
+  if (!last.length)
+    throw new AssociationError("unavailable");
+  if (last.length > 32)
+    throw new AssociationError("incomplete");
+  const children = [];
+  for (const { sessionID } of last)
+    children.push(await port.get(sessionID));
+  const first = children[0];
+  if (!first)
+    throw new AssociationError("unavailable");
+  const projectID = first.projectID;
+  if (children.some((child) => child.projectID !== projectID))
+    throw new AssociationError("ambiguous");
+  const parents = new Set(children.flatMap((child) => child.parentID ? [child.parentID] : []));
+  if (parents.size > 1)
+    throw new AssociationError("ambiguous");
+  if (first.parentID && children.every((child) => child.parentID)) {
+    const session = await port.get(first.parentID);
+    if (session.projectID !== projectID || children.some((child) => child.id === session.id))
+      throw new AssociationError("ambiguous");
+    return { session, association: "sdk-parent" };
+  }
+  const expected = last.map(({ op, attempt }) => {
+    if (!attempt?.model || !["succeeded", "failed"].includes(attempt.state))
+      throw new AssociationError("unavailable");
+    return `${op.roleID}\x00${attempt.state === "succeeded" ? "ok" : "failed"}\x00${attempt.model.providerID}/${attempt.model.modelID}\x00${attempt.sessionID}`;
+  });
+  let match;
+  try {
+    const candidates = await port.primaries(projectID);
+    for (const listed of candidates) {
+      const session = await port.get(listed.id);
+      if (session.projectID !== projectID || session.parentID !== listed.parentID)
+        throw new AssociationError("incomplete");
+      if (await references(await port.messages(session.id), session.id, expected)) {
+        if (match)
+          throw new AssociationError("ambiguous");
+        match = session;
+      }
+    }
+  } catch (error) {
+    if (error instanceof AssociationError)
+      throw error;
+    throw new AssociationError("incomplete");
+  }
+  if (!match)
+    throw new AssociationError("unavailable");
+  if (parents.size && !parents.has(match.id))
+    throw new AssociationError("ambiguous");
+  return { session: match, association: "tool-result" };
+}
+
+// src/console/conversation.ts
+var CONVERSATION_LIMITS = {
+  bytes: 4 * 1024 * 1024,
+  messages: 200,
+  parts: 100,
+  tools: 200,
+  fieldChars: 16384,
+  totalChars: 262144,
+  argumentDepth: 8,
+  argumentEntries: 512
+};
+var SESSION_HISTORY_LIMITS = {
+  bytes: 32 * 1024 * 1024,
+  timeoutMs: 1e4,
+  labels: 64
+};
+var SESSION_LIST_WINDOW = 100;
+
+class ConversationTooLargeError extends Error {
+  constructor() {
+    super(consoleDetailMessages.oversized);
+  }
+}
+var Info = z4.preprocess(only(["id", "sessionID", "role", "time"]), z4.object({
+  id: z4.string(),
+  sessionID: z4.string(),
+  role: z4.enum(["user", "assistant"]),
+  time: z4.preprocess(only(["created", "completed"]), z4.object({
+    created: z4.number().finite(),
+    completed: z4.number().finite().optional()
+  }).strict())
+}).strict());
+var PartIdentity = z4.object({
+  id: z4.string(),
+  messageID: z4.string(),
+  sessionID: z4.string()
+}).strict();
+var Text = PartIdentity.extend({
+  type: z4.literal("text"),
+  text: z4.string(),
+  ignored: z4.boolean().optional()
+});
+var Tool = PartIdentity.extend({
+  type: z4.literal("tool"),
+  callID: z4.string(),
+  tool: z4.string(),
+  state: z4.preprocess(only(["status", "input", "output", "error", "time"]), z4.object({
+    status: z4.enum(["pending", "running", "completed", "error"]),
+    input: z4.unknown().refine((value) => typeof value === "object" && value !== null && !Array.isArray(value)),
+    output: z4.string().optional(),
+    error: z4.string().optional(),
+    time: z4.preprocess(only(["start", "end", "compacted"]), z4.object({
+      start: z4.number().finite(),
+      end: z4.number().finite().optional(),
+      compacted: z4.number().finite().optional()
+    }).strict()).optional()
+  }).strict())
+});
+var Message = z4.preprocess(only(["info", "parts"]), z4.object({ info: Info, parts: z4.custom(Array.isArray) }).strict());
+function projectConversation(raw, sessionID) {
+  if (!Array.isArray(raw))
+    throw new Error(consoleDetailMessages.readFailed);
+  const limits = CONVERSATION_LIMITS;
+  let truncated = raw.length > limits.messages;
+  let remaining = limits.totalChars;
+  let toolsRemaining = limits.tools;
+  function text(value) {
+    const length = Math.min(value.length, limits.fieldChars, remaining);
+    remaining -= length;
+    if (length === value.length)
+      return value;
+    truncated = true;
+    return value.slice(0, length) + consoleDetailMessages.truncatedMarker;
+  }
+  function argumentsText(input) {
+    let entries = limits.argumentEntries;
+    const seen = new Set;
+    function bounded(value, depth) {
+      if (typeof value === "string")
+        return text(value);
+      if (value === null || typeof value === "boolean" || typeof value === "number")
+        return value;
+      if (typeof value !== "object")
+        return null;
+      if (depth >= limits.argumentDepth || entries <= 0 || seen.has(value)) {
+        truncated = true;
+        return consoleDetailMessages.truncatedMarker;
+      }
+      seen.add(value);
+      const result = Object.create(null);
+      const array = [];
+      for (const key in value) {
+        if (!Object.hasOwn(value, key))
+          continue;
+        if (entries-- <= 0 || remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        const child = bounded(value[key], depth + 1);
+        if (Array.isArray(value))
+          array.push(child);
+        else
+          result[text(key)] = child;
+      }
+      return Array.isArray(value) ? array : result;
+    }
+    return text(JSON.stringify(bounded(input, 0), null, 2));
+  }
+  const messages = [];
+  for (const rawRow of raw.slice(0, limits.messages)) {
+    if (remaining <= 0) {
+      truncated = true;
+      break;
+    }
+    const row = Message.parse(rawRow);
+    if (row.info.sessionID !== sessionID)
+      throw new Error(consoleDetailMessages.readFailed);
+    const message = {
+      id: text(row.info.id),
+      role: row.info.role,
+      createdAt: row.info.time.created,
+      ...row.info.time.completed !== undefined ? { completedAt: row.info.time.completed } : {},
+      text: [],
+      tools: []
+    };
+    if (row.parts.length > limits.parts)
+      truncated = true;
+    for (const rawPart of row.parts.slice(0, limits.parts)) {
+      if (remaining <= 0) {
+        truncated = true;
+        break;
+      }
+      const kind = rawPart?.type;
+      if (kind !== "text" && kind !== "tool")
+        continue;
+      const part = kind === "text" ? Text.parse(only(["id", "messageID", "sessionID", "type", "text", "ignored"])(rawPart)) : Tool.parse(only([
+        "id",
+        "messageID",
+        "sessionID",
+        "type",
+        "callID",
+        "tool",
+        "state"
+      ])(rawPart));
+      if (part.sessionID !== sessionID || part.messageID !== row.info.id)
+        throw new Error(consoleDetailMessages.readFailed);
+      if (part.type === "text") {
+        if (!part.ignored)
+          message.text.push(text(part.text));
+      } else {
+        if (toolsRemaining-- <= 0) {
+          truncated = true;
+          continue;
+        }
+        const state = part.state;
+        message.tools.push({
+          id: text(part.callID),
+          name: text(part.tool),
+          status: state.status,
+          arguments: argumentsText(state.input),
+          ...state.time !== undefined ? { startedAt: state.time.start } : {},
+          ...state.time?.end !== undefined ? { endedAt: state.time.end } : {},
+          ...state.time?.compacted !== undefined ? { result: consoleDetailMessages.compacted } : state.status === "completed" && state.output !== undefined ? { result: text(state.output) } : state.status === "error" && state.error !== undefined ? { result: text(state.error) } : {}
+        });
+      }
+    }
+    if (message.text.length || message.tools.length)
+      messages.push(message);
+  }
+  return {
+    ...truncated ? { truncated: true } : {},
+    messages: messages.sort((a, b) => a.createdAt - b.createdAt || a.id.localeCompare(b.id))
+  };
+}
+var SessionScope = z4.preprocess(only(["id", "directory", "projectID", "parentID", "title", "time"]), z4.object({
+  id: z4.string().min(1).max(256),
+  directory: z4.string().min(1),
+  projectID: z4.string().min(1),
+  parentID: z4.string().min(1).max(256).optional(),
+  title: z4.unknown().optional(),
+  time: z4.unknown().optional()
+}).strict());
+function workspaceKey(directory) {
+  if (!isAbsolute(directory) || directory.includes("\x00"))
+    throw new Error(consoleDetailMessages.readFailed);
+  const normalized = normalize(directory);
+  const root = parse(normalized).root;
+  const key = normalized.length > root.length && normalized.endsWith(sep) ? normalized.slice(0, -1) : normalized;
+  return process.platform === "win32" ? key.toLowerCase() : key;
+}
+async function boundedResponse(response, controller, budget) {
+  const fail = async (error) => {
+    await response.body?.cancel().catch(() => {});
+    controller.abort();
+    throw error;
+  };
+  if (!response.ok || !response.body) {
+    await response.body?.cancel().catch(() => {});
+    throw new Error(consoleDetailMessages.readFailed);
+  }
+  if (Number(response.headers.get("content-length")) > CONVERSATION_LIMITS.bytes)
+    return fail(new ConversationTooLargeError);
+  const reader = response.body.getReader();
+  const cancel = () => {
+    reader.cancel().catch(() => {});
+  };
+  controller.signal.addEventListener("abort", cancel, { once: true });
+  const bytes = new Uint8Array(CONVERSATION_LIMITS.bytes);
+  let length = 0;
+  try {
+    while (true) {
+      controller.signal.throwIfAborted();
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      if (length + chunk.value.byteLength > CONVERSATION_LIMITS.bytes)
+        throw new ConversationTooLargeError;
+      budget.remaining -= chunk.value.byteLength;
+      if (budget.remaining < 0)
+        throw new AssociationError("incomplete");
+      bytes.set(chunk.value, length);
+      length += chunk.value.byteLength;
+    }
+    controller.signal.throwIfAborted();
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    headers.delete("content-encoding");
+    return new Response(bytes.subarray(0, length), {
+      status: response.status,
+      headers
+    });
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    controller.abort();
+    throw error;
+  } finally {
+    controller.signal.removeEventListener("abort", cancel);
+    reader.releaseLock();
+  }
+}
+function createConversationReader(deps) {
+  const directory = resolve(deps.directory);
+  const labels = new Map;
+  async function withHistory(endpoint, signal, work, options) {
+    if (!isLocalHistoryEndpoint(endpoint))
+      throw new Error(consoleDetailMessages.readFailed);
+    const controller = new AbortController;
+    const abort = () => controller.abort();
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted)
+      controller.abort();
+    const timeout = setTimeout(() => controller.abort(), Math.min(options?.timeoutMs ?? SESSION_HISTORY_LIMITS.timeoutMs, SESSION_HISTORY_LIMITS.timeoutMs));
+    const budget = options?.budget ?? {
+      remaining: SESSION_HISTORY_LIMITS.bytes
+    };
+    try {
+      let scoped = function(raw) {
+        const session = SessionScope.parse(raw);
+        if (workspaceKey(session.directory) !== workspaceKey(directory))
+          throw new Error(consoleDetailMessages.readFailed);
+        const time = z4.preprocess(only(["created"]), z4.object({ created: z4.number().finite().min(0).max(8640000000000000) }).strict()).safeParse(session.time);
+        const title = boundedTitle(session.title);
+        return {
+          id: session.id,
+          directory: session.directory,
+          projectID: session.projectID,
+          ...session.parentID === undefined ? {} : { parentID: session.parentID },
+          label: {
+            id: session.id,
+            ...title ? { title } : {},
+            ...time.success ? { createdAt: time.data.created } : {}
+          }
+        };
+      };
+      const client = createOpencodeClient({
+        baseUrl: endpoint,
+        directory,
+        ...deps.password ? {
+          headers: {
+            authorization: `Basic ${Buffer.from(`opencode:${deps.password}`).toString("base64")}`
+          }
+        } : {},
+        fetch: async (request) => {
+          controller.signal.throwIfAborted();
+          if (budget.remaining <= 0)
+            throw new AssociationError("incomplete");
+          const response = await (deps.fetch ?? fetch)(request, {
+            signal: controller.signal,
+            redirect: "error"
+          });
+          return boundedResponse(response, controller, budget);
+        }
+      });
+      const verified = new Map;
+      return await work({
+        get: async (id) => {
+          const result = await client.session.get({ path: { id } });
+          if (!result.response.ok || result.error !== undefined)
+            throw new Error(consoleDetailMessages.readFailed);
+          const session = scoped(result.data);
+          if (session.id !== id)
+            throw new Error(consoleDetailMessages.readFailed);
+          verified.set(id, session);
+          const key = JSON.stringify([endpoint, id]);
+          labels.delete(key);
+          labels.set(key, { at: Date.now(), label: session.label });
+          const oldest = labels.keys().next().value;
+          if (labels.size > 128 && oldest !== undefined)
+            labels.delete(oldest);
+          return session;
+        },
+        messages: async (id) => {
+          if (!verified.has(id))
+            throw new Error(consoleDetailMessages.readFailed);
+          const result = await client.session.messages({ path: { id } });
+          if (!result.response.ok || result.error !== undefined)
+            throw new Error(consoleDetailMessages.readFailed);
+          return result.data;
+        },
+        primaries: async (projectID) => {
+          const result = await client.session.list({ query: { directory } });
+          if (!result.response.ok || result.error !== undefined || !Array.isArray(result.data) || result.data.length >= SESSION_LIST_WINDOW)
+            throw new AssociationError("incomplete");
+          const candidates = [];
+          const ids = new Set;
+          for (const raw of result.data) {
+            const session = SessionScope.parse(raw);
+            if (workspaceKey(session.directory) !== workspaceKey(directory) || session.projectID !== projectID || session.parentID)
+              continue;
+            if (ids.has(session.id))
+              throw new AssociationError("ambiguous");
+            ids.add(session.id);
+            candidates.push(scoped(raw));
+          }
+          if (candidates.length > 64)
+            throw new AssociationError("incomplete");
+          return candidates;
+        }
+      }, controller.signal);
+    } catch (error) {
+      if (error instanceof ConversationTooLargeError || error instanceof AssociationError)
+        throw error;
+      throw new Error(consoleDetailMessages.readFailed);
+    } finally {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+  const read = async (endpoint, sessionID, signal) => withHistory(endpoint, signal, async (port) => {
+    const session = await port.get(sessionID);
+    return {
+      ...projectConversation(await port.messages(sessionID), sessionID),
+      session: session.label
+    };
+  });
+  read.root = (endpoint, projection, signal) => withHistory(endpoint, signal, async (port) => {
+    const recovered = await recoverRootSession(port, projection);
+    return {
+      ...projectConversation(await port.messages(recovered.session.id), recovered.session.id),
+      session: recovered.session.label,
+      association: recovered.association
+    };
+  });
+  read.labels = (endpoint, ids, signal, options) => withHistory(endpoint, signal, async (port, historySignal) => {
+    if (ids.length > SESSION_HISTORY_LIMITS.labels)
+      throw new Error(consoleDetailMessages.readFailed);
+    const result = [];
+    for (const id of new Set(ids)) {
+      controllerCheck(signal);
+      if (historySignal.aborted)
+        break;
+      const cached = labels.get(JSON.stringify([endpoint, id]));
+      if (cached && Date.now() - cached.at < 30000)
+        result.push(cached.label);
+      else {
+        try {
+          result.push((await port.get(id)).label);
+        } catch {}
+      }
+    }
+    controllerCheck(signal);
+    return result;
+  }, options);
+  return read;
+}
+function controllerCheck(signal) {
+  signal?.throwIfAborted();
+}
+
 // src/console/protocol.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // src/orchestrator/coordinator.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 
 // src/context/redaction.ts
 import { createHash } from "node:crypto";
@@ -919,41 +1616,41 @@ function splitVirtualPath(path) {
 }
 
 // src/telemetry/events.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/capabilities/types.ts
-import { z as z3 } from "zod";
-var CapabilityTierSchema = z3.union([
-  z3.literal(0),
-  z3.literal(1),
-  z3.literal(2),
-  z3.literal(3),
-  z3.literal(4),
-  z3.literal(5)
+import { z as z5 } from "zod";
+var CapabilityTierSchema = z5.union([
+  z5.literal(0),
+  z5.literal(1),
+  z5.literal(2),
+  z5.literal(3),
+  z5.literal(4),
+  z5.literal(5)
 ]);
-var ComplexityTierSchema = z3.enum([
+var ComplexityTierSchema = z5.enum([
   "trivial",
   "simple",
   "moderate",
   "hard"
 ]);
-var ModelCapabilityProfileSchema = z3.object({
-  ref: z3.object({
-    providerID: z3.string().min(1),
-    modelID: z3.string().min(1)
+var ModelCapabilityProfileSchema = z5.object({
+  ref: z5.object({
+    providerID: z5.string().min(1),
+    modelID: z5.string().min(1)
   }).strict(),
-  kind: z3.enum(["local", "frontier", "router"]),
-  contextWindow: z3.number().int().positive(),
-  maxOutputTokens: z3.number().int().positive(),
-  supportsToolCalling: z3.boolean(),
-  supportsVision: z3.boolean(),
+  kind: z5.enum(["local", "frontier", "router"]),
+  contextWindow: z5.number().int().positive(),
+  maxOutputTokens: z5.number().int().positive(),
+  supportsToolCalling: z5.boolean(),
+  supportsVision: z5.boolean(),
   reasoningTier: CapabilityTierSchema,
   codeQualityTier: CapabilityTierSchema,
-  costPer1M: z3.object({
-    inputUSD: z3.number().min(0),
-    outputUSD: z3.number().min(0)
+  costPer1M: z5.object({
+    inputUSD: z5.number().min(0),
+    outputUSD: z5.number().min(0)
   }).strict(),
-  availability: z3.enum(["available", "degraded", "unavailable"])
+  availability: z5.enum(["available", "degraded", "unavailable"])
 }).strict();
 
 // src/telemetry/diagnostics.ts
@@ -1008,97 +1705,97 @@ function diagnosticDescription(code) {
 
 // src/telemetry/events.ts
 var EVENT_SCHEMA_VERSION = 1;
-var EventBaseSchema = z4.object({
-  v: z4.literal(EVENT_SCHEMA_VERSION),
-  ts: z4.number().finite(),
-  sessionID: z4.string().min(1)
+var EventBaseSchema = z6.object({
+  v: z6.literal(EVENT_SCHEMA_VERSION),
+  ts: z6.number().finite(),
+  sessionID: z6.string().min(1)
 }).strict();
 var RouteEventSchema = EventBaseSchema.extend({
-  type: z4.literal("route"),
-  promptHash: z4.string().min(1),
-  promptChars: z4.number().int().min(0),
+  type: z6.literal("route"),
+  promptHash: z6.string().min(1),
+  promptChars: z6.number().int().min(0),
   tier: ComplexityTierSchema,
-  routeKind: z4.enum(["local", "frontier", "blocked"]),
+  routeKind: z6.enum(["local", "frontier", "blocked"]),
   selected: ModelRefSchema,
-  rationale: z4.string(),
-  estimatedCostUSD: z4.number().finite().min(0).nullable(),
-  baselineCostUSD: z4.number().finite().min(0).nullable(),
-  estimatedSavingsUSD: z4.number().finite().nullable(),
-  budgetAction: z4.string().min(1),
-  tokensIn: z4.number().int().min(0).optional(),
-  tokensOut: z4.number().int().min(0).optional(),
-  decisionID: z4.string().min(1).optional(),
-  agent: z4.string().min(1).optional(),
-  success: z4.boolean().optional(),
-  batchID: z4.string().min(1).optional(),
-  taskID: z4.string().min(1).optional(),
-  failureReason: z4.string().min(1).optional(),
-  failureStage: z4.string().min(1).optional()
+  rationale: z6.string(),
+  estimatedCostUSD: z6.number().finite().min(0).nullable(),
+  baselineCostUSD: z6.number().finite().min(0).nullable(),
+  estimatedSavingsUSD: z6.number().finite().nullable(),
+  budgetAction: z6.string().min(1),
+  tokensIn: z6.number().int().min(0).optional(),
+  tokensOut: z6.number().int().min(0).optional(),
+  decisionID: z6.string().min(1).optional(),
+  agent: z6.string().min(1).optional(),
+  success: z6.boolean().optional(),
+  batchID: z6.string().min(1).optional(),
+  taskID: z6.string().min(1).optional(),
+  failureReason: z6.string().min(1).optional(),
+  failureStage: z6.string().min(1).optional()
 });
 var MessageEventSchema = EventBaseSchema.extend({
-  type: z4.literal("message"),
-  providerID: z4.string().min(1),
-  modelID: z4.string().min(1),
-  agent: z4.string().min(1).optional(),
-  mode: z4.string().min(1).optional(),
-  messageID: z4.string().min(1).optional(),
-  costUSD: z4.number().finite().min(0),
-  tokensIn: z4.number().int().min(0),
-  tokensOut: z4.number().int().min(0),
-  tokensReasoning: z4.number().int().min(0),
-  tokensCacheRead: z4.number().int().min(0),
-  tokensCacheWrite: z4.number().int().min(0),
-  durationMs: z4.number().int().min(0)
+  type: z6.literal("message"),
+  providerID: z6.string().min(1),
+  modelID: z6.string().min(1),
+  agent: z6.string().min(1).optional(),
+  mode: z6.string().min(1).optional(),
+  messageID: z6.string().min(1).optional(),
+  costUSD: z6.number().finite().min(0),
+  tokensIn: z6.number().int().min(0),
+  tokensOut: z6.number().int().min(0),
+  tokensReasoning: z6.number().int().min(0),
+  tokensCacheRead: z6.number().int().min(0),
+  tokensCacheWrite: z6.number().int().min(0),
+  durationMs: z6.number().int().min(0)
 });
 var ToolcallEventSchema = EventBaseSchema.extend({
-  type: z4.literal("toolcall"),
-  tool: z4.string().min(1),
-  callID: z4.string().min(1),
-  agent: z4.string().min(1).optional(),
-  durationMs: z4.number().int().min(0),
-  ok: z4.boolean(),
-  title: z4.string().optional()
+  type: z6.literal("toolcall"),
+  tool: z6.string().min(1),
+  callID: z6.string().min(1),
+  agent: z6.string().min(1).optional(),
+  durationMs: z6.number().int().min(0),
+  ok: z6.boolean(),
+  title: z6.string().optional()
 });
 var MeetingEventSchema = EventBaseSchema.extend({
-  type: z4.literal("meeting"),
-  batchID: z4.string().min(1),
-  purpose: z4.string().optional(),
-  roles: z4.array(z4.string().min(1)),
-  decisionIDs: z4.array(z4.string().min(1)).optional()
+  type: z6.literal("meeting"),
+  batchID: z6.string().min(1),
+  purpose: z6.string().optional(),
+  roles: z6.array(z6.string().min(1)),
+  decisionIDs: z6.array(z6.string().min(1)).optional()
 });
 var QueueEventSchema = EventBaseSchema.extend({
-  type: z4.literal("queue"),
-  runtimeId: z4.string().min(1),
-  waitedMs: z4.number().finite().min(0),
-  activeCount: z4.number().int().min(0),
-  queuedCount: z4.number().int().min(0),
-  decisionID: z4.string().min(1).optional(),
-  agent: z4.string().min(1).optional(),
-  batchID: z4.string().min(1).optional()
+  type: z6.literal("queue"),
+  runtimeId: z6.string().min(1),
+  waitedMs: z6.number().finite().min(0),
+  activeCount: z6.number().int().min(0),
+  queuedCount: z6.number().int().min(0),
+  decisionID: z6.string().min(1).optional(),
+  agent: z6.string().min(1).optional(),
+  batchID: z6.string().min(1).optional()
 });
 var DecisionEventSchema = EventBaseSchema.extend({
-  type: z4.literal("decision"),
-  agent: z4.string().min(1).optional(),
-  summary: z4.string().min(1),
-  tags: z4.array(z4.string().min(1)).optional()
+  type: z6.literal("decision"),
+  agent: z6.string().min(1).optional(),
+  summary: z6.string().min(1),
+  tags: z6.array(z6.string().min(1)).optional()
 });
 var ActivityEventSchema = EventBaseSchema.extend({
-  type: z4.literal("activity"),
-  kind: z4.enum(["route", "agent", "decision", "commit"]),
-  agent: z4.string().min(1).optional(),
-  summary: z4.string().min(1)
+  type: z6.literal("activity"),
+  kind: z6.enum(["route", "agent", "decision", "commit"]),
+  agent: z6.string().min(1).optional(),
+  summary: z6.string().min(1)
 });
 var SessionEndpointEventSchema = EventBaseSchema.extend({
-  type: z4.literal("session-endpoint"),
-  url: z4.string().url(),
-  directory: z4.string().min(1).optional(),
-  worktree: z4.string().min(1).optional(),
-  title: z4.string().min(1).optional()
+  type: z6.literal("session-endpoint"),
+  url: z6.string().url(),
+  directory: z6.string().min(1).optional(),
+  worktree: z6.string().min(1).optional(),
+  title: z6.string().min(1).optional()
 });
 var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
-  type: z4.literal("shadow-diagnostic"),
-  batchID: z4.string().min(1),
-  failureClass: z4.enum([
+  type: z6.literal("shadow-diagnostic"),
+  batchID: z6.string().min(1),
+  failureClass: z6.enum([
     "invalid-node-id",
     "journal-create-failed",
     "journal-append-failed",
@@ -1109,16 +1806,16 @@ var ShadowDiagnosticEventSchema = EventBaseSchema.extend({
     "unknown"
   ])
 });
-var DiagnosticLevelSchema = z4.enum(["debug", "info", "warn", "error"]);
-var DiagnosticCodeSchema = z4.enum(DIAGNOSTIC_CODES);
+var DiagnosticLevelSchema = z6.enum(["debug", "info", "warn", "error"]);
+var DiagnosticCodeSchema = z6.enum(DIAGNOSTIC_CODES);
 var DiagnosticEventSchema = EventBaseSchema.extend({
-  type: z4.literal("diagnostic"),
+  type: z6.literal("diagnostic"),
   level: DiagnosticLevelSchema,
   code: DiagnosticCodeSchema,
-  roleID: z4.string().min(1).optional(),
-  passCount: z4.number().int().min(0).optional()
+  roleID: z6.string().min(1).optional(),
+  passCount: z6.number().int().min(0).optional()
 });
-var OpenTeamEventSchema = z4.discriminatedUnion("type", [
+var OpenTeamEventSchema = z6.discriminatedUnion("type", [
   RouteEventSchema,
   MessageEventSchema,
   ToolcallEventSchema,
@@ -1227,22 +1924,22 @@ function createFsStorageProvider(root) {
 }
 
 // src/telemetry/types.ts
-import { z as z5 } from "zod";
-var CostRecordSchema = z5.object({
-  ts: z5.number().finite(),
-  sessionID: z5.string().min(1).optional(),
-  promptHash: z5.string().min(1),
-  promptChars: z5.number().int().min(0),
+import { z as z7 } from "zod";
+var CostRecordSchema = z7.object({
+  ts: z7.number().finite(),
+  sessionID: z7.string().min(1).optional(),
+  promptHash: z7.string().min(1),
+  promptChars: z7.number().int().min(0),
   tier: ComplexityTierSchema,
-  routeKind: z5.enum(["local", "frontier", "blocked"]),
+  routeKind: z7.enum(["local", "frontier", "blocked"]),
   selected: ModelRefSchema,
-  rationale: z5.string(),
-  estimatedCostUSD: z5.number().finite().min(0).nullable(),
-  baselineCostUSD: z5.number().finite().min(0).nullable(),
-  estimatedSavingsUSD: z5.number().finite().nullable(),
-  budgetAction: z5.string().min(1),
-  tokensIn: z5.number().int().min(0).optional(),
-  tokensOut: z5.number().int().min(0).optional()
+  rationale: z7.string(),
+  estimatedCostUSD: z7.number().finite().min(0).nullable(),
+  baselineCostUSD: z7.number().finite().min(0).nullable(),
+  estimatedSavingsUSD: z7.number().finite().nullable(),
+  budgetAction: z7.string().min(1),
+  tokensIn: z7.number().int().min(0).optional(),
+  tokensOut: z7.number().int().min(0).optional()
 }).strict();
 
 // src/telemetry/read.ts
@@ -1430,7 +2127,7 @@ function hashPrompt(prompt) {
 }
 
 // src/orchestrator/coordinator.ts
-var TelemetryFailureClassSchema = z6.enum([
+var TelemetryFailureClassSchema = z8.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -1581,8 +2278,8 @@ function redactFrameText(text) {
   return `[redacted · ${text.length} chars · ${hashPrompt(text)}]`;
 }
 var MAX_INPUT_CHARS = 1e5;
-var SessionInputSchema = z7.object({
-  text: z7.string().min(1).max(MAX_INPUT_CHARS)
+var SessionInputSchema = z9.object({
+  text: z9.string().min(1).max(MAX_INPUT_CHARS)
 }).strict();
 function parseSessionInput(raw) {
   const result = SessionInputSchema.safeParse(raw);
@@ -1768,13 +2465,20 @@ function createConsoleClient(deps) {
       await post(`/session/${encodeURIComponent(sessionID)}/permissions/${encodeURIComponent(permissionID)}`, { response });
     },
     async listMessages(sessionID, options) {
-      const res = await doFetch(`${base}/session/${encodeURIComponent(sessionID)}/message`, { headers: { accept: "application/json", ...authHeaders } });
+      const res = await doFetch(`${base}/session/${encodeURIComponent(sessionID)}/message`, {
+        headers: { accept: "application/json", ...authHeaders },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!res.ok)
+        throw new Error(consoleDetailMessages.readFailed);
       let raw;
       try {
         raw = await res.json();
       } catch {
-        return [];
+        throw new Error(consoleDetailMessages.readFailed);
       }
+      if (!Array.isArray(raw))
+        throw new Error(consoleDetailMessages.readFailed);
       return messagesToFrames(raw, sessionID, options ?? {});
     },
     async streamFrames(sessionID, onFrame, signal, options) {
@@ -2302,7 +3006,7 @@ async function buildSqliteIndexFromConfig(path, sessionsDir, deps) {
 }
 
 // src/config/errors.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var ROOT_PATH = "<root>";
 var MODEL_REF_KEYS = ["providerID", "modelID"];
 var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
@@ -2377,11 +3081,13 @@ var KNOWN_CONFIG_KEYS_BY_PATH = new Map([
       "openBrowser",
       "remoteStorage",
       "terminal",
-      "graphView"
+      "graphView",
+      "sessionHistory"
     ]
   ],
   ["console.terminal", ["enabled", "pty"]],
   ["console.graphView", ["enabled"]],
+  ["console.sessionHistory", ["contentEnabled", "endpoint"]],
   ["storage", ["sqliteIndex"]],
   ["storage.sqliteIndex", ["enabled", "path"]],
   ["memory", ["semantic"]],
@@ -2506,7 +3212,7 @@ function formatUnrecognizedKeys(issues, knownKeysByPath) {
   return messages;
 }
 function formatZodBoundaryError(error, options = {}) {
-  if (error instanceof z8.ZodError) {
+  if (error instanceof z10.ZodError) {
     const unknownKeys = formatUnrecognizedKeys(error.issues, options.knownKeysByPath ?? KNOWN_CONFIG_KEYS_BY_PATH);
     const otherIssues = error.issues.filter((issue) => !isUnrecognizedKeysIssue(issue)).map((issue) => {
       const path = formatConfigPath(issue.path);
@@ -2656,17 +3362,17 @@ function compareRoleIDs([left], [right]) {
   return left === right ? 0 : left < right ? -1 : 1;
 }
 function policyModelReferences(policy, path) {
-  const references = [];
+  const references2 = [];
   if (policy?.model !== undefined && policy.model !== "auto") {
-    references.push({ path: `${path}.model`, model: policy.model });
+    references2.push({ path: `${path}.model`, model: policy.model });
   }
   for (const [index, fallback] of (policy?.fallbacks ?? []).entries()) {
-    references.push({
+    references2.push({
       path: `${path}.fallbacks.${index}`,
       model: fallback
     });
   }
-  return references;
+  return references2;
 }
 function configuredPolicies(config) {
   const policies = [
@@ -2829,7 +3535,7 @@ async function writeOpenTeamConfigFile(config, path = DEFAULT_CONFIG_PATH, stora
 }
 
 // src/config/runtime.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var CONFIG_KEYS = [
   "baseline",
   "router",
@@ -2845,18 +3551,18 @@ var CONFIG_KEYS = [
 ];
 var CONFIG_KEY_SET = new Set(CONFIG_KEYS);
 var TELEMETRY_PLUGIN_OPTION_KEY = "telemetry";
-var configOptionSchemas = Object.fromEntries(CONFIG_KEYS.map((key) => [key, z9.unknown().optional()]));
-var TelemetryPluginOptionsObjectSchema = z9.object({
-  enabled: z9.boolean().default(true),
-  path: z9.string().min(1).default(DEFAULT_TELEMETRY_PATH),
-  sessionsDir: z9.string().min(1).default(DEFAULT_SESSIONS_DIR)
+var configOptionSchemas = Object.fromEntries(CONFIG_KEYS.map((key) => [key, z11.unknown().optional()]));
+var TelemetryPluginOptionsObjectSchema = z11.object({
+  enabled: z11.boolean().default(true),
+  path: z11.string().min(1).default(DEFAULT_TELEMETRY_PATH),
+  sessionsDir: z11.string().min(1).default(DEFAULT_SESSIONS_DIR)
 }).strict();
 var TelemetryPluginOptionsSchema = TelemetryPluginOptionsObjectSchema.default({
   enabled: true,
   path: DEFAULT_TELEMETRY_PATH,
   sessionsDir: DEFAULT_SESSIONS_DIR
 });
-var PluginOptionsObjectSchema = z9.object({
+var PluginOptionsObjectSchema = z11.object({
   ...configOptionSchemas,
   [TELEMETRY_PLUGIN_OPTION_KEY]: TelemetryPluginOptionsObjectSchema.optional()
 }).strict();
@@ -2978,7 +3684,8 @@ function isJsonObject2(value) {
 var MACHINE_SPECIFIC_KEYS = [
   "local.runtimes",
   "console.host",
-  "console.port"
+  "console.port",
+  "console.sessionHistory"
 ];
 var HOT_RELOADABLE_KEYS = ["console.refreshMs"];
 var KNOWN_ENV_SECRETS = [
@@ -3531,10 +4238,411 @@ async function handleLifecycleHistoryRoute(request, response, url, deps) {
   return true;
 }
 
+// src/console/inspector.ts
+var CONVERSATION_CLIENT_JS = `
+function wireConversationInspector(){
+  var mount=document.getElementById('lifecycle-timeline-mount');
+  if(!mount){return}
+  var msg=${JSON.stringify(consoleDetailMessages)};
+  var limits=${JSON.stringify(CONVERSATION_LIMITS)};
+  var panel=document.createElement('section');panel.className='lc-conversation';panel.hidden=true;panel.id='lc-attempt-conversation';
+  panel.setAttribute('data-conversation-inspector','');
+  panel.setAttribute('aria-labelledby','lc-conversation-heading');
+  mount.appendChild(panel);
+  var selection=null,request=null,epoch=0,retained=null;
+  function element(tag,text){var e=document.createElement(tag);if(text!==undefined){e.textContent=text}return e}
+  function selectedButton(){
+    if(!selection||mount.getAttribute('data-conversation-transition')==='1'||
+      mount.getAttribute('data-lifecycle-run')!==selection.run||
+      (mount.getAttribute('data-conversation-cursor')||null)!==selection.cursor){return null}
+    return Array.from(mount.querySelectorAll('[data-inspect-attempt],[data-inspect-root]')).find(function(button){
+      var attempt=button.closest('[data-lifecycle-attempt-id]');
+      var operation=button.closest('[data-lifecycle-operation-id]');
+      var session=button.closest(selection.target==='root'?'[data-root-session-id]':'[data-lifecycle-session-id]');
+      return !button.disabled&&operation&&session&&
+        (selection.target==='root'?button.hasAttribute('data-inspect-root'):attempt&&attempt.getAttribute('data-lifecycle-attempt-id')===selection.attempt&&
+        button.getAttribute('data-inspect-attempt')===selection.attempt)&&
+        operation.getAttribute('data-lifecycle-operation-id')===selection.operation&&
+        button.getAttribute('data-inspect-operation')===selection.operation&&
+        session.getAttribute(selection.target==='root'?'data-root-session-id':'data-lifecycle-session-id')===selection.session;
+    })||null;
+  }
+  function expanded(button,open){
+    if(button.getAttribute('aria-expanded')!==String(open)){button.setAttribute('aria-expanded',String(open))}
+    var label=open?msg.close:msg.inspectConversation;
+    if(button.textContent!==label){button.textContent=label}
+  }
+  function cancel(){
+    epoch++;if(request){request.abort();request=null}
+  }
+  function close(focus){
+    var button=selectedButton();
+    cancel();selection=null;retained=null;
+    mount.querySelectorAll('[data-inspect-attempt],[data-inspect-root]').forEach(function(control){expanded(control,false)});
+    panel.textContent='';panel.hidden=true;
+    ['data-conversation-kind','data-conversation-run','data-conversation-operation','data-conversation-attempt','data-conversation-session','data-conversation-target','aria-busy'].forEach(function(name){panel.removeAttribute(name)});
+    mount.appendChild(panel);
+    if(focus===true&&button){button.focus({preventScroll:true})}
+  }
+  // The renderer replaces metadata, not retained content. Restore only after
+  // the real run/cursor commits and the same attempt/session is still visible.
+  function retain(){
+    if(!selection||panel.hidden||!selectedButton()){return}
+    var scrolls=[],ancestor=panel.parentElement;
+    while(ancestor){scrolls.push([ancestor,ancestor.scrollTop,ancestor.scrollLeft]);ancestor=ancestor.parentElement}
+    panel.querySelectorAll('pre,[data-conversation-tool-list]').forEach(function(node){scrolls.push([node,node.scrollTop,node.scrollLeft])});
+    retained={scrolls:scrolls,top:panel.getBoundingClientRect().top,focus:panel.contains(document.activeElement)?document.activeElement:null};
+  }
+  function reanchor(){
+    if(!selection){return}
+    var button=selectedButton();
+    if(!button){close();return}
+    var attempt=selection.target==='root'?button.closest('.lct-operation-card'):button.closest('[data-lifecycle-attempt-id]');
+    if(panel.parentElement!==attempt){attempt.appendChild(panel)}
+    expanded(button,true);
+    if(retained){
+      retained.scrolls.forEach(function(item){if(item[0].isConnected){item[0].scrollTop=item[1];item[0].scrollLeft=item[2]}});
+      var tree=mount.querySelector('[data-lifecycle-tree-mount]');
+      if(tree){tree.scrollTop+=panel.getBoundingClientRect().top-retained.top}
+      if(retained.focus){retained.focus.focus({preventScroll:true})}
+      retained=null;
+    }
+  }
+  function reset(){
+    panel.textContent='';
+    var header=element('header');header.className='lc-conversation-head';
+    var heading=element('h3',msg.title);heading.id='lc-conversation-heading';heading.tabIndex=-1;header.appendChild(heading);
+    var closeBtn=element('button',msg.close);closeBtn.type='button';
+    closeBtn.setAttribute('data-conversation-close','');
+    closeBtn.addEventListener('click',function(){close(true)});header.appendChild(closeBtn);panel.appendChild(header);
+  }
+  function showHeading(){
+    var heading=panel.querySelector('h3');
+    heading.focus({preventScroll:true});
+    heading.scrollIntoView({block:'start',inline:'nearest'});
+  }
+  function load(reveal){
+    if(!selectedButton()){return}
+    cancel();var current=epoch,selected=selection;
+    reset();
+    panel.setAttribute('data-conversation-kind','loading');
+    panel.setAttribute('aria-busy','true');
+    var status=element('p',msg.loading);status.setAttribute('role','status');panel.appendChild(status);
+    var opening=null;
+    if(reveal===true){
+      showHeading();
+      opening={focus:document.activeElement,scrolls:[mount.querySelector('[data-lifecycle-tree-mount]'),mount.closest('.scroll')].filter(Boolean).map(function(node){return [node,node.scrollTop,node.scrollLeft]})};
+    }
+    var controller=new AbortController();request=controller;
+    var query=new URLSearchParams({run:selected.run,operation:selected.operation,diagnostic:'1'});
+    if(selected.target==='root'){query.set('target','root')}else{query.set('attempt',selected.attempt)}
+    query.set('token',document.documentElement.getAttribute('data-token')||'');
+    if(selected.cursor!==null){query.set('cursor',selected.cursor)}
+    var timeout=setTimeout(function(){controller.abort()},15000);
+    fetch('/api/graph/conversation?'+query.toString(),{signal:controller.signal,cache:'no-store'})
+      .then(function(r){return r.json()}).then(function(data){
+        if(epoch!==current||selection!==selected||!selectedButton()){return}
+        var bringIntoView=opening&&document.activeElement===opening.focus&&opening.scrolls.every(function(item){return item[0].scrollTop===item[1]&&item[0].scrollLeft===item[2]});
+        if((data.kind==='conversation'||data.kind==='empty')&&(data.runID!==selected.run||data.operationID!==selected.operation||
+          (selected.target==='root'?(data.target!=='root'||data.attemptID!==undefined||!data.sessionID||(!selected.session&&!['sdk-parent','tool-result'].includes(data.association))):(data.target!=='attempt'||data.attemptID!==selected.attempt))||
+          (selected.session&&data.sessionID!==selected.session))){
+          data={kind:'unavailable',message:msg.unavailable};
+        }
+        status.textContent=data.message||msg.unavailable;
+        panel.setAttribute('data-conversation-kind',data.kind||'unavailable');
+        if(data.kind==='conversation'||data.kind==='empty'){
+          panel.setAttribute('data-conversation-session',data.sessionID);
+          var source=element('p');source.appendChild(element('strong',data.session&&data.session.title|| (selected.target==='root'?msg.orchestrator:msg.session)));
+          var created=consoleLabels.utcTime(data.session&&data.session.createdAt);
+          source.appendChild(element('small',' · '+(created===msg.timeUnknown?msg.timeUnknown:msg.sessionCreated+': '+created)));
+          source.appendChild(element('code',' · '+data.sessionID));panel.appendChild(source);
+          if(data.session&&data.session.id===data.sessionID){document.dispatchEvent(new CustomEvent('console-session-metadata',{detail:{session:data.session,runID:data.runID,target:selected.target}}))}
+        }
+        if(data.kind==='conversation'){
+          renderMessages(data.messages||[]);
+        }else if(data.kind==='empty'){
+          renderMessages([]);
+        }
+        // The short loading card may not have enough scroll range. Complete
+        // the explicit reveal after layout grows, unless the reader moved on.
+        if(bringIntoView){panel.querySelector('h3').scrollIntoView({block:'start',inline:'nearest'})}
+      }).catch(function(){
+        if(epoch===current){status.textContent=msg.unavailable;panel.setAttribute('data-conversation-kind','unavailable')}
+      }).finally(function(){
+        clearTimeout(timeout);
+        if(epoch!==current){return}
+        request=null;
+        panel.setAttribute('aria-busy','false');
+        var refresh=element('button',msg.refresh);refresh.type='button';refresh.setAttribute('data-conversation-refresh','');
+        refresh.addEventListener('click',load);panel.appendChild(refresh);
+      });
+  }
+  function renderMessages(messages){
+    var truncated=messages.length>limits.messages,remaining=limits.totalChars,toolCount=0;
+    messages=messages.slice(0,limits.messages);
+    var tools=element('details');tools.setAttribute('data-conversation-tools','');tools.open=true;
+    var count=messages.reduce(function(total,m){return total+(m.tools||[]).length},0);
+    tools.appendChild(element('summary',msg.tools.replace('{count}',String(count))));
+    var calls=element('div');calls.setAttribute('data-conversation-tool-list','');tools.appendChild(calls);
+    panel.appendChild(tools);
+    function text(value){
+      value=String(value);
+      var size=Math.min(value.length,limits.fieldChars+msg.truncatedMarker.length,remaining);
+      remaining-=size;
+      if(size<value.length){truncated=true}
+      return value.slice(0,size);
+    }
+    ['user','assistant'].forEach(function(role){
+      var section=element('section');section.setAttribute('data-conversation-role',role);
+      section.appendChild(element('h4',role==='user'?msg.prompt:msg.assistant));
+      var hasText=false;
+      messages.filter(function(m){return m.role===role}).forEach(function(m){
+        var item=element('article');item.appendChild(element('time',consoleLabels.utcTime(m.createdAt)));
+        if((m.text||[]).length>limits.parts){truncated=true}
+        (m.text||[]).slice(0,limits.parts).forEach(function(value){
+          if(!value){return}
+          hasText=true;
+          if(remaining>0){item.appendChild(element('pre',text(value)))}else{truncated=true}
+        });
+        if(item.querySelector('pre')){section.appendChild(item)}
+      });panel.appendChild(section);
+      if(!hasText){section.appendChild(element('p',role==='user'?msg.noPrompts:msg.noOutput))}
+    });
+    messages.forEach(function(m){
+      if((m.tools||[]).length>limits.parts){truncated=true}
+      (m.tools||[]).slice(0,limits.parts).forEach(function(tool){
+        if(toolCount++>=limits.tools||remaining<=0){truncated=true;return}
+        var call=element('details');call.setAttribute('data-tool-call',tool.id);
+        call.appendChild(element('summary',text(tool.name)+' · '+text(tool.status)));
+        if(tool.startedAt!==undefined){call.appendChild(element('time',consoleLabels.utcTime(tool.startedAt)))}
+        call.appendChild(element('h5',msg.arguments));call.appendChild(element('pre',text(tool.arguments)));
+        call.appendChild(element('h5',msg.result));call.appendChild(element('pre',text(tool.result===undefined?msg.pending:tool.result)));
+        calls.appendChild(call);
+      });
+    });
+    if(count===0){calls.appendChild(element('p',msg.noTools))}
+    if(truncated){panel.appendChild(element('p',msg.truncated))}
+  }
+  mount.addEventListener('click',function(event){
+    var button=event.target.closest('[data-inspect-attempt],[data-inspect-root]');
+    if(!button||button.disabled||mount.getAttribute('data-conversation-transition')==='1'){return}
+    if(button===selectedButton()){close(true);return}
+    close();
+    var root=button.hasAttribute('data-inspect-root');
+    var session=button.closest(root?'[data-root-session-id]':'[data-lifecycle-session-id]');
+    if(!session){return}
+    selection={
+      run:mount.getAttribute('data-lifecycle-run'),
+      operation:button.getAttribute('data-inspect-operation'),
+      attempt:button.getAttribute('data-inspect-attempt'),
+      target:root?'root':'attempt',
+      session:session.getAttribute(root?'data-root-session-id':'data-lifecycle-session-id'),
+      cursor:mount.getAttribute('data-conversation-cursor')||null
+    };
+    if(!selectedButton()){close();return}
+    panel.setAttribute('data-conversation-run',selection.run);
+    panel.setAttribute('data-conversation-operation',selection.operation);
+    if(selection.attempt){panel.setAttribute('data-conversation-attempt',selection.attempt)}
+    panel.setAttribute('data-conversation-target',selection.target);
+    panel.setAttribute('data-conversation-session',selection.session);
+    reanchor();
+    panel.hidden=false;
+    if(selection.cursor!==null){reset();panel.setAttribute('data-conversation-kind','historical');panel.appendChild(element('p',msg.historical));showHeading()}
+    else{load(true)}
+  });
+  document.addEventListener('conversation-selection',close);
+  document.addEventListener('conversation-tree-replacing',retain);
+  document.addEventListener('conversation-tree-committed',reanchor);
+  window.addEventListener('pagehide',close);
+}
+`;
+var CONVERSATION_STYLE = `
+.lc-conversation{margin-top:12px;padding:12px;min-width:0;border:1px solid var(--cp-border);border-radius:16px;background:var(--cp-surface);color:var(--cp-text);overflow-anchor:none}
+.lc-conversation[hidden]{display:none}
+.lc-conversation-head{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px}
+.lc-conversation h3,.lc-conversation h4,.lc-conversation p{margin:8px 0}
+.lc-conversation h3{scroll-margin-top:12px}
+.lc-conversation pre{white-space:pre-wrap;overflow-wrap:anywhere;max-height:400px;overflow:auto;background:var(--cp-surface-soft);padding:12px;font-family:Consolas,"Courier New",Courier,monospace}
+.lc-conversation [data-conversation-role="user"] pre{max-height:180px}
+.lc-conversation [data-conversation-tool-list]{max-height:160px;overflow:auto}
+.lc-conversation details{margin-top:12px;padding:8px;border:1px solid var(--cp-border);border-radius:.625rem}
+.lc-conversation summary{cursor:pointer;color:var(--cp-accent)}
+.lc-conversation time{font-size:11px;color:var(--cp-text-muted)}
+.lc-conversation button,[data-inspect-attempt],[data-inspect-root]{padding:6px 10px;margin:6px;border:1px solid var(--cp-border);border-radius:.625rem;background:var(--cp-surface);color:var(--cp-accent)}
+.lct-operation-name{display:block;font-size:16px}
+.lct-operation-head details,.lct-session details{font-size:11px;color:var(--cp-text-muted)}
+.lct-session small,.session-btn small{display:block;color:var(--cp-text-muted)}
+.lc-run-select{max-width:650px}
+`;
+
+// src/console/refresh.ts
+var CONSOLE_REFRESH_JS = `
+  var viewRevision='',viewRequest=null,viewPending=false,viewStopped=false,latestView=null;
+  var appliedRouting='',appliedLogs='',appliedTree='';
+  function protectedContent(element){
+    var active=document.activeElement;
+    if(active&&element.contains(active)&&/^(INPUT|TEXTAREA|SELECT)$/.test(active.tagName)){return true}
+    var selection=window.getSelection&&window.getSelection();
+    return !!(selection&&!selection.isCollapsed&&element.contains(selection.anchorNode));
+  }
+  function nodeKey(node){
+    if(node.nodeType!==1){return ''}
+    return (node.hasAttribute('data-session-target')?'session-target:'+node.getAttribute('data-session-target'):
+      node.hasAttribute('data-session-view')?'session-view:'+node.getAttribute('data-session-view'):node.id)||
+      ((node.tagName==='LI'||node.tagName==='TR')?node.outerHTML:'');
+  }
+  function patchNode(old,next){
+    if(old.isEqualNode(next)){return}
+    if(old.nodeType!==next.nodeType||old.nodeName!==next.nodeName){
+      old.replaceWith(next.cloneNode(true));return;
+    }
+    if(old.nodeType===3){old.nodeValue=next.nodeValue;return}
+    if(old.nodeType!==1){return}
+    if(old.matches('[data-session-name],[data-session-time]')){
+      if(old.getAttribute('data-label-fallback')!==next.textContent){old.setAttribute('data-label-fallback',next.textContent)}
+      return;
+    }
+    if(old.matches('input,textarea,select,.term,.pty,.graph-drill,[data-config-mount]')){return}
+    Array.from(old.attributes).forEach(function(a){
+      if(a.name!=='open'&&a.name!=='hidden'&&a.name!=='aria-selected'&&!next.hasAttribute(a.name)){old.removeAttribute(a.name)}
+    });
+    Array.from(next.attributes).forEach(function(a){
+      if(a.name!=='open'&&a.name!=='hidden'&&a.name!=='aria-selected'&&old.getAttribute(a.name)!==a.value){old.setAttribute(a.name,a.value)}
+    });
+    var originals=Array.from(old.childNodes),used=new Set();
+    Array.from(next.childNodes).forEach(function(child,index){
+      var key=nodeKey(child),match;
+      if(key){match=originals.find(function(n){return !used.has(n)&&nodeKey(n)===key})}
+      else{match=originals.find(function(n){return !used.has(n)&&!nodeKey(n)&&n.nodeName===child.nodeName})}
+      if(match){used.add(match);patchNode(match,child)}
+      else{match=child.cloneNode(true)}
+      if(old.childNodes[index]!==match){
+        var scrolls=match.nodeType===1?[match].concat(Array.from(match.querySelectorAll('*'))).map(function(n){return [n,n.scrollTop,n.scrollLeft]}):[];
+        old.insertBefore(match,old.childNodes[index]||null);
+        scrolls.forEach(function(s){s[0].scrollTop=s[1];s[0].scrollLeft=s[2]});
+      }
+    });
+    originals.forEach(function(n){
+      if(!used.has(n)&&n.parentNode===old){
+        if(n.nodeType===1){
+          disconnectTerminal(n);
+          n.querySelectorAll('[data-session-view]').forEach(disconnectTerminal);
+        }
+        old.removeChild(n);
+      }
+    });
+  }
+  function patchHtml(element,html){
+    var next=document.createElement('div');
+    next.innerHTML=html;
+    var shell=element.cloneNode(false);
+    while(next.firstChild){shell.appendChild(next.firstChild)}
+    patchNode(element,shell);
+  }
+  function applyView(forceLogs){
+    if(!latestView){return}
+    var tree=document.querySelector('#screen-tree > .graph-panel');
+    if(tree&&latestView.tree&&latestView.tree!==appliedTree&&!protectedContent(tree)){
+      var graph=document.createElement('div');graph.innerHTML=latestView.tree;
+      if(graph.firstElementChild){patchNode(tree,graph.firstElementChild)}
+      appliedTree=latestView.tree;
+    }
+    var routing=document.querySelector('#screen-routing > .screen-grid');
+    if(routing&&latestView.routing!==appliedRouting&&!protectedContent(routing)){
+      var next=document.createElement('div');next.innerHTML=latestView.routing;
+      if(next.firstElementChild){patchNode(routing,next.firstElementChild)}
+      appliedRouting=latestView.routing;
+    }
+    var logs=document.getElementById('screen-logs');
+    var content=logs&&logs.querySelector('[data-log-content]');
+    var follow=logs&&logs.querySelector('[data-log-follow]');
+    var incoming=logs&&logs.querySelector('[data-log-incoming]');
+    var scroll=document.querySelector('.scroll');
+    if(content&&latestView.logs!==appliedLogs){
+      if(appliedLogs===''&&content.innerHTML===latestView.logs){appliedLogs=latestView.logs}
+      else{
+        var atBottom=!scroll||scroll.scrollHeight-scroll.scrollTop-scroll.clientHeight<40;
+        var safe=logs.hidden||(follow&&follow.checked&&atBottom);
+        if((forceLogs||safe)&&!protectedContent(content)){
+          var top=scroll&&scroll.scrollTop;
+          patchHtml(content,latestView.logs);
+          appliedLogs=latestView.logs;
+          wireLogsScreen(logs);
+          if(scroll&&!logs.hidden){scroll.scrollTop=follow&&follow.checked?scroll.scrollHeight:top}
+        }
+      }
+      if(incoming){incoming.hidden=latestView.logs===appliedLogs&&!Array.from(content.querySelectorAll('.termlog')).some(function(log){return log.__incoming})}
+    }
+    var count=document.querySelector('[data-screen="logs"] .count');
+    if(count&&count.textContent!==String(latestView.sessionCount)){count.textContent=String(latestView.sessionCount)}
+    if(typeof consoleLabels!=='undefined'){consoleLabels.refresh()}
+  }
+  function refreshView(){
+    if(viewStopped){return}
+    applyView(false);
+    if(viewRequest){viewPending=true;return}
+    viewPending=false;
+    var controller=new AbortController();
+    viewRequest=controller;
+    var timeout=setTimeout(function(){controller.abort()},15000);
+    fetch('/api/view'+authTok,{headers:viewRevision?{'If-None-Match':viewRevision}:{},signal:controller.signal})
+      .then(function(r){
+        var error=document.querySelector('[data-refresh-error]');
+        if(error){error.hidden=r.ok||r.status===304}
+        if(r.status===304){return null}
+        if(!r.ok){throw new Error()}
+        var revision=r.headers.get('etag')||'';
+        return r.json().then(function(d){return {data:d,revision:revision}});
+      }).then(function(result){
+        if(viewStopped||viewRequest!==controller||!result){return}
+        if(typeof result.data.routing!=='string'||typeof result.data.logs!=='string'){return}
+        latestView=result.data;viewRevision=result.revision;
+        var updated=document.querySelector('.token-chip b');
+        if(updated&&typeof latestView.updatedAt==='string'){updated.textContent=latestView.updatedAt}
+        if(Number.isInteger(latestView.refreshMs)&&latestView.refreshMs>=250&&latestView.refreshMs!==ms){
+          ms=latestView.refreshMs;document.documentElement.setAttribute('data-refresh',String(ms));
+          clearInterval(refreshTimer);refreshTimer=null;startRefresh();
+          document.dispatchEvent(new CustomEvent('console-refresh-changed',{detail:ms}));
+        }
+        applyView(false);
+      }).catch(function(){
+        var error=document.querySelector('[data-refresh-error]');
+        if(error&&!viewStopped){error.hidden=false}
+      }).finally(function(){
+        clearTimeout(timeout);
+        if(viewRequest!==controller){return}
+        viewRequest=null;
+        if(viewPending&&!viewStopped){refreshView()}
+      });
+  }
+  var refreshTimer=null;
+  function startRefresh(){
+    if(refreshTimer!==null){return}
+    viewStopped=false;
+    refreshTimer=setInterval(refreshView,isNaN(ms)?2000:Math.max(250,ms));
+  }
+  window.addEventListener('pagehide',function(){
+    viewStopped=true;clearInterval(refreshTimer);refreshTimer=null;
+    if(viewRequest){viewRequest.abort();viewRequest=null}
+    if(es){es.close();es=null}
+    document.querySelectorAll('[data-session-view]').forEach(disconnectTerminal);
+  });
+  window.addEventListener('pageshow',function(e){
+    if(e.persisted){
+      startRefresh();openStateStream();refreshView();
+      var logs=document.getElementById('screen-logs');
+      if(logs&&!logs.hidden){wireLogsScreen(logs)}
+    }
+  });
+`;
+
 // src/console/assets.ts
 var CONSOLE_STYLE = `
 :root{color-scheme:dark;--bg:#0f0f0f;--surface:#17181b;--surface-2:#1e2024;--panel:var(--surface);--fg:#eceef1;--muted:#a2a8b2;--faint:#6b7079;--border:rgba(255,255,255,.08);--border-strong:rgba(255,255,255,.16);--line:var(--border);--accent:#35c07a;--accent-bg:rgba(53,192,122,.12);--accent-fg:#57d492;--good:var(--accent-fg);--local:#6aa6f5;--frontier:#e0a53a;--warn:#e0a53a;--warn-bg:rgba(224,165,58,.12);--danger:#f0687f;--danger-bg:rgba(240,104,127,.12);--info:#6aa6f5;--info-bg:rgba(106,166,245,.12);--font-sans:-apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;--font-mono:"JetBrains Mono","IBM Plex Mono",ui-monospace,"SFMono-Regular",Consolas,monospace;--shadow-pop:0 8px 28px rgba(0,0,0,.5);--sidebar-w:248px}
 *{box-sizing:border-box;margin:0;padding:0}
+[data-log-controls]{display:flex;gap:12px;align-items:center;flex-wrap:wrap;margin-bottom:16px}
+[data-log-controls] input,[data-log-controls] button{padding:6px;border:1px solid var(--cp-border);border-radius:.625rem;background:var(--cp-surface);color:var(--cp-text)}
+[data-session-target][hidden]{display:none}
 html,body{height:100%}
 body{background:var(--bg);color:var(--fg);font:14px/1.55 var(--font-sans);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;font-variant-numeric:tabular-nums}
 .mono,code,.hash{font-family:var(--font-mono);font-variant-numeric:tabular-nums}
@@ -3609,25 +4717,21 @@ svg.graph{display:block}
 `;
 var CONSOLE_CLIENT_JS = `
 (function(){
+  var detailMsg=${JSON.stringify(consoleDetailMessages)};
+  var terminalCollectors=[];
   var authTok='';
   try{
     var qp=new URLSearchParams(window.location.search).get('token');
     if(qp){authTok='?token='+encodeURIComponent(qp)}
   }catch(e){/* ignore */}
-  function reloadIfChanged(prev){
-    fetch('/api/state'+authTok).then(function(r){return r.json()}).then(function(s){
-      if(s.generatedAt!==prev&&!configActive()&&!lifecycleActive()){location.reload()}
-    }).catch(function(){});
-  }
-  var current=document.documentElement.getAttribute('data-generated')||'';
+  ${CONSOLE_REFRESH_JS}
+  var es=null;
+  function openStateStream(){
   if('EventSource' in window){
     try{
-      var es=new EventSource('/events'+authTok);
+      es=new EventSource('/events'+authTok);
       es.addEventListener('state',function(ev){
-        try{
-          var d=JSON.parse(ev.data||'{}');
-          if(d.generatedAt&&d.generatedAt!==current&&!configActive()&&!lifecycleActive()){location.reload()}
-        }catch(e){}
+        refreshView();
       });
       es.addEventListener('graph-append',function(ev){
         try{
@@ -3638,26 +4742,22 @@ var CONSOLE_CLIENT_JS = `
       es.onerror=function(){/* fallback below */};
     }catch(e){/* ignore */}
   }
+  }
   var ms=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
-  setInterval(function(){reloadIfChanged(current)},isNaN(ms)?2000:Math.max(250,ms));
+  startRefresh();
+  openStateStream();
 
-  function configActive(){
-    var s=document.getElementById('screen-config');
-    return !!(s&&!s.hidden);
-  }
-  // Only the visible timeline owns incremental refresh. Other screens still
-  // need state reloads; their navigation preserves the timeline URL selection.
-  function lifecycleActive(){
-    var mount=document.getElementById('lifecycle-timeline-mount');
-    var screen=mount&&mount.closest('.screen');
-    return !!(screen&&!screen.hidden);
-  }
   function wireLogsScreen(screen){
-    if(screen.__logsWired){return}
-    screen.__logsWired=true;
-    var buttons=screen.querySelectorAll('[data-session-target]');
-    var cards=screen.querySelectorAll('[data-session-view]');
+    function filterSessions(){
+      var filter=screen.querySelector('[data-log-filter]');
+      var value=filter?filter.value.toLowerCase():'';
+      var buttons=screen.querySelectorAll('[data-session-target]');
+      for(var i=0;i<buttons.length;i++){buttons[i].hidden=buttons[i].getAttribute('data-session-target').toLowerCase().indexOf(value)===-1}
+    }
     function showSession(id){
+      var buttons=screen.querySelectorAll('[data-session-target]');
+      var cards=screen.querySelectorAll('[data-session-view]');
+      screen.__selectedSession=id;
       var matched=false;
       for(var i=0;i<buttons.length;i++){
         var on=buttons[i].getAttribute('data-session-target')===id;
@@ -3667,19 +4767,41 @@ var CONSOLE_CLIENT_JS = `
       for(var j=0;j<cards.length;j++){
         var show=cards[j].getAttribute('data-session-view')===id;
         cards[j].hidden=!show;
-        if(show){matched=true;connectTerminal(cards[j],id)}
+        if(show){matched=true;if(!screen.hidden){connectTerminal(cards[j],id)}}
       }
+      updateTerminalLeases();
       return matched;
     }
-    for(var k=0;k<buttons.length;k++){
-      buttons[k].addEventListener('click',function(e){
-        var id=e.currentTarget.getAttribute('data-session-target');
-        if(id){showSession(id)}
+    if(!screen.__logsWired){
+      screen.__logsWired=true;
+      screen.addEventListener('click',function(e){
+        var button=e.target.closest('[data-session-target]');
+        if(button){showSession(button.getAttribute('data-session-target'))}
+        if(e.target.closest('[data-log-incoming]')){applyView(true);followTerminalOutput(screen)}
       });
+      var follow=screen.querySelector('[data-log-follow]');
+      if(follow){follow.addEventListener('change',function(){
+        if(follow.checked){
+          applyView(true);followTerminalOutput(screen);
+          var viewport=document.querySelector('.scroll');if(viewport){viewport.scrollTop=viewport.scrollHeight}
+        }
+      })}
+      var filter=screen.querySelector('[data-log-filter]');
+      if(filter){filter.addEventListener('input',filterSessions)}
+      var scroll=document.querySelector('.scroll');
+      if(scroll&&follow){
+        scroll.addEventListener('scroll',function(){if(!screen.hidden&&scroll.scrollHeight-scroll.scrollTop-scroll.clientHeight>40){follow.checked=false}});
+        screen.addEventListener('scroll',function(e){
+          var target=e.target;
+          if(target.scrollHeight-target.scrollTop-target.clientHeight>40){follow.checked=false}
+        },true);
+      }
     }
+    var buttons=screen.querySelectorAll('[data-session-target]');
     if(buttons.length>0){
-      showSession(buttons[0].getAttribute('data-session-target'));
+      if(!showSession(screen.__selectedSession)){showSession(buttons[0].getAttribute('data-session-target'))}
     }
+    filterSessions();
   }
   function selectScreen(name){
     var screens=document.querySelectorAll('.screen');
@@ -3707,6 +4829,7 @@ var CONSOLE_CLIENT_JS = `
     if(title){title.textContent=titleText}
     if(name==='config'&&activeScreen){loadConfig(activeScreen)}
     if(name==='logs'&&activeScreen){wireLogsScreen(activeScreen)}
+    updateTerminalLeases();
     try{localStorage.setItem('openteam.screen',name)}catch(e){}
     document.body.classList.remove('nav-open');
     return true;
@@ -3754,28 +4877,74 @@ var CONSOLE_CLIENT_JS = `
         .catch(function(){if(btn){btn.disabled=false}out.innerHTML='<div class="config-summary"><p class="config-err">Save failed.</p></div>'});
     });
   }
+  function disconnectTerminal(view){
+    clearTimeout(view.__lease);view.__lease=null;
+    terminalCollectors=terminalCollectors.filter(function(item){return item!==view});
+    if(view.__stream){
+      view.__stream.close();view.__stream=null;
+      if(view.__append){view.__append('status',detailMsg.terminalGap)}
+    }
+  }
+  function updateTerminalLeases(){
+    terminalCollectors.forEach(function(view){
+      var screen=view.closest('.screen');
+      if(!view.hidden&&screen&&!screen.hidden){clearTimeout(view.__lease);view.__lease=null}
+      else if(!view.__lease){view.__lease=setTimeout(function(){disconnectTerminal(view)},300000)}
+    });
+  }
+  function followTerminalOutput(screen){
+    screen.querySelectorAll('.termlog').forEach(function(log){
+      log.scrollTop=log.scrollHeight;log.__incoming=false;
+    });
+    var incoming=screen.querySelector('[data-log-incoming]');
+    if(incoming&&(!latestView||latestView.logs===appliedLogs)){incoming.hidden=true}
+  }
   function connectTerminal(view,id){
-    if(view.__wired){return}
     var root=document.documentElement;
     var token=root.getAttribute('data-token');
     if(root.getAttribute('data-terminal')!=='1'||!token){return}
     var log=view.querySelector('.termlog');
     if(!log){return}
-    view.__wired=true;
     function append(cls,text){
+      var atBottom=log.scrollHeight-log.scrollTop-log.clientHeight<40;
+      var screen=view.closest('.screen');
+      var follow=screen&&screen.querySelector('[data-log-follow]');
       var line=document.createElement('div');
-      line.className='tl '+cls;line.textContent=text;
-      log.appendChild(line);log.scrollTop=log.scrollHeight;
+      line.className='tl '+cls;line.textContent=String(text).slice(0,16384);
+      log.appendChild(line);
+      var removed=false;
+      while(log.children.length>1000||log.textContent.length>262144){log.removeChild(log.firstChild);removed=true}
+      if(removed){
+        var notice=view.querySelector('[data-terminal-truncated]');
+        if(!notice){notice=document.createElement('p');notice.setAttribute('data-terminal-truncated','');log.before(notice)}
+        notice.textContent=detailMsg.terminalTrimmed;
+      }
+      if(cls==='input'||(atBottom&&follow&&follow.checked)){log.scrollTop=log.scrollHeight}
+      else{
+        log.__incoming=true;
+        var incoming=screen&&screen.querySelector('[data-log-incoming]');
+        if(incoming){incoming.hidden=false}
+      }
     }
     var q='/console/session/'+encodeURIComponent(id);
     var tk='token='+encodeURIComponent(token);
-    if('EventSource' in window){
+    view.__append=append;
+    if(!view.__stream&&'EventSource' in window){
       try{
+        while(terminalCollectors.length>=2){disconnectTerminal(terminalCollectors[0])}
         var es=new EventSource(q+'/stream?'+tk);
-        es.addEventListener('frame',function(e){try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}}); 
-        es.onerror=function(){/* reconnects on its own */};
+        view.__stream=es;
+        terminalCollectors.push(view);
+        es.addEventListener('frame',function(e){if(view.__stream!==es){return}try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}});
+        es.onerror=function(){if(view.__stream===es){append('status',detailMsg.terminalGap)}};
       }catch(_){/* ignore */}
     }
+    // Two recently selected sessions collect bounded output across tabs; hidden
+    // collectors expire after five minutes and never occupy unbounded sockets.
+    if(view.__stream){terminalCollectors=terminalCollectors.filter(function(item){return item!==view}).concat(view)}
+    updateTerminalLeases();
+    if(view.__wired){return}
+    view.__wired=true;
     var form=view.querySelector('form.terminput');
     if(form){
       form.addEventListener('submit',function(e){
@@ -3847,29 +5016,41 @@ var CONSOLE_CLIENT_JS = `
     var title=drill.querySelector('.drill-title');
     if(!log){return}
     var es=null;
+    var epoch=0,request=null;
+    function closeDrill(){
+      epoch++;
+      if(es){es.close();es=null}
+      if(request){request.abort();request=null}
+    }
+    window.addEventListener('pagehide',closeDrill);
+    document.addEventListener('conversation-selection',function(){closeDrill();log.textContent='';drill.hidden=true});
     function append(cls,text){
       var line=document.createElement('div');
       line.className='tl '+cls;line.textContent=text;
       log.appendChild(line);log.scrollTop=log.scrollHeight;
     }
     function open(id){
-      if(es){try{es.close()}catch(_){}}
+      closeDrill();
+      var current=epoch;
+      request=new AbortController();
       log.textContent='';drill.hidden=false;
       if(title){title.textContent='Conversation · '+id}
       var tk='token='+encodeURIComponent(token);
       var base='/console/session/'+encodeURIComponent(id);
-      fetch(base+'/messages?'+tk).then(function(r){return r.ok?r.json():Promise.reject(r.status)})
-        .then(function(d){(d&&d.frames||[]).forEach(function(f){append(f.kind,f.text)})})
-        .catch(function(s){append('error','✖ could not load conversation ('+s+')')});
+      fetch(base+'/messages?'+tk,{signal:request.signal}).then(function(r){return r.ok?r.json():Promise.reject(r.status)})
+        .then(function(d){if(epoch===current){(d&&d.frames||[]).forEach(function(f){append(f.kind,f.text)})}})
+        .catch(function(s){if(epoch===current){append('error','✖ could not load conversation ('+s+')')}});
       if('EventSource' in window){
         try{
           es=new EventSource(base+'/stream?'+tk);
-          es.addEventListener('frame',function(e){try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}}); 
+          es.addEventListener('frame',function(e){if(epoch!==current){return}try{var f=JSON.parse(e.data);append(f.kind,f.text)}catch(_){}});
           es.onerror=function(){/* reconnects on its own */};
         }catch(_){/* ignore */}
       }
     }
     gview.addEventListener('click',function(e){
+      var timeline=document.getElementById('lifecycle-timeline-mount');
+      if(timeline&&timeline.getAttribute('data-conversation-transition')==='1'){return}
       var t=e.target;
       while(t&&t!==gview&&!(t.getAttribute&&t.getAttribute('data-session'))){t=t.parentNode}
       if(t&&t.getAttribute&&t.getAttribute('data-session')){open(t.getAttribute('data-session'))}
@@ -3891,7 +5072,8 @@ var CONSOLE_CLIENT_JS = `
   try{saved=localStorage.getItem('openteam.screen')||'tree'}catch(e){}
   if(!selectScreen(saved)){selectScreen('tree')}
   wireGraphDrill();
-  wireLifecycleTimeline();
+  if(typeof wireLifecycleTimeline==='function'){wireLifecycleTimeline()}
+  if(typeof wireConversationInspector==='function'){wireConversationInspector()}
 })();
 `;
 var LIFECYCLE_STYLE = `
@@ -4049,6 +5231,8 @@ var LIFECYCLE_THEME_BOOT = `
 })();
 `;
 var LIFECYCLE_CLIENT_JS = `
+${LABELS_CLIENT_JS}
+${CONVERSATION_CLIENT_JS}
 function wireLifecycleTimeline(){
   var mount=document.getElementById('lifecycle-timeline-mount');
   if(!mount){return}
@@ -4087,6 +5271,28 @@ function wireLifecycleTimeline(){
     lastSseHead:new Map()
   };
   var projectionKey='';
+  var committedRun=mount.getAttribute('data-lifecycle-run')||null,committedCursor=urlCursor();
+
+  function invalidateConversation(){
+    mount.setAttribute('data-conversation-transition','1');
+    if(treeMountEl){
+      treeMountEl.setAttribute('inert','');
+      treeMountEl.querySelectorAll('[data-inspect-attempt],[data-inspect-root]').forEach(function(button){button.disabled=true});
+    }
+    document.dispatchEvent(new CustomEvent('conversation-selection'));
+  }
+  function commitConversation(run,cursor){
+    cursor=cursor===null?null:String(cursor);
+    if(run!==committedRun||cursor!==committedCursor){invalidateConversation()}
+    committedRun=run;committedCursor=cursor;
+    mount.setAttribute('data-conversation-cursor',cursor===null?'':String(cursor));
+    mount.removeAttribute('data-conversation-transition');
+    if(treeMountEl){
+      treeMountEl.removeAttribute('inert');
+      treeMountEl.querySelectorAll('[data-inspect-attempt],[data-inspect-root]').forEach(function(button){button.disabled=false});
+    }
+    document.dispatchEvent(new CustomEvent('conversation-tree-committed'));
+  }
 
   function urlCursor(){
     try{
@@ -4168,6 +5374,7 @@ function wireLifecycleTimeline(){
   }
 
   function navigateFromUrl(initial){
+    invalidateConversation();
     state.generation++;
     cancelRequest();
     state.pending=false;
@@ -4181,6 +5388,9 @@ function wireLifecycleTimeline(){
   }
 
   function handleResponse(d,requestedCursor){
+    if(!d||(d.kind!=='view'&&d.kind!=='legacy')||(d.selection&&(d.selection.runID!==committedRun||(requestedCursor===null?null:String(requestedCursor))!==committedCursor))){
+      invalidateConversation();
+    }
     if(!d||d.version!==1){showError();return}
     if(d.kind==='error'){showApiError(d.error);return}
     if(d.kind==='disabled'){showDisabled(d);return}
@@ -4385,6 +5595,7 @@ function wireLifecycleTimeline(){
     mount.setAttribute('data-lifecycle-state', state.followLive?'live':'paused');
     mount.setAttribute('data-lifecycle-run', d.selection.runID||'');
     mount.setAttribute('data-lifecycle-head', String(state.head));
+    commitConversation(d.selection.runID,requestedCursor);
   }
 
   function syncRunOptions(runs,selectedID){
@@ -4399,12 +5610,16 @@ function wireLifecycleTimeline(){
       for(var i=0;i<runs.length;i++){
         var opt=document.createElement('option');
         opt.value=runs[i].runID;
-        var label=runs[i].runID.slice(0,16)+(runs[i].source==='legacy-graph'?' (legacy)':'');
-        opt.textContent=label;
+        opt.textContent=consoleLabels.runLabel(runs[i]);
         runSelect.appendChild(opt);
       }
     }
+    runs.forEach(function(run){
+      var opt=Array.from(runSelect.options).find(function(option){return option.value===run.runID});
+      if(opt){opt.title=run.runID;opt.setAttribute('data-run-started',run.startedAt===null?'':String(run.startedAt));opt.setAttribute('data-run-authority',run.executionAuthority);opt.setAttribute('data-run-session',run.rootSessionID||'')}
+    });
     runSelect.value=selectedID;
+    var technical=mount.querySelector('[data-lifecycle-run-id]');if(technical&&technical.textContent!==selectedID){technical.textContent=selectedID}
   }
 
   function renderLegacy(d){
@@ -4441,14 +5656,17 @@ function wireLifecycleTimeline(){
     mount.setAttribute('data-lifecycle-state','legacy');
     mount.setAttribute('data-lifecycle-run',d.selection.runID||'');
     mount.setAttribute('data-lifecycle-head','0');
+    commitConversation(d.selection.runID,null);
   }
 
   function renderProjection(proj,recording){
     if(!proj||!treeMountEl){return}
     var degraded=recording&&recording.state==='degraded';
-    var key=JSON.stringify([proj.runID,proj.cursor,proj.rootOperationID,proj.operations,degraded]);
+    var option=runSelect&&Array.from(runSelect.options).find(function(o){return o.value===proj.runID});
+    var key=JSON.stringify([proj.runID,proj.cursor,proj.rootOperationID,proj.operations,degraded,option&&option.getAttribute('data-run-session')]);
     if(key===projectionKey){return}
     projectionKey=key;
+    document.dispatchEvent(new CustomEvent('conversation-tree-replacing'));
     treeMountEl.textContent='';
     if(degraded){
       var note=makeElement('div','lc-partial-note',message('partial-tail'));
@@ -4507,7 +5725,7 @@ function wireLifecycleTimeline(){
     parent.appendChild(box);
   }
 
-  function appendSession(parent,attempt){
+  function appendSession(parent,attempt,role){
     if(!attempt.sessionID){
       parent.appendChild(makeElement('div','lct-session-empty',message('no-session')));
       return;
@@ -4515,7 +5733,16 @@ function wireLifecycleTimeline(){
     var session=makeElement('div','lct-session');
     session.setAttribute('data-lifecycle-session-id',attempt.sessionID);
     session.appendChild(makeElement('span','',message('session')));
-    session.appendChild(makeElement('code','',attempt.sessionID));
+    var name=makeElement('span','',role);name.setAttribute('data-session-name',attempt.sessionID);session.appendChild(name);
+    var time=makeElement('small','',${JSON.stringify(consoleDetailMessages.timeUnknown)});time.setAttribute('data-session-time',attempt.sessionID);session.appendChild(time);
+    var technical=makeElement('details','');technical.appendChild(makeElement('summary','',${JSON.stringify(consoleDetailMessages.technicalID)}));technical.appendChild(makeElement('code','',attempt.sessionID));session.appendChild(technical);
+    var inspect=makeElement('button','',message('inspect'));
+    inspect.type='button';
+    inspect.setAttribute('aria-expanded','false');
+    inspect.setAttribute('aria-controls','lc-attempt-conversation');
+    inspect.setAttribute('data-inspect-attempt',attempt.attemptID);
+    inspect.setAttribute('data-inspect-operation',attempt.operationID);
+    session.appendChild(inspect);
     if(attempt.parentSessionID){
       var parentSession=makeElement('span','lct-parent-session',message('parent-session')+' ');
       parentSession.appendChild(makeElement('code','',attempt.parentSessionID));
@@ -4524,7 +5751,7 @@ function wireLifecycleTimeline(){
     parent.appendChild(session);
   }
 
-  function buildAttempt(attempt){
+  function buildAttempt(attempt,role){
     var article=makeElement('article','lct-attempt');
     article.setAttribute('data-lifecycle-attempt-id',attempt.attemptID);
     article.setAttribute('data-lifecycle-attempt-state',attempt.state);
@@ -4557,7 +5784,7 @@ function wireLifecycleTimeline(){
       model.appendChild(makeElement('code','',identity));
       article.appendChild(model);
     }
-    appendSession(article,attempt);
+    appendSession(article,attempt,role);
     return article;
   }
 
@@ -4604,7 +5831,9 @@ function wireLifecycleTimeline(){
     var header=makeElement('header','lct-operation-head');
     var identity=makeElement('div','');
     identity.appendChild(makeElement('span','lct-operation-label',message('operation')));
-    identity.appendChild(makeElement('code','lct-operation-id',op.operationID));
+    var name=makeElement('strong','lct-operation-name',op.agentID||op.roleID);
+    identity.appendChild(name);
+    var technical=makeElement('details','');technical.appendChild(makeElement('summary','',${JSON.stringify(consoleDetailMessages.technicalID)}));technical.appendChild(makeElement('code','lct-operation-id',op.operationID));identity.appendChild(technical);
     header.appendChild(identity);
     header.appendChild(stateBadge(op.state));
     card.appendChild(header);
@@ -4624,7 +5853,7 @@ function wireLifecycleTimeline(){
     if(attemptList.length===0){
       attempts.appendChild(makeElement('div','lct-no-attempts',message('no-attempts')));
     }else{
-      attemptList.forEach(function(attempt){attempts.appendChild(buildAttempt(attempt))});
+      attemptList.forEach(function(attempt){attempts.appendChild(buildAttempt(attempt,op.agentID||op.roleID))});
     }
     card.appendChild(attempts);
     article.appendChild(card);
@@ -4652,6 +5881,21 @@ function wireLifecycleTimeline(){
       if(visited.has(op.operationID)){return null}
       visited.add(op.operationID);
       var article=buildOperation(op,known,depth);
+      if(op.operationID===proj.rootOperationID&&op.kind==='coordinator'){
+        var option=runSelect&&Array.from(runSelect.options).find(function(o){return o.value===proj.runID});
+        var rootID=option&&option.getAttribute('data-run-session')||'';
+        var card=article.querySelector('.lct-operation-card'),name=card.querySelector('.lct-operation-name');
+        name.setAttribute('data-run-name',proj.runID);
+        if(rootID){name.setAttribute('data-session-name',rootID)}
+        var rootSession=makeElement('div','lct-session');rootSession.setAttribute('data-root-session-id',rootID);
+        if(rootID){
+          var rootName=makeElement('span','',${JSON.stringify(consoleDetailMessages.orchestrator)});rootName.setAttribute('data-session-name',rootID);rootSession.appendChild(rootName);
+          var time=makeElement('small','',${JSON.stringify(consoleDetailMessages.timeUnknown)});time.setAttribute('data-session-time',rootID);rootSession.appendChild(time);
+          var id=makeElement('code','',rootID);rootSession.appendChild(id);
+        }else{rootSession.appendChild(makeElement('span','',${JSON.stringify(consoleDetailMessages.rootUnlinked)}))}
+        var inspect=makeElement('button','',message('inspect'));inspect.type='button';inspect.setAttribute('data-inspect-root','');inspect.setAttribute('data-inspect-operation',op.operationID);inspect.setAttribute('aria-expanded','false');inspect.setAttribute('aria-controls','lc-attempt-conversation');rootSession.appendChild(inspect);
+        card.insertBefore(rootSession,card.querySelector('.lct-attempts'));
+      }
       var children=childrenByParent.get(op.operationID)||[];
       var childNodes=[];
       children.forEach(function(child){
@@ -4761,6 +6005,7 @@ function wireLifecycleTimeline(){
   }
 
   function showError(){
+    invalidateConversation();
     projectionKey='';
     mount.setAttribute('data-lifecycle-state','error');
     updateScreenCopy('unavailable',false,null);
@@ -4873,6 +6118,11 @@ function wireLifecycleTimeline(){
   var lcRefreshMs=parseInt(document.documentElement.getAttribute('data-refresh')||'2000',10);
   if(isNaN(lcRefreshMs)||lcRefreshMs<500){lcRefreshMs=2000;}
   var pollTimer=setInterval(fetchHistory,lcRefreshMs);
+  document.addEventListener('console-refresh-changed',function(e){
+    lcRefreshMs=e.detail;
+    clearInterval(pollTimer);
+    if(!state.stopped){pollTimer=setInterval(fetchHistory,lcRefreshMs)}
+  });
   window.addEventListener('pagehide',function(){
     state.stopped=true;
     state.generation++;
@@ -4920,8 +6170,7 @@ function agentModel(agent) {
   return agent.model === undefined ? "inherits default" : `${agent.model.providerID}/${agent.model.modelID}`;
 }
 function domIdPart(value) {
-  const cleaned = value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
-  return cleaned.length === 0 ? "session" : cleaned;
+  return Array.from({ length: value.length }, (_, index) => value.charCodeAt(index).toString(16).padStart(4, "0")).join("");
 }
 function panelId(base, idSuffix) {
   return idSuffix === undefined ? base : `${base}-${idSuffix}`;
@@ -5065,11 +6314,20 @@ function totalsPanel(totals) {
     "</section>"
   ].join("");
 }
+function sessionName(session) {
+  return boundedTitle(session.endpoint?.title) ?? boundedTitle(session.agents.join(", ")) ?? consoleDetailMessages.session;
+}
+function sessionNameHtml(id, fallback) {
+  return `<span data-session-name="${escapeHtml(id)}">${escapeHtml(fallback)}</span>`;
+}
+function observedTimeHtml(session) {
+  return `<small data-session-time="${escapeHtml(session.sessionID)}">${escapeHtml(consoleDetailMessages.firstObserved)}: ${escapeHtml(utcTime(session.firstTs))}</small>`;
+}
 function sessionRow(session) {
   const models = session.models.map(escapeHtml).join("<br>") || "—";
   return [
     "<tr>",
-    `<td class="hash">${escapeHtml(session.sessionID)}</td>`,
+    `<td>${sessionNameHtml(session.sessionID, sessionName(session))}<br>${observedTimeHtml(session)}<br><code>${escapeHtml(session.sessionID)}</code></td>`,
     `<td>${models}</td>`,
     `<td><span class="local">${session.localCount}</span>/<span class="frontier">${session.frontierCount}</span></td>`,
     `<td>${usd(session.realCostUSD)}</td>`,
@@ -5181,7 +6439,7 @@ function sidebarNav(liveCount, logCount) {
     "</nav>",
     '<div class="sidebar-foot">',
     '<div class="host-row"><span class="dot live"></span><span>loopback console</span></div>',
-    '<div class="host-row faint"><span>prompts stay redacted by hash</span></div>',
+    `<div class="host-row faint"><span>${escapeHtml(consoleDetailMessages.metadataOnly)}</span></div>`,
     "</div>",
     "</aside>"
   ].join("");
@@ -5199,11 +6457,13 @@ function screenSection(screen, label, heading, description, body, active = false
 function sessionHeaderPanel(tab) {
   const endpoint = tab.endpoint === undefined ? '<span class="muted">endpoint not announced</span>' : `<code>${escapeHtml(tab.endpoint.url)}</code>`;
   const dir = tab.endpoint?.directory === undefined ? "" : `<div class="stat"><span class="k">Directory</span><span class="v mono">${escapeHtml(tab.endpoint.directory)}</span></div>`;
-  const title = tab.endpoint?.title === undefined ? "" : `<div class="stat"><span class="k">Title</span><span class="v">${escapeHtml(tab.endpoint.title)}</span></div>`;
+  const title = tab.endpoint?.title === undefined ? "" : `<div class="stat"><span class="k">Title</span><span class="v">${escapeHtml(boundedTitle(tab.endpoint.title) ?? consoleDetailMessages.session)}</span></div>`;
   const s = tab.summary;
   return [
     '<section class="panel">',
-    `<h2>Session ${escapeHtml(shortSessionID(tab.sessionID))} ${statusBadge(tab.status)}</h2>`,
+    `<h2>${sessionNameHtml(tab.sessionID, sessionName(s))} ${statusBadge(tab.status)}</h2>`,
+    observedTimeHtml(s),
+    `<div>${escapeHtml(consoleDetailMessages.technicalID)}: <code>${escapeHtml(tab.sessionID)}</code></div>`,
     '<div class="grid">',
     `<div class="stat"><span class="k">Endpoint</span><span class="v">${endpoint}</span></div>`,
     dir,
@@ -5241,8 +6501,8 @@ function ptyPanel(tab) {
     "</section>"
   ].join("");
 }
-function sessionDetailCard(tab, terminalEnabled, ptyEnabled, visible, index) {
-  const idSuffix = `${index}-${domIdPart(tab.sessionID)}`;
+function sessionDetailCard(tab, terminalEnabled, ptyEnabled, visible) {
+  const idSuffix = domIdPart(tab.sessionID);
   const body = [
     sessionHeaderPanel(tab),
     terminalEnabled ? terminalPanel(tab) : "",
@@ -5484,6 +6744,7 @@ function lcDataAttrs() {
     ["data-msg-selection", lifecycleMessages.selectionLabel],
     ["data-msg-runtime", lifecycleMessages.runtimeLabel],
     ["data-msg-session", lifecycleMessages.sessionLabel],
+    ["data-msg-inspect", consoleDetailMessages.inspectConversation],
     ["data-msg-no-session", lifecycleMessages.noSession],
     ["data-msg-parent-session", lifecycleMessages.parentSessionLabel],
     ["data-msg-depends-on", lifecycleMessages.dependsOnLabel],
@@ -5509,9 +6770,9 @@ function lcRunOptions(runs, selectedID) {
   if (runs.length === 0)
     return "";
   return runs.map((r) => {
-    const label = r.runID.slice(0, 16) + (r.source === "legacy-graph" ? " (legacy)" : "");
+    const label = runLabel(r);
     const sel = r.runID === selectedID ? " selected" : "";
-    return `<option value="${escapeHtml(r.runID)}"${sel}>${escapeHtml(label)}</option>`;
+    return `<option value="${escapeHtml(r.runID)}" title="${escapeHtml(r.runID)}" data-run-started="${r.startedAt ?? ""}" data-run-authority="${r.executionAuthority}" data-run-session="${escapeHtml(r.rootSessionID ?? "")}"${sel}>${escapeHtml(label)}</option>`;
   }).join("");
 }
 function lcActivityBadge(activity) {
@@ -5550,6 +6811,7 @@ function lcControls(runs, selectedID, followLive, activity, liveDisabled = false
     "</button>",
     lcActivityBadge(activity),
     `<span class="lc-incoming-badge" data-lifecycle-incoming hidden></span>`,
+    `<details><summary>${escapeHtml(consoleDetailMessages.technicalID)}</summary><code data-lifecycle-run-id>${escapeHtml(selectedID ?? "")}</code></details>`,
     "</div>"
   ].join("");
 }
@@ -5618,19 +6880,22 @@ function lcFailureHtml(failure) {
     "</div>"
   ].join("");
 }
-function lcSessionHtml(attempt) {
+function lcSessionHtml(attempt, role) {
   if (attempt.sessionID === undefined) {
     return `<div class="lct-session-empty">${escapeHtml(lifecycleMessages.noSession)}</div>`;
   }
   return [
     `<div class="lct-session" data-lifecycle-session-id="${escapeHtml(attempt.sessionID)}">`,
     `<span>${escapeHtml(lifecycleMessages.sessionLabel)}</span>`,
-    `<code>${escapeHtml(attempt.sessionID)}</code>`,
+    sessionNameHtml(attempt.sessionID, role),
+    `<small data-session-time="${escapeHtml(attempt.sessionID)}">${escapeHtml(consoleDetailMessages.timeUnknown)}</small>`,
+    `<details><summary>${escapeHtml(consoleDetailMessages.technicalID)}</summary><code>${escapeHtml(attempt.sessionID)}</code></details>`,
+    `<button type="button" aria-expanded="false" aria-controls="lc-attempt-conversation" data-inspect-operation="${escapeHtml(attempt.operationID)}" data-inspect-attempt="${escapeHtml(attempt.attemptID)}">${escapeHtml(consoleDetailMessages.inspectConversation)}</button>`,
     attempt.parentSessionID === undefined ? "" : `<span class="lct-parent-session">${escapeHtml(lifecycleMessages.parentSessionLabel)} <code>${escapeHtml(attempt.parentSessionID)}</code></span>`,
     "</div>"
   ].join("");
 }
-function lcAttemptHtml(attempt) {
+function lcAttemptHtml(attempt, role) {
   const model = attempt.model === undefined ? undefined : `${attempt.model.providerID}/${attempt.model.modelID}`;
   const route = attempt.routeKind ?? lifecycleMessages.noRoute;
   return [
@@ -5659,7 +6924,7 @@ function lcAttemptHtml(attempt) {
       `<code>${escapeHtml(model)}</code>`,
       "</div>"
     ].join(""),
-    lcSessionHtml(attempt),
+    lcSessionHtml(attempt, role),
     "</article>"
   ].join("");
 }
@@ -5687,16 +6952,17 @@ function lcParentReferenceHtml(operation, operationIDs) {
     "</div>"
   ].join("");
 }
-function lcOperationHtml(operation, operationIDs, childrenHtml, depth) {
+function lcOperationHtml(operation, operationIDs, childrenHtml, depth, rootSessionID, isRoot = false) {
   const parentAttr = operation.parentOperationID === undefined ? "" : ` data-lifecycle-parent-operation-id="${escapeHtml(operation.parentOperationID)}"`;
-  const attempts = operation.attempts.length === 0 ? `<div class="lct-no-attempts">${escapeHtml(lifecycleMessages.noAttempts)}</div>` : operation.attempts.map(lcAttemptHtml).join("");
+  const attempts = operation.attempts.length === 0 ? `<div class="lct-no-attempts">${escapeHtml(lifecycleMessages.noAttempts)}</div>` : operation.attempts.map((attempt) => lcAttemptHtml(attempt, operation.agentID ?? operation.roleID)).join("");
   return [
     `<article class="lct-operation" role="treeitem" aria-level="${depth}" data-lifecycle-operation-id="${escapeHtml(operation.operationID)}"${parentAttr} data-lifecycle-operation-state="${escapeHtml(operation.state)}" data-op-id="${escapeHtml(operation.operationID)}" data-op-state="${escapeHtml(operation.state)}">`,
     '<div class="lct-operation-card">',
     '<header class="lct-operation-head">',
     "<div>",
     `<span class="lct-operation-label">${escapeHtml(lifecycleMessages.operationLabel)}</span>`,
-    `<code class="lct-operation-id">${escapeHtml(operation.operationID)}</code>`,
+    `<strong class="lct-operation-name">${rootSessionID ? sessionNameHtml(rootSessionID, operation.agentID ?? operation.roleID) : escapeHtml(operation.agentID ?? operation.roleID)}</strong>`,
+    `<details><summary>${escapeHtml(consoleDetailMessages.technicalID)}</summary><code class="lct-operation-id">${escapeHtml(operation.operationID)}</code></details>`,
     "</div>",
     `<span class="lct-state" data-state="${escapeHtml(operation.state)}"><span class="sr-only">${escapeHtml(lifecycleMessages.stateLabel)}: </span>${escapeHtml(operation.state)}</span>`,
     "</header>",
@@ -5708,13 +6974,19 @@ function lcOperationHtml(operation, operationIDs, childrenHtml, depth) {
     "</dl>",
     lcParentReferenceHtml(operation, operationIDs),
     lcDependenciesHtml(operation, operationIDs),
+    isRoot && operation.kind === "coordinator" ? [
+      `<div class="lct-session" data-root-session-id="${escapeHtml(rootSessionID ?? "")}">`,
+      rootSessionID ? `${sessionNameHtml(rootSessionID, consoleDetailMessages.orchestrator)} <small data-session-time="${escapeHtml(rootSessionID)}">${escapeHtml(consoleDetailMessages.timeUnknown)}</small><details><summary>${escapeHtml(consoleDetailMessages.technicalID)}</summary><code>${escapeHtml(rootSessionID)}</code></details>` : `<span>${escapeHtml(consoleDetailMessages.rootUnlinked)}</span>`,
+      `<button type="button" data-inspect-root data-inspect-operation="${escapeHtml(operation.operationID)}" aria-expanded="false" aria-controls="lc-attempt-conversation">${escapeHtml(consoleDetailMessages.inspectConversation)}</button>`,
+      "</div>"
+    ].join("") : "",
     `<section class="lct-attempts" aria-label="${escapeHtml(lifecycleMessages.attemptsLabel)}">${attempts}</section>`,
     "</div>",
     childrenHtml === "" ? "" : `<div class="lct-operation-children" role="group">${childrenHtml}</div>`,
     "</article>"
   ].join("");
 }
-function renderLifecycleOperationTree(projection) {
+function renderLifecycleOperationTree(projection, rootSessionID) {
   if (projection.operations.length === 0) {
     return `<div class="lc-empty" role="status">${escapeHtml(lifecycleMessages.noOperationsAtCursor)}</div>`;
   }
@@ -5738,7 +7010,8 @@ function renderLifecycleOperationTree(projection) {
       return "";
     visited.add(operation.operationID);
     const childHtml = (childrenByParent.get(operation.operationID) ?? []).map((child) => renderBranch(child, depth + 1)).join("");
-    return lcOperationHtml(operation, operationIDs, childHtml, depth);
+    const isRoot = operation.operationID === projection.rootOperationID;
+    return lcOperationHtml(operation, operationIDs, childHtml, depth, isRoot ? rootSessionID : undefined, isRoot);
   };
   const root = byID.get(projection.rootOperationID);
   const rootHtml = root === undefined ? "" : renderBranch(root, 1);
@@ -5854,7 +7127,7 @@ function renderLifecycleTimelinePanel(lifecycleView) {
   const followLive = selection.followLive;
   const cursor = selection.cursor;
   const head = selection.head;
-  const projectionHtml = renderLifecycleOperationTree(projection);
+  const projectionHtml = renderLifecycleOperationTree(projection, runs.find((run) => run.runID === selection.runID)?.rootSessionID);
   const stateAttr = followLive ? "live" : "paused";
   return [
     `<div id="lifecycle-timeline-mount" class="lc-host" role="region" aria-label="${escapeHtml(lifecycleMessages.timelineRegionLabel)}" ${mountAttrs} data-lifecycle-state="${stateAttr}" data-lifecycle-run="${escapeHtml(selection.runID)}" data-lifecycle-head="${head}">`,
@@ -6026,7 +7299,7 @@ function sessionList(sessions) {
     return [
       `<button type="button" class="session-btn${selected ? " sel" : ""}" role="tab" aria-selected="${selected ? "true" : "false"}" data-session-target="${escapeHtml(tab.sessionID)}">`,
       `<span class="dot status-${tab.status}"></span>`,
-      `<span class="sid">${escapeHtml(shortSessionID(tab.sessionID))}</span>`,
+      `<span class="sid">${sessionNameHtml(tab.sessionID, sessionName(tab.summary))}<br>${observedTimeHtml(tab.summary)}<br><small class="mono">${escapeHtml(tab.sessionID)}</small></span>`,
       `<span class="n">${tab.summary.messageCount}</span>`,
       "</button>"
     ].join("");
@@ -6044,7 +7317,7 @@ function sessionDetailList(sessions, terminalEnabled, ptyEnabled) {
   if (sessions.length === 0) {
     return '<div class="card empty-state">No session activity recorded yet.</div>';
   }
-  return sessions.map((tab, index) => sessionDetailCard(tab, terminalEnabled, ptyEnabled, index === 0, index)).join("");
+  return sessions.map((tab, index) => sessionDetailCard(tab, terminalEnabled, ptyEnabled, index === 0)).join("");
 }
 function logsScreenBody(state, terminalEnabled, ptyEnabled) {
   return [
@@ -6083,11 +7356,11 @@ function renderConsoleHtml(state, options = {}) {
   const body = [
     screenSection("tree", treeCopy.label, treeCopy.heading, treeCopy.description, treeBody, true),
     screenSection("routing", "Routing and telemetry", "Routing + telemetry", "Aggregate routing and cost telemetry from <code>GET /api/state</code> across all sessions.", routingScreenBody(state)),
-    screenSection("logs", "Logs and session activity", "Logs / activity", "Per-session activity. Prompts are referenced by hash only and never rendered in clear text.", logsScreenBody(state, terminalEnabled, ptyEnabled)),
+    screenSection("logs", "Logs and session activity", "Logs / activity", "Per-session activity. Prompts are referenced by hash only and never rendered in clear text.", `<div data-log-controls><label>${escapeHtml(consoleDetailMessages.filter)} <input type="search" data-log-filter></label> <label><input type="checkbox" data-log-follow> ${escapeHtml(consoleDetailMessages.follow)}</label> <button type="button" data-log-incoming hidden>${escapeHtml(consoleDetailMessages.incoming)}</button></div><div data-log-content>${logsScreenBody(state, terminalEnabled, ptyEnabled)}</div>`),
     screenSection("config", "Editable configuration", 'Configuration <span class="pill warn">editable</span>', "Edit the whole openteam JSON configuration. Roles are editable inside the JSON when present; unsupported surfaces are not shown.", configScreenBody(options.configEditor?.hasToken === true))
   ].join("");
   const session = state.session.id === undefined ? "" : ` · session ${escapeHtml(state.session.id)}`;
-  const tokenAttr = (terminalEnabled || graphDrilldown || configEnabled) && options.consoleToken !== undefined ? ` data-token="${escapeHtml(options.consoleToken)}"${terminalEnabled ? ' data-terminal="1"' : ""}${ptyEnabled ? ' data-pty="1"' : ""}${graphDrilldown ? ' data-drilldown="1"' : ""}${configEnabled ? ' data-config="1"' : ""}` : "";
+  const tokenAttr = (terminalEnabled || graphDrilldown || configEnabled || lifecycleEnabled) && options.consoleToken !== undefined ? ` data-token="${escapeHtml(options.consoleToken)}"${terminalEnabled ? ' data-terminal="1"' : ""}${ptyEnabled ? ' data-pty="1"' : ""}${graphDrilldown ? ' data-drilldown="1"' : ""}${configEnabled ? ' data-config="1"' : ""}` : "";
   return [
     "<!doctype html>",
     `<html lang="en" data-generated="${escapeHtml(state.generatedAt)}" data-refresh="${refreshMs}"${tokenAttr}>`,
@@ -6096,7 +7369,7 @@ function renderConsoleHtml(state, options = {}) {
     '<meta name="viewport" content="width=device-width,initial-scale=1">',
     "<title>openteam console</title>",
     lifecycleEnabled ? `<script>${LIFECYCLE_THEME_BOOT}</script>` : "",
-    `<style>${CONSOLE_STYLE}${graphOptionProvided ? GRAPH_STYLE : ""}${lifecycleEnabled ? LIFECYCLE_STYLE : ""}</style>`,
+    `<style>${CONSOLE_STYLE}${graphOptionProvided ? GRAPH_STYLE : ""}${lifecycleEnabled ? LIFECYCLE_STYLE + CONVERSATION_STYLE : ""}</style>`,
     "</head>",
     "<body>",
     '<div class="app">',
@@ -6107,6 +7380,7 @@ function renderConsoleHtml(state, options = {}) {
     '<button type="button" class="icon-btn menu-btn" data-toggle-nav aria-label="Open navigation"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M4 6h16M4 12h16M4 18h16"></path></svg></button>',
     '<h1 id="screen-title">Agent tree</h1>',
     `<span class="refresh" title="SSE + polling"><span class="beat"></span> ${refreshMs} ms · SSE</span>`,
+    `<span data-refresh-error role="status" hidden>${escapeHtml(consoleDetailMessages.refreshError)}</span>`,
     '<div class="spacer"></div>',
     `<span class="token-chip" title="Page status"><span class="lbl">updated</span> <b class="mono">${escapeHtml(state.generatedAt)}${session}</b></span>`,
     "</header>",
@@ -6120,6 +7394,16 @@ function renderConsoleHtml(state, options = {}) {
     "</html>"
   ].join("");
 }
+function renderConsoleUpdate(state, options = {}) {
+  return {
+    routing: routingScreenBody(state),
+    logs: logsScreenBody(state, options.terminalEnabled === true, options.ptyEnabled === true),
+    sessionCount: state.sessionsDetail.length,
+    ...options.graphView ? {
+      tree: treeGraphPanel(options.graphView.projection, options.drilldownEnabled === true, false, options.graphView.mode ?? "active")
+    } : {}
+  };
+}
 
 // src/console/configView.ts
 var OVERLAY_PATH = ".opencode/openteam-local/config.local.json";
@@ -6268,7 +7552,7 @@ function isCrossOriginMutation(request) {
   }
 }
 async function readJsonBody(request, limit) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let raw = "";
     let aborted = false;
     request.on("data", (chunk) => {
@@ -6278,7 +7562,7 @@ async function readJsonBody(request, limit) {
       raw += chunk.toString("utf8");
       if (raw.length > limit) {
         aborted = true;
-        resolve({ ok: false });
+        resolve2({ ok: false });
       }
     });
     request.on("end", () => {
@@ -6286,12 +7570,12 @@ async function readJsonBody(request, limit) {
         return;
       }
       try {
-        resolve({ ok: true, value: JSON.parse(raw) });
+        resolve2({ ok: true, value: JSON.parse(raw) });
       } catch {
-        resolve({ ok: false });
+        resolve2({ ok: false });
       }
     });
-    request.on("error", () => resolve({ ok: false }));
+    request.on("error", () => resolve2({ ok: false }));
   });
 }
 async function handleConfigRoute(request, response, url, deps) {
@@ -6361,6 +7645,7 @@ var DEFAULT_BACKLOG_PATH = ".opencode/openteam/backlog.md";
 var DEFAULT_DECISIONS_PATH = ".opencode/openteam/decisions.md";
 
 // src/web/server.ts
+import { createHash as createHash2 } from "node:crypto";
 import {
   createServer as createHttpServer
 } from "node:http";
@@ -6671,7 +7956,7 @@ function authorized2(request, query, token) {
   return provided !== undefined && safeEqualToken(provided, token);
 }
 async function readJsonBody2(request, limit) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let raw = "";
     let aborted = false;
     request.on("data", (chunk) => {
@@ -6681,7 +7966,7 @@ async function readJsonBody2(request, limit) {
       raw += chunk.toString("utf8");
       if (raw.length > limit) {
         aborted = true;
-        resolve(undefined);
+        resolve2(undefined);
       }
     });
     request.on("end", () => {
@@ -6689,12 +7974,12 @@ async function readJsonBody2(request, limit) {
         return;
       }
       try {
-        resolve(JSON.parse(raw));
+        resolve2(JSON.parse(raw));
       } catch {
-        resolve(undefined);
+        resolve2(undefined);
       }
     });
-    request.on("error", () => resolve(undefined));
+    request.on("error", () => resolve2(undefined));
   });
 }
 function parseConsolePath(path) {
@@ -6734,8 +8019,12 @@ async function handleMessages(_request, response, sessionID, deps, diagnostic) {
     response.writeHead(404, JSON_HEADERS3).end(JSON.stringify({ error: "no endpoint" }));
     return;
   }
-  const frames = await deps.createClient(endpoint).listMessages(sessionID, { diagnostic });
-  response.writeHead(200, JSON_HEADERS3).end(JSON.stringify({ frames }));
+  try {
+    const frames = await deps.createClient(endpoint).listMessages(sessionID, { diagnostic });
+    response.writeHead(200, { ...JSON_HEADERS3, "cache-control": "no-store" }).end(JSON.stringify({ frames }));
+  } catch {
+    response.writeHead(503, JSON_HEADERS3).end(JSON.stringify({ error: consoleDetailMessages.readFailed }));
+  }
 }
 async function handleInput(request, response, sessionID, deps) {
   const endpoint = await deps.resolveEndpoint(sessionID);
@@ -6839,6 +8128,201 @@ async function handleConsoleRoute(request, response, url, deps) {
   return true;
 }
 
+// src/web/conversationRoute.ts
+async function untilAborted(read, signal) {
+  let cancel = () => {};
+  const aborted = new Promise((_resolve, reject) => {
+    cancel = () => reject(signal.reason);
+    if (signal.aborted)
+      cancel();
+    else
+      signal.addEventListener("abort", cancel, { once: true });
+  });
+  try {
+    return await Promise.race([read, aborted]);
+  } finally {
+    signal.removeEventListener("abort", cancel);
+  }
+}
+async function handleConversationRoute(request, response, url, deps) {
+  const labelsOnly = url.pathname === "/api/graph/session-labels";
+  if (url.pathname !== "/api/graph/conversation" && !labelsOnly)
+    return false;
+  const send = (status, kind, message, extra = {}) => {
+    response.writeHead(status, {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "referrer-policy": "no-referrer"
+    }).end(JSON.stringify({ version: 1, kind, message, ...extra }));
+  };
+  const authorization = request.headers.authorization;
+  const bearer = authorization?.startsWith("Bearer ") ? authorization.slice(7) : undefined;
+  const token = url.searchParams.get("token") ?? bearer;
+  if (!token || !safeEqualToken(token, deps.token)) {
+    send(401, "unauthorized", consoleDetailMessages.unauthorized);
+    return true;
+  }
+  if (request.method !== "GET") {
+    send(405, "unavailable", consoleDetailMessages.unauthorized);
+    return true;
+  }
+  if (!deps.enabled || !deps.contentEnabled || url.searchParams.get("diagnostic") !== "1") {
+    send(403, "disabled", consoleDetailMessages.disabled);
+    return true;
+  }
+  const params = url.searchParams;
+  const rootTarget = params.get("target") === "root";
+  if ((labelsOnly ? params.has("run") ? ["run"] : [] : rootTarget ? ["run", "operation"] : ["run", "operation", "attempt"]).some((key) => params.getAll(key).length !== 1 || !params.get(key)) || params.has("session") || params.getAll("target").length > 1 || params.has("target") && !rootTarget && params.get("target") !== "attempt" || rootTarget && params.has("attempt") || labelsOnly && (params.has("operation") || params.has("attempt") || params.has("target"))) {
+    send(400, "invalid", consoleDetailMessages.invalid);
+    return true;
+  }
+  if (labelsOnly) {
+    const selected = params.has("run") ? await readLifecycleHistoryQuery(deps.reader, params) : undefined;
+    if (selected && (selected.kind !== "view" || selected.selection.runID !== params.get("run"))) {
+      send(409, "invalid", consoleDetailMessages.invalid);
+      return true;
+    }
+    if (params.has("cursor")) {
+      send(409, "historical", consoleDetailMessages.historical);
+      return true;
+    }
+    const controller2 = new AbortController;
+    const cancel2 = () => controller2.abort();
+    response.on("close", cancel2);
+    request.on("aborted", cancel2);
+    request.socket.on("close", cancel2);
+    if (request.aborted || request.socket.destroyed)
+      cancel2();
+    const deadline = Date.now() + SESSION_HISTORY_LIMITS.timeoutMs;
+    const timeout = setTimeout(cancel2, SESSION_HISTORY_LIMITS.timeoutMs);
+    try {
+      const history2 = selected?.kind === "view" ? selected : undefined;
+      const selectedRoot = history2?.runs.find((run) => run.runID === history2.selection.runID)?.rootSessionID;
+      const eligibleIDs = [
+        ...new Set([
+          ...selectedRoot ? [selectedRoot] : [],
+          ...history2?.projection.operations.flatMap((op) => op.attempts.flatMap((attempt2) => attempt2.sessionID ? [attempt2.sessionID] : [])) ?? [],
+          ...history2?.runs.flatMap((run) => run.rootSessionID ? [run.rootSessionID] : []) ?? [],
+          ...deps.observedSessionIDs ? await untilAborted(deps.observedSessionIDs(), controller2.signal) : []
+        ])
+      ];
+      const ids = eligibleIDs.slice(0, SESSION_HISTORY_LIMITS.labels);
+      const groups = new Map;
+      for (const id of ids) {
+        if (controller2.signal.aborted)
+          break;
+        try {
+          const endpoint = await untilAborted(deps.resolveEndpoint(id), controller2.signal);
+          if (!endpoint)
+            continue;
+          const group = groups.get(endpoint) ?? [];
+          group.push(id);
+          groups.set(endpoint, group);
+        } catch {}
+      }
+      const sessions = [];
+      const budget = { remaining: SESSION_HISTORY_LIMITS.bytes };
+      let groupsLeft = groups.size;
+      for (const [endpoint, group] of groups) {
+        if (controller2.signal.aborted || !deps.readConversation.labels)
+          break;
+        try {
+          sessions.push(...await untilAborted(deps.readConversation.labels(endpoint, group, controller2.signal, {
+            budget,
+            timeoutMs: Math.max(1, Math.floor((deadline - Date.now()) / groupsLeft))
+          }), controller2.signal));
+        } catch {}
+        groupsLeft--;
+      }
+      const found = new Set(sessions.map((session) => session.id));
+      const unavailableSessionIDs = ids.filter((id) => !found.has(id));
+      const truncated = eligibleIDs.length > ids.length;
+      const partial = truncated || unavailableSessionIDs.length > 0;
+      if (response.destroyed || request.socket.destroyed)
+        return true;
+      if (ids.length && !sessions.length) {
+        send(503, "unavailable", consoleDetailMessages.readFailed, {
+          completeness: "partial",
+          unavailableSessionIDs,
+          ...truncated ? { truncated: true } : {}
+        });
+        return true;
+      }
+      send(200, "labels", partial ? `${consoleDetailMessages.currentMetadata}
+${consoleDetailMessages.partialMetadata}` : consoleDetailMessages.currentMetadata, {
+        runID: history2?.selection.runID ?? null,
+        sessions,
+        completeness: partial ? "partial" : "complete",
+        unavailableSessionIDs,
+        ...truncated ? { truncated: true } : {}
+      });
+    } catch {
+      if (!response.destroyed && !request.socket.destroyed)
+        send(503, "unavailable", consoleDetailMessages.unavailable);
+    } finally {
+      clearTimeout(timeout);
+      response.off("close", cancel2);
+      request.off("aborted", cancel2);
+      request.socket.off("close", cancel2);
+    }
+    return true;
+  }
+  const history = await readLifecycleHistoryQuery(deps.reader, params);
+  if (history.kind !== "view" || history.selection.runID !== params.get("run")) {
+    send(409, "invalid", consoleDetailMessages.invalid);
+    return true;
+  }
+  const operation = history.projection.operations.find((item) => item.operationID === params.get("operation"));
+  const attempt = operation?.attempts.find((item) => item.attemptID === params.get("attempt"));
+  if (!labelsOnly && (rootTarget ? !operation || operation.operationID !== history.projection.rootOperationID || operation.kind !== "coordinator" : !attempt?.sessionID)) {
+    send(404, "invalid", consoleDetailMessages.invalid);
+    return true;
+  }
+  if (params.has("cursor") || !history.selection.followLive) {
+    send(409, "historical", consoleDetailMessages.historical);
+    return true;
+  }
+  const controller = new AbortController;
+  const cancel = () => controller.abort();
+  response.on("close", cancel);
+  try {
+    const run = history.runs.find((item) => item.runID === history.selection.runID);
+    const recordedRoot = run?.rootSessionID;
+    const sessionID = rootTarget ? recordedRoot : attempt?.sessionID;
+    const endpointID = sessionID ?? history.projection.operations.flatMap((op) => op.attempts).filter((item) => item.sessionID).at(-1)?.sessionID ?? "";
+    const endpoint = await deps.resolveEndpoint(endpointID);
+    if (!endpoint) {
+      send(503, "unavailable", consoleDetailMessages.unavailable);
+      return true;
+    }
+    const recovered = !sessionID && rootTarget && deps.readConversation.root ? await deps.readConversation.root(endpoint, history.projection, controller.signal) : undefined;
+    const resolvedID = sessionID ?? recovered?.session.id;
+    if (!resolvedID)
+      throw new AssociationError("unavailable");
+    const conversation = recovered ?? await deps.readConversation(endpoint, resolvedID, controller.signal);
+    const current = rootTarget ? `${consoleDetailMessages.rootCurrent}
+${consoleDetailMessages.current}${recovered ? `
+${consoleDetailMessages.recovered}` : ""}` : consoleDetailMessages.current;
+    send(200, conversation.messages.length || conversation.truncated ? "conversation" : "empty", conversation.truncated ? `${current}
+${consoleDetailMessages.truncated}` : conversation.messages.length ? current : `${current}
+${consoleDetailMessages.empty}`, {
+      scope: "present-day-session",
+      runID: history.selection.runID,
+      operationID: operation?.operationID,
+      target: rootTarget ? "root" : "attempt",
+      ...rootTarget ? {} : { attemptID: attempt?.attemptID },
+      sessionID: resolvedID,
+      ...conversation
+    });
+  } catch (error) {
+    if (!controller.signal.aborted)
+      send(error instanceof ConversationTooLargeError ? 413 : 503, error instanceof ConversationTooLargeError ? "oversized" : "unavailable", error instanceof AssociationError ? error.message : error instanceof ConversationTooLargeError ? consoleDetailMessages.oversized : consoleDetailMessages.unavailable);
+  } finally {
+    response.off("close", cancel);
+  }
+  return true;
+}
+
 // src/web/storageRoute.ts
 var JSON_HEADERS4 = { "content-type": "application/json" };
 var READ_OPS = new Set(["read", "exists", "list", "isDirectory", "stat"]);
@@ -6868,7 +8352,7 @@ function pathAllowed(path, allowPrefixes) {
   });
 }
 async function readJsonBody3(request, limit) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let raw = "";
     let aborted = false;
     request.on("data", (chunk) => {
@@ -6878,19 +8362,19 @@ async function readJsonBody3(request, limit) {
       raw += chunk.toString("utf8");
       if (raw.length > limit) {
         aborted = true;
-        resolve(undefined);
+        resolve2(undefined);
       }
     });
     request.on("end", () => {
       if (!aborted) {
         try {
-          resolve(JSON.parse(raw));
+          resolve2(JSON.parse(raw));
         } catch {
-          resolve(undefined);
+          resolve2(undefined);
         }
       }
     });
-    request.on("error", () => resolve(undefined));
+    request.on("error", () => resolve2(undefined));
   });
 }
 function sendJson(response, status, body) {
@@ -7068,18 +8552,18 @@ data: ${json}
 `;
 }
 function tryListen(server, host, port) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const onError = (error) => {
       server.removeListener("listening", onListening);
       if (isAddressInUse(error)) {
-        resolve(false);
+        resolve2(false);
       } else {
         reject(error);
       }
     };
     const onListening = () => {
       server.removeListener("error", onError);
-      resolve(true);
+      resolve2(true);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -7114,6 +8598,20 @@ async function createConsoleServer(deps) {
   };
   const handle = async (request, response) => {
     const url2 = new URL(request.url ?? "/", "http://localhost");
+    if (["/api/graph/conversation", "/api/graph/session-labels"].includes(url2.pathname) && deps.storageApi && !readAuthorized2(request, url2, deps.storageApi.token)) {
+      response.writeHead(401, { ...JSON_HEADERS5, "cache-control": "no-store" }).end(JSON.stringify({ version: 1, kind: "unauthorized" }));
+      return;
+    }
+    if (deps.console?.readConversation && deps.lifecycleHistoryApi && await handleConversationRoute(request, response, url2, {
+      token: deps.console.token,
+      enabled: deps.config.graphView?.enabled === true,
+      contentEnabled: deps.console.conversationContentEnabled === true,
+      reader: deps.lifecycleHistoryApi.reader,
+      resolveEndpoint: async (id) => deps.console?.historyEndpoint ?? await resolveEndpoint(id),
+      observedSessionIDs: async () => buildConsoleState(await deps.readSnapshot()).sessions.map((session) => session.sessionID),
+      readConversation: deps.console.readConversation
+    }))
+      return;
     if (consoleDeps !== undefined && await handleConsoleRoute(request, response, url2, consoleDeps)) {
       return;
     }
@@ -7143,7 +8641,7 @@ async function createConsoleServer(deps) {
     }
     const path = url2.pathname;
     const remoteToken = deps.storageApi?.token;
-    if (remoteToken !== undefined && (path === "/" || path === "/index.html" || path === "/api/state" || path === "/events") && !readAuthorized2(request, url2, remoteToken)) {
+    if (remoteToken !== undefined && (path === "/" || path === "/index.html" || path === "/api/state" || path === "/api/view" || path === "/events") && !readAuthorized2(request, url2, remoteToken)) {
       response.writeHead(401, JSON_HEADERS5).end(JSON.stringify({ error: "unauthorized" }));
       return;
     }
@@ -7155,6 +8653,34 @@ async function createConsoleServer(deps) {
       response.writeHead(200, JSON_HEADERS5).end(await stateJson(deps));
       return;
     }
+    if (path === "/api/view") {
+      const state = buildConsoleState(await deps.readSnapshot());
+      const view = {
+        ...renderConsoleUpdate(state, {
+          ...deps.console,
+          ...deps.graphApi && !deps.lifecycleHistoryApi ? {
+            graphView: {
+              projection: await deps.graphApi.readView(),
+              mode: deps.graphMode ?? "active"
+            }
+          } : {}
+        }),
+        refreshMs: (deps.getConsoleConfig?.() ?? deps.config).refreshMs
+      };
+      const json = JSON.stringify(view);
+      const revision = `"${createHash2("sha256").update(json).digest("hex")}"`;
+      const headers = {
+        ...JSON_HEADERS5,
+        etag: revision,
+        "cache-control": "no-store"
+      };
+      if (request.headers["if-none-match"] === revision) {
+        response.writeHead(304, headers).end();
+      } else {
+        response.writeHead(200, headers).end(JSON.stringify({ ...view, updatedAt: state.generatedAt }));
+      }
+      return;
+    }
     if (path === "/healthz") {
       response.writeHead(200, JSON_HEADERS5).end(JSON.stringify({ ok: true }));
       return;
@@ -7719,19 +9245,19 @@ import { readdirSync, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 
 // src/storage/lifecycle/codec.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/lifecycle/schema.ts
-import { z as z10 } from "zod";
-var nonEmptyString = z10.string().min(1);
-var nonNegativeInteger = z10.number().int().nonnegative();
-var positiveInteger = z10.number().int().positive();
-var modelSelectionSchema2 = z10.object({
+import { z as z12 } from "zod";
+var nonEmptyString = z12.string().min(1);
+var nonNegativeInteger = z12.number().int().nonnegative();
+var positiveInteger = z12.number().int().positive();
+var modelSelectionSchema2 = z12.object({
   providerID: nonEmptyString,
   modelID: nonEmptyString
 }).strict();
-var lifecycleFailureSchema = z10.object({
-  class: z10.enum([
+var lifecycleFailureSchema = z12.object({
+  class: z12.enum([
     "routing-blocked",
     "create-rejected",
     "create-no-id",
@@ -7753,25 +9279,25 @@ var lifecycleFailureSchema = z10.object({
     "interrupted",
     "unknown"
   ]),
-  statusCode: z10.number().int().min(100).max(599).optional(),
-  retryable: z10.boolean().optional()
+  statusCode: z12.number().int().min(100).max(599).optional(),
+  retryable: z12.boolean().optional()
 }).strict();
-var lifecycleRootOperationSchema = z10.object({
+var lifecycleRootOperationSchema = z12.object({
   operationID: nonEmptyString,
   taskID: nonEmptyString,
-  kind: z10.enum(["coordinator", "graph-node"]),
+  kind: z12.enum(["coordinator", "graph-node"]),
   roleID: nonEmptyString,
   agentID: nonEmptyString.optional(),
   sessionID: nonEmptyString.optional()
 }).strict();
-var lifecycleRunStartInputSchema = z10.object({
+var lifecycleRunStartInputSchema = z12.object({
   runID: nonEmptyString,
-  source: z10.enum(["plugin", "cli"]),
-  executionAuthority: z10.enum(["coordinator", "graph"]),
+  source: z12.enum(["plugin", "cli"]),
+  executionAuthority: z12.enum(["coordinator", "graph"]),
   root: lifecycleRootOperationSchema
 }).strict();
 var LifecycleRunMetadataSchema = lifecycleRunStartInputSchema.extend({
-  version: z10.literal(1),
+  version: z12.literal(1),
   createdAt: nonNegativeInteger
 }).strict();
 var attemptRefShape = {
@@ -7783,34 +9309,34 @@ var attemptRefShape = {
   retryIndex: nonNegativeInteger
 };
 var eventEnvelopeShape = {
-  v: z10.literal(1),
+  v: z12.literal(1),
   seq: nonNegativeInteger,
   runID: nonEmptyString,
   at: nonNegativeInteger
 };
 var runStartedBodyShape = {
-  type: z10.literal("run.started"),
-  source: z10.enum(["plugin", "cli"]),
-  executionAuthority: z10.enum(["coordinator", "graph"]),
+  type: z12.literal("run.started"),
+  source: z12.enum(["plugin", "cli"]),
+  executionAuthority: z12.enum(["coordinator", "graph"]),
   root: lifecycleRootOperationSchema
 };
 var operationQueuedBodyShape = {
-  type: z10.literal("operation.queued"),
+  type: z12.literal("operation.queued"),
   operationID: nonEmptyString,
   taskID: nonEmptyString,
-  kind: z10.enum(["role", "graph-node"]),
+  kind: z12.enum(["role", "graph-node"]),
   roleID: nonEmptyString,
   agentID: nonEmptyString.optional(),
   parentOperationID: nonEmptyString,
-  dependsOnOperationIDs: z10.array(nonEmptyString).readonly()
+  dependsOnOperationIDs: z12.array(nonEmptyString).readonly()
 };
 var modelSelectedBodyShape = {
-  type: z10.literal("attempt.model-selected"),
+  type: z12.literal("attempt.model-selected"),
   ...attemptRefShape,
   decisionID: nonEmptyString,
   model: modelSelectionSchema2,
-  routeKind: z10.enum(["local", "frontier"]),
-  selectionCause: z10.enum([
+  routeKind: z12.enum(["local", "frontier"]),
+  selectionCause: z12.enum([
     "initial",
     "retry-incomplete",
     "retry-transport",
@@ -7820,31 +9346,31 @@ var modelSelectedBodyShape = {
   runtimeID: nonEmptyString.optional()
 };
 var attemptQueuedBodyShape = {
-  type: z10.literal("attempt.queued"),
+  type: z12.literal("attempt.queued"),
   ...attemptRefShape,
   runtimeID: nonEmptyString.optional()
 };
 var attemptStartedBodyShape = {
-  type: z10.literal("attempt.started"),
+  type: z12.literal("attempt.started"),
   ...attemptRefShape
 };
 var sessionCreatedBodyShape = {
-  type: z10.literal("session.created"),
+  type: z12.literal("session.created"),
   ...attemptRefShape,
   sessionID: nonEmptyString,
   parentSessionID: nonEmptyString.optional()
 };
 var attemptTerminalBodyShape = {
-  type: z10.literal("attempt.terminal"),
+  type: z12.literal("attempt.terminal"),
   ...attemptRefShape,
-  outcome: z10.enum([
+  outcome: z12.enum([
     "succeeded",
     "failed",
     "cancelled",
     "interrupted",
     "unknown"
   ]),
-  continuation: z10.enum([
+  continuation: z12.enum([
     "none",
     "retry-same-model",
     "fallback-next-model",
@@ -7854,10 +9380,10 @@ var attemptTerminalBodyShape = {
   failure: lifecycleFailureSchema.optional()
 };
 var operationTerminalBodyShape = {
-  type: z10.literal("operation.terminal"),
+  type: z12.literal("operation.terminal"),
   operationID: nonEmptyString,
   taskID: nonEmptyString,
-  outcome: z10.enum([
+  outcome: z12.enum([
     "succeeded",
     "failed",
     "cancelled",
@@ -7870,8 +9396,8 @@ var operationTerminalBodyShape = {
   failure: lifecycleFailureSchema.optional()
 };
 var runTerminalBodyShape = {
-  type: z10.literal("run.terminal"),
-  outcome: z10.enum([
+  type: z12.literal("run.terminal"),
+  outcome: z12.enum([
     "succeeded",
     "failed",
     "cancelled",
@@ -7882,39 +9408,39 @@ var runTerminalBodyShape = {
   failure: lifecycleFailureSchema.optional()
 };
 var bodySchemas = [
-  z10.object(runStartedBodyShape).strict(),
-  z10.object(operationQueuedBodyShape).strict(),
-  z10.object(modelSelectedBodyShape).strict(),
-  z10.object(attemptQueuedBodyShape).strict(),
-  z10.object(attemptStartedBodyShape).strict(),
-  z10.object(sessionCreatedBodyShape).strict(),
-  z10.object(attemptTerminalBodyShape).strict(),
-  z10.object(operationTerminalBodyShape).strict(),
-  z10.object(runTerminalBodyShape).strict()
+  z12.object(runStartedBodyShape).strict(),
+  z12.object(operationQueuedBodyShape).strict(),
+  z12.object(modelSelectedBodyShape).strict(),
+  z12.object(attemptQueuedBodyShape).strict(),
+  z12.object(attemptStartedBodyShape).strict(),
+  z12.object(sessionCreatedBodyShape).strict(),
+  z12.object(attemptTerminalBodyShape).strict(),
+  z12.object(operationTerminalBodyShape).strict(),
+  z12.object(runTerminalBodyShape).strict()
 ];
 var appendBodySchemas = bodySchemas.slice(1);
-var LifecycleAppendEventSchema = z10.discriminatedUnion("type", appendBodySchemas);
-var LifecycleEventSchema = z10.discriminatedUnion("type", [
-  z10.object({ ...eventEnvelopeShape, ...runStartedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...operationQueuedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...modelSelectedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...attemptQueuedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...attemptStartedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...sessionCreatedBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...attemptTerminalBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...operationTerminalBodyShape }).strict(),
-  z10.object({ ...eventEnvelopeShape, ...runTerminalBodyShape }).strict()
+var LifecycleAppendEventSchema = z12.discriminatedUnion("type", appendBodySchemas);
+var LifecycleEventSchema = z12.discriminatedUnion("type", [
+  z12.object({ ...eventEnvelopeShape, ...runStartedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...operationQueuedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...modelSelectedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...attemptQueuedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...attemptStartedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...sessionCreatedBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...attemptTerminalBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...operationTerminalBodyShape }).strict(),
+  z12.object({ ...eventEnvelopeShape, ...runTerminalBodyShape }).strict()
 ]);
-var LifecycleWriterLeaseInputSchema = z10.object({
-  writer: z10.object({
+var LifecycleWriterLeaseInputSchema = z12.object({
+  writer: z12.object({
     processID: positiveInteger,
     processInstanceID: nonEmptyString
   }).strict(),
   now: nonNegativeInteger,
   leaseDurationMs: positiveInteger
 }).strict();
-var LifecycleWriterLeaseSchema = z10.object({
-  version: z10.literal(1),
+var LifecycleWriterLeaseSchema = z12.object({
+  version: z12.literal(1),
   runID: nonEmptyString,
   writerToken: nonEmptyString,
   processID: positiveInteger,
@@ -7990,12 +9516,12 @@ var LIFECYCLE_GENESIS_DIGEST = sha256Hex("openteam/lifecycle-journal/genesis/v1"
 var NUL2 = "\x00";
 var NEWLINE = `
 `;
-var frameSchema = z11.object({
-  v: z11.literal(LIFECYCLE_CODEC_VERSION),
-  seq: z11.number().int().nonnegative(),
-  prev: z11.string().min(1),
-  sum: z11.string().min(1),
-  event: z11.unknown()
+var frameSchema = z13.object({
+  v: z13.literal(LIFECYCLE_CODEC_VERSION),
+  seq: z13.number().int().nonnegative(),
+  prev: z13.string().min(1),
+  sum: z13.string().min(1),
+  event: z13.unknown()
 }).strict();
 function canonical(value) {
   if (Array.isArray(value)) {
@@ -8513,94 +10039,94 @@ function replay(spec, events) {
 }
 
 // src/graph/schema.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/context/schema.ts
-import { z as z12 } from "zod";
-var PrivacyClassSchema = z12.enum(["public", "internal", "sensitive"]);
-var Sha256Schema = z12.string().regex(/^[0-9a-f]{64}$/, "expected lowercase hex sha-256");
-var IdentifierSchema = z12.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "invalid identifier");
-var TaskAnchorSchema = z12.object({
+import { z as z14 } from "zod";
+var PrivacyClassSchema = z14.enum(["public", "internal", "sensitive"]);
+var Sha256Schema = z14.string().regex(/^[0-9a-f]{64}$/, "expected lowercase hex sha-256");
+var IdentifierSchema = z14.string().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/, "invalid identifier");
+var TaskAnchorSchema = z14.object({
   taskID: IdentifierSchema,
   specDigest: Sha256Schema
 }).strict();
-var ContextRefSchema = z12.object({
-  uri: z12.string().min(1).max(1024),
+var ContextRefSchema = z14.object({
+  uri: z14.string().min(1).max(1024),
   sha256: Sha256Schema,
-  bytes: z12.number().int().nonnegative(),
-  mediaType: z12.string().min(1).max(128).optional()
+  bytes: z14.number().int().nonnegative(),
+  mediaType: z14.string().min(1).max(128).optional()
 }).strict();
-var ManifestEntrySchema = z12.object({
+var ManifestEntrySchema = z14.object({
   label: IdentifierSchema,
   sha256: Sha256Schema,
-  bytes: z12.number().int().nonnegative(),
+  bytes: z14.number().int().nonnegative(),
   ref: ContextRefSchema.optional()
 }).strict();
-var ArtifactManifestSchema = z12.object({
-  version: z12.literal(1),
+var ArtifactManifestSchema = z14.object({
+  version: z14.literal(1),
   taskID: IdentifierSchema,
   privacyClass: PrivacyClassSchema,
-  entries: z12.array(ManifestEntrySchema)
+  entries: z14.array(ManifestEntrySchema)
 }).strict();
-var NodeContextContractSchema = z12.object({
-  version: z12.literal(1),
-  refs: z12.array(ContextRefSchema),
+var NodeContextContractSchema = z14.object({
+  version: z14.literal(1),
+  refs: z14.array(ContextRefSchema),
   privacyClass: PrivacyClassSchema,
-  maxInputTokens: z12.number().int().positive().optional()
+  maxInputTokens: z14.number().int().positive().optional()
 }).strict();
 
 // src/graph/schema.ts
 var GRAPH_SPEC_VERSION = 1;
 var GRAPH_EVENT_VERSION = 1;
-var NodeIDSchema = z13.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid node id");
-var NodeRoleSchema = z13.enum(["implementer", "reviewer"]);
-var OperationIDSchema = z13.string().regex(/^[0-9a-f]{8,64}$/, "invalid operation id");
-var AttemptIDSchema = z13.string().regex(/^[0-9a-f]{8,64}$/, "invalid attempt id");
-var ErrorClassSchema = z13.enum([
+var NodeIDSchema = z15.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "invalid node id");
+var NodeRoleSchema = z15.enum(["implementer", "reviewer"]);
+var OperationIDSchema = z15.string().regex(/^[0-9a-f]{8,64}$/, "invalid operation id");
+var AttemptIDSchema = z15.string().regex(/^[0-9a-f]{8,64}$/, "invalid attempt id");
+var ErrorClassSchema = z15.enum([
   "transient",
   "permanent",
   "timeout",
   "cancelled",
   "unknown"
 ]);
-var GraphNodeSchema = z13.object({
+var GraphNodeSchema = z15.object({
   id: NodeIDSchema,
   role: NodeRoleSchema,
-  dependsOn: z13.array(NodeIDSchema).default([]),
+  dependsOn: z15.array(NodeIDSchema).default([]),
   anchor: TaskAnchorSchema,
   reviews: NodeIDSchema.optional()
 }).strict();
-var GraphSpecV1Schema = z13.object({
-  version: z13.literal(GRAPH_SPEC_VERSION),
+var GraphSpecV1Schema = z15.object({
+  version: z15.literal(GRAPH_SPEC_VERSION),
   runID: NodeIDSchema,
-  nodes: z13.array(GraphNodeSchema).min(1)
+  nodes: z15.array(GraphNodeSchema).min(1)
 }).strict();
 var eventEnvelope = {
-  v: z13.literal(GRAPH_EVENT_VERSION),
-  seq: z13.number().int().nonnegative(),
+  v: z15.literal(GRAPH_EVENT_VERSION),
+  seq: z15.number().int().nonnegative(),
   runID: NodeIDSchema
 };
-var RunStartedEventSchema = z13.object({
+var RunStartedEventSchema = z15.object({
   ...eventEnvelope,
-  type: z13.literal("run.started"),
+  type: z15.literal("run.started"),
   specDigest: Sha256Schema
 }).strict();
-var NodeDispatchedEventSchema = z13.object({
+var NodeDispatchedEventSchema = z15.object({
   ...eventEnvelope,
-  type: z13.literal("node.dispatched"),
+  type: z15.literal("node.dispatched"),
   nodeID: NodeIDSchema,
   operationID: OperationIDSchema,
   attemptID: AttemptIDSchema
 }).strict();
-var NodeSucceededEventSchema = z13.object({
+var NodeSucceededEventSchema = z15.object({
   ...eventEnvelope,
-  type: z13.literal("node.succeeded"),
+  type: z15.literal("node.succeeded"),
   nodeID: NodeIDSchema,
   operationID: OperationIDSchema,
   attemptID: AttemptIDSchema,
   artifact: ContextRefSchema
 }).strict();
-var NodeFailureClassSchema = z13.enum([
+var NodeFailureClassSchema = z15.enum([
   "create-rejected",
   "create-no-id",
   "prompt-rejected",
@@ -8614,24 +10140,24 @@ var NodeFailureClassSchema = z13.enum([
   "prompt-server",
   "unknown"
 ]);
-var NodeFailedEventSchema = z13.object({
+var NodeFailedEventSchema = z15.object({
   ...eventEnvelope,
-  type: z13.literal("node.failed"),
+  type: z15.literal("node.failed"),
   nodeID: NodeIDSchema,
   operationID: OperationIDSchema,
   attemptID: AttemptIDSchema,
   errorClass: ErrorClassSchema,
   failureClass: NodeFailureClassSchema.optional()
 }).strict();
-var NodeCancelledEventSchema = z13.object({
+var NodeCancelledEventSchema = z15.object({
   ...eventEnvelope,
-  type: z13.literal("node.cancelled"),
+  type: z15.literal("node.cancelled"),
   nodeID: NodeIDSchema
 }).strict();
-var RunCompletedEventSchema = z13.object({ ...eventEnvelope, type: z13.literal("run.completed") }).strict();
-var RunFailedEventSchema = z13.object({ ...eventEnvelope, type: z13.literal("run.failed") }).strict();
-var RunCancelledEventSchema = z13.object({ ...eventEnvelope, type: z13.literal("run.cancelled") }).strict();
-var GraphEventV1Schema = z13.discriminatedUnion("type", [
+var RunCompletedEventSchema = z15.object({ ...eventEnvelope, type: z15.literal("run.completed") }).strict();
+var RunFailedEventSchema = z15.object({ ...eventEnvelope, type: z15.literal("run.failed") }).strict();
+var RunCancelledEventSchema = z15.object({ ...eventEnvelope, type: z15.literal("run.cancelled") }).strict();
+var GraphEventV1Schema = z15.discriminatedUnion("type", [
   RunStartedEventSchema,
   NodeDispatchedEventSchema,
   NodeSucceededEventSchema,
@@ -8781,7 +10307,7 @@ import {
   realpathSync,
   writeSync
 } from "node:fs";
-import { basename, dirname as dirname2, join as join3, parse, resolve } from "node:path";
+import { basename, dirname as dirname2, join as join3, parse as parse2, resolve as resolve2 } from "node:path";
 function ensureDir(dir) {
   mkdirSync(dir, { recursive: true });
 }
@@ -8820,8 +10346,8 @@ function tryRealPath(path) {
   }
 }
 function realPathDeep(target) {
-  const absolute = resolve(target);
-  const root = parse(absolute).root;
+  const absolute = resolve2(target);
+  const root = parse2(absolute).root;
   let current = absolute;
   let suffix = "";
   while (current !== root) {
@@ -9279,6 +10805,13 @@ async function runConsoleServe(deps, options) {
         terminalEnabled,
         ptyEnabled,
         createClient: makeClient,
+        drilldownEnabled: graphViewEnabled,
+        conversationContentEnabled: config.console.sessionHistory?.contentEnabled === true,
+        ...config.console.sessionHistory?.endpoint !== undefined ? { historyEndpoint: config.console.sessionHistory.endpoint } : {},
+        readConversation: createConversationReader({
+          directory: deps.directory ?? process.cwd(),
+          ...deps.serverPassword !== undefined ? { password: deps.serverPassword } : {}
+        }),
         createPtyClient: makePtyClient
       },
       ...graphViewProvider !== undefined ? { graphView: graphViewProvider } : {},
@@ -9407,13 +10940,13 @@ async function invokeStateGraph(definition, input, deps) {
 }
 
 // src/graph/langgraph/checkpointer.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 var EPHEMERAL_CHECKPOINT_DIR = ".opencode/openteam-local/langgraph-checkpoints";
 var COMMITTED_CHECKPOINT_DIR = ".opencode/openteam/graph/checkpoints";
-var PersistedCheckpointSchema = z14.object({
-  runID: z14.string().min(1),
-  nodeID: z14.string().min(1),
-  route: z14.enum(["local", "frontier"]),
+var PersistedCheckpointSchema = z16.object({
+  runID: z16.string().min(1),
+  nodeID: z16.string().min(1),
+  route: z16.enum(["local", "frontier"]),
   stateHash: Sha256Schema
 }).strict();
 function createReferenceOnlySaver(location = COMMITTED_CHECKPOINT_DIR) {
@@ -9544,13 +11077,13 @@ function runCancelled(runID, seq) {
 
 // src/storage/graph/workspaceLease.ts
 import { join as join7 } from "node:path";
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/storage/graph/runRegistry.ts
 import { join as join6 } from "node:path";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var REGISTRY_FILE = "active-runs.json";
-var registrySchema = z15.object({ runs: z15.array(z15.string().min(1)) }).strict();
+var registrySchema = z17.object({ runs: z17.array(z17.string().min(1)) }).strict();
 
 class RunRegistryError extends Error {
   code = "corrupt";
@@ -9606,11 +11139,11 @@ function createRunRegistry(root) {
 
 // src/storage/graph/workspaceLease.ts
 var NUL5 = "\x00";
-var leaseRecordSchema = z16.object({
-  runID: z16.string().min(1),
-  holder: z16.string().min(1),
-  token: z16.string().length(32),
-  released: z16.boolean()
+var leaseRecordSchema = z18.object({
+  runID: z18.string().min(1),
+  holder: z18.string().min(1),
+  token: z18.string().length(32),
+  released: z18.boolean()
 }).strict();
 
 class LeaseError extends Error {
@@ -9626,7 +11159,7 @@ class LeaseError extends Error {
 function createWorkspaceLease(root, registry = createRunRegistry(root)) {
   const leasePath = (runID) => join7(root, `lease-${runID}.json`);
   const deriveToken = (runID, holder) => sha256Hex(`lease${NUL5}${runID}${NUL5}${holder}`).slice(0, 32);
-  const parse2 = (text) => {
+  const parse3 = (text) => {
     let raw;
     try {
       raw = JSON.parse(text);
@@ -9641,7 +11174,7 @@ function createWorkspaceLease(root, registry = createRunRegistry(root)) {
   };
   const readRecord = (runID) => {
     const text = readText(leasePath(runID));
-    return text === undefined ? undefined : parse2(text);
+    return text === undefined ? undefined : parse3(text);
   };
   const grant = async (runID, holder, token) => {
     const record2 = { runID, holder, token, released: false };
@@ -9704,7 +11237,7 @@ function planCancellation(state) {
 }
 
 // src/orchestrator/graphReview.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // src/graph/policies.ts
 var DEFAULT_RETRY_LIMIT = 3;
@@ -9727,11 +11260,11 @@ function retryAllowed(errorClass, attempts, limit = DEFAULT_RETRY_LIMIT) {
 }
 
 // src/orchestrator/graphReview.ts
-var ReviewInputSchema = z17.object({
-  decision: z17.enum(["approve", "reject"]),
+var ReviewInputSchema = z19.object({
+  decision: z19.enum(["approve", "reject"]),
   anchor: TaskAnchorSchema.optional(),
   artifactSha256: Sha256Schema.optional(),
-  reason: z17.string().min(1).max(500).optional()
+  reason: z19.string().min(1).max(500).optional()
 }).strict();
 function planRevision(input) {
   const limit = input.limit ?? DEFAULT_REVISION_LIMIT;
@@ -11079,15 +12612,15 @@ function createGraphOperator(options) {
 }
 
 // src/cli/graphStatusSnapshot.ts
-import { z as z18 } from "zod";
-var activeRunRegistrySchema = z18.object({
-  runs: z18.array(z18.string().min(1))
+import { z as z20 } from "zod";
+var activeRunRegistrySchema = z20.object({
+  runs: z20.array(z20.string().min(1))
 }).strict();
-var leaseRecordSchema2 = z18.object({
-  runID: z18.string().min(1),
-  holder: z18.string().min(1),
-  token: z18.string().length(32),
-  released: z18.boolean()
+var leaseRecordSchema2 = z20.object({
+  runID: z20.string().min(1),
+  holder: z20.string().min(1),
+  token: z20.string().length(32),
+  released: z20.boolean()
 }).strict();
 
 class BoundaryJsonError extends Error {
@@ -11768,7 +13301,7 @@ import {
   statSync as statSync2,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join11, resolve as resolve3 } from "node:path";
+import { join as join11, resolve as resolve4 } from "node:path";
 import { ZodError } from "zod";
 
 // src/storage/lifecycle/fsLifecycleSupport.ts
@@ -11789,7 +13322,7 @@ import {
   unlinkSync,
   writeSync as writeSync2
 } from "node:fs";
-import { basename as basename2, dirname as dirname3, join as join10, relative, resolve as resolve2 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join10, relative, resolve as resolve3 } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,126}[A-Za-z0-9])?$/u;
 
 class LifecycleFsError extends Error {
@@ -11813,7 +13346,7 @@ function validateRunID(runID) {
 }
 function resolvedLifecycleRoot(root) {
   try {
-    const absolute = resolve2(root);
+    const absolute = resolve3(root);
     mkdirSync2(absolute, { recursive: true });
     const rootStat = lstatSync(absolute);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
@@ -11856,7 +13389,7 @@ function assertExistingSafeRun(root, runID) {
     throw new LifecycleFsError("unavailable");
   }
   const child = relative(root, real);
-  if (child === "" || child.startsWith("..") || resolve2(root, child) !== real || dirname3(real) !== root) {
+  if (child === "" || child.startsWith("..") || resolve3(root, child) !== real || dirname3(real) !== root) {
     throw new LifecycleFsError("corrupt");
   }
   return real;
@@ -11989,9 +13522,9 @@ function mapFsFailure(error, runID) {
   }
   return failure("unavailable", { recoverable: true, ...context });
 }
-function parseJson(text, parse2) {
+function parseJson(text, parse3) {
   try {
-    return parse2(JSON.parse(text));
+    return parse3(JSON.parse(text));
   } catch {
     throw new LifecycleFsError("corrupt");
   }
@@ -12096,7 +13629,7 @@ function canDeleteTerminalRun(runDir, runID, now) {
   return now >= lease.expiresAt;
 }
 var createFsLifecycleJournal = (options) => {
-  const configuredRoot = resolve3(options.root);
+  const configuredRoot = resolve4(options.root);
   const now = options.now ?? Date.now;
   const mutateRun = options.withMutationLock ?? withRunMutationLock;
   return {
@@ -12619,9 +14152,9 @@ var createLifecycleHistoryProvider = (options, legacyFs = legacyReadFs) => {
 
 // src/cli/migrateAdapter.ts
 import * as fs from "node:fs";
-import { dirname as dirname4, join as join14, resolve as resolve4 } from "node:path";
+import { dirname as dirname4, join as join14, resolve as resolve5 } from "node:path";
 function createMigrateAdapter(root) {
-  const rootAbs = resolve4(root);
+  const rootAbs = resolve5(root);
   const toDisk = (relPath) => join14(rootAbs, ...splitVirtualPath(relPath));
   return {
     async exists(relPath) {
@@ -12715,7 +14248,7 @@ async function resolveOpencodeVersionBestEffort(deps) {
 // src/cli/purgeAdapter.ts
 import { execFile } from "node:child_process";
 import * as fs2 from "node:fs";
-import { dirname as dirname5, join as join15, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join15, resolve as resolve6 } from "node:path";
 import { promisify } from "node:util";
 
 // src/opencodeArtifacts/orchestratorAgent.ts
@@ -13125,7 +14658,7 @@ var REFUSAL_MARKERS = [
   "cannot remove a locked"
 ];
 function createPurgeAdapter(root) {
-  const repoRootAbs = resolve5(root);
+  const repoRootAbs = resolve6(root);
   const worktreesDir = join15(repoRootAbs, ...DEFAULT_GRAPH_WORKTREES_DIR.split("/"));
   const agentDirAbs = join15(repoRootAbs, ...AGENT_DIR_POSIX.split("/"));
   const exec = nodeExec();
@@ -13134,7 +14667,7 @@ function createPurgeAdapter(root) {
     repoRoot: repoRootAbs,
     worktreesDir
   });
-  const toDisk = (relPath) => resolve5(repoRootAbs, relPath);
+  const toDisk = (relPath) => resolve6(repoRootAbs, relPath);
   const runGit2 = async (rest) => exec("git", ["-C", repoRootAbs, ...GIT_TOP_FLAGS2, ...rest]);
   return {
     repoRoot() {
@@ -14334,11 +15867,11 @@ function planWorktreeReconciliation(input) {
 }
 
 // src/telemetry/otelConfig.ts
-import { z as z19 } from "zod";
-var OtelBackendConfigSchema = z19.object({
-  backend: z19.literal("opentelemetry"),
-  connectionEnv: z19.string().min(1),
-  serviceName: z19.string().min(1).optional()
+import { z as z21 } from "zod";
+var OtelBackendConfigSchema = z21.object({
+  backend: z21.literal("opentelemetry"),
+  connectionEnv: z21.string().min(1),
+  serviceName: z21.string().min(1).optional()
 }).strict();
 function parseConnectionString(raw) {
   const pairs = new Map;
@@ -15317,31 +16850,31 @@ function mergeOpencodeConfigs(base, override) {
 }
 
 // src/graph/soakLedger.ts
-import { z as z20 } from "zod";
-var Sha256Schema2 = z20.string().regex(/^[0-9a-f]{64}$/);
-var SoakPlatformSchema = z20.enum(["linux", "win32", "darwin"]);
-var PrivacyPairSchema = z20.object({
-  surfacesScanned: z20.number().int().nonnegative(),
-  rawFindings: z20.number().int().nonnegative()
+import { z as z22 } from "zod";
+var Sha256Schema2 = z22.string().regex(/^[0-9a-f]{64}$/);
+var SoakPlatformSchema = z22.enum(["linux", "win32", "darwin"]);
+var PrivacyPairSchema = z22.object({
+  surfacesScanned: z22.number().int().nonnegative(),
+  rawFindings: z22.number().int().nonnegative()
 }).strict();
-var DuplicateEffectPairSchema = z20.object({
-  effectsExamined: z20.number().int().nonnegative(),
-  duplicatesFound: z20.number().int().nonnegative()
+var DuplicateEffectPairSchema = z22.object({
+  effectsExamined: z22.number().int().nonnegative(),
+  duplicatesFound: z22.number().int().nonnegative()
 }).strict();
-var ModelVerificationPairSchema = z20.object({
-  nodesChecked: z20.number().int().nonnegative(),
-  unverified: z20.number().int().nonnegative(),
-  mismatched: z20.number().int().nonnegative()
+var ModelVerificationPairSchema = z22.object({
+  nodesChecked: z22.number().int().nonnegative(),
+  unverified: z22.number().int().nonnegative(),
+  mismatched: z22.number().int().nonnegative()
 }).strict();
-var SoakObservationSchema = z20.object({
-  version: z20.literal(1),
-  seq: z20.number().int().nonnegative(),
-  timestamp: z20.string().datetime(),
+var SoakObservationSchema = z22.object({
+  version: z22.literal(1),
+  seq: z22.number().int().nonnegative(),
+  timestamp: z22.string().datetime(),
   platform: SoakPlatformSchema,
-  opencodeVersion: z20.string().min(1),
-  provenance: z20.enum(["genuine-usage", "ci-synthetic"]),
+  opencodeVersion: z22.string().min(1),
+  provenance: z22.enum(["genuine-usage", "ci-synthetic"]),
   traceDigest: Sha256Schema2,
-  criticalDivergences: z20.number().int().nonnegative().nullable(),
+  criticalDivergences: z22.number().int().nonnegative().nullable(),
   privacy: PrivacyPairSchema.nullable(),
   duplicateEffects: DuplicateEffectPairSchema.nullable(),
   modelVerification: ModelVerificationPairSchema.nullable(),
@@ -17762,14 +19295,14 @@ ${HELP}`
 }
 
 // src/orchestrator/roster.ts
-import { z as z21 } from "zod";
-var RosterEntrySchema = z21.object({
-  roleID: z21.string().min(1),
-  agentName: z21.string().min(1)
+import { z as z23 } from "zod";
+var RosterEntrySchema = z23.object({
+  roleID: z23.string().min(1),
+  agentName: z23.string().min(1)
 }).strict();
-var RosterSchema = z21.object({
-  universe: z21.string().min(1),
-  entries: z21.array(RosterEntrySchema)
+var RosterSchema = z23.object({
+  universe: z23.string().min(1),
+  entries: z23.array(RosterEntrySchema)
 }).strict();
 var ROSTER_JSON_FENCE = /```json\s*([\s\S]*?)```/;
 
@@ -18323,7 +19856,7 @@ import { readFile as readFile2 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname6 } from "node:path";
 
 // src/graph/certificate.ts
-import { z as z22 } from "zod";
+import { z as z24 } from "zod";
 
 // src/contract/opencode.ts
 var SUPPORTED_OPENCODE_VERSIONS = [
@@ -18364,7 +19897,7 @@ function isCertificateVersionCompatible(certifiedVersion, liveVersion) {
 
 // src/graph/certificate.ts
 var SHADOW_CERTIFICATE_MIN_RUNS = 1000;
-var DivergenceCodeSchema = z22.enum([
+var DivergenceCodeSchema = z24.enum([
   "status",
   "order",
   "roles",
@@ -18372,50 +19905,50 @@ var DivergenceCodeSchema = z22.enum([
   "fixes",
   "outcome"
 ]);
-var ProvenanceSchema = z22.enum([
+var ProvenanceSchema = z24.enum([
   "recomputed",
   "compiled",
   "validated",
   "carried"
 ]);
-var EvidenceSchema = z22.object({
-  opencodeVersion: z22.string().min(1),
-  parity: z22.object({
-    runs: z22.number().int().nonnegative(),
-    match: z22.number().int().nonnegative(),
-    divergent: z22.number().int().nonnegative(),
-    inconclusive: z22.number().int().nonnegative(),
-    divergences: z22.array(DivergenceCodeSchema)
+var EvidenceSchema = z24.object({
+  opencodeVersion: z24.string().min(1),
+  parity: z24.object({
+    runs: z24.number().int().nonnegative(),
+    match: z24.number().int().nonnegative(),
+    divergent: z24.number().int().nonnegative(),
+    inconclusive: z24.number().int().nonnegative(),
+    divergences: z24.array(DivergenceCodeSchema)
   }).strict(),
-  legacy: z22.object({
-    observed: z22.number().int().nonnegative(),
-    duplicated: z22.number().int().nonnegative()
+  legacy: z24.object({
+    observed: z24.number().int().nonnegative(),
+    duplicated: z24.number().int().nonnegative()
   }).strict(),
-  privacy: z22.object({
-    surfacesScanned: z22.number().int().nonnegative(),
-    rawFindings: z22.number().int().nonnegative()
+  privacy: z24.object({
+    surfacesScanned: z24.number().int().nonnegative(),
+    rawFindings: z24.number().int().nonnegative()
   }).strict(),
-  overhead: z22.object({
-    p95Millis: z22.number().nonnegative(),
-    budgetMillis: z22.number().positive(),
-    samples: z22.number().int().nonnegative()
+  overhead: z24.object({
+    p95Millis: z24.number().nonnegative(),
+    budgetMillis: z24.number().positive(),
+    samples: z24.number().int().nonnegative()
   }).strict(),
-  provenance: z22.record(DivergenceCodeSchema, ProvenanceSchema)
+  provenance: z24.record(DivergenceCodeSchema, ProvenanceSchema)
 }).strict();
-var CertificateSchema = z22.object({
-  version: z22.literal(1),
-  certificate: z22.literal("graph-shadow"),
-  opencodeVersion: z22.string().min(1),
+var CertificateSchema = z24.object({
+  version: z24.literal(1),
+  certificate: z24.literal("graph-shadow"),
+  opencodeVersion: z24.string().min(1),
   evidence: EvidenceSchema,
-  verdict: z22.enum(["pass", "fail"]),
-  failedGates: z22.array(z22.enum([
+  verdict: z24.enum(["pass", "fail"]),
+  failedGates: z24.array(z24.enum([
     "sample",
     "parity",
     "one-legacy-execution",
     "privacy",
     "overhead"
   ])),
-  digest: z22.string().regex(/^[0-9a-f]{64}$/)
+  digest: z24.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class ShadowCertificateError extends Error {
@@ -18530,37 +20063,37 @@ function parseShadowCertificate(value, opencodeVersion) {
   }
   return certificate;
 }
-var ReleaseDeterminismSchema = z22.object({ runs: z22.number().int().nonnegative(), allMatch: z22.boolean() }).strict();
-var ReleaseCrashRecoverySchema = z22.object({
-  scenarios: z22.number().int().nonnegative(),
-  allConverge: z22.boolean()
+var ReleaseDeterminismSchema = z24.object({ runs: z24.number().int().nonnegative(), allMatch: z24.boolean() }).strict();
+var ReleaseCrashRecoverySchema = z24.object({
+  scenarios: z24.number().int().nonnegative(),
+  allConverge: z24.boolean()
 }).strict();
-var ReleaseReplayEquivalenceSchema = z22.object({
-  checks: z22.number().int().nonnegative(),
-  allEquivalent: z22.boolean()
+var ReleaseReplayEquivalenceSchema = z24.object({
+  checks: z24.number().int().nonnegative(),
+  allEquivalent: z24.boolean()
 }).strict();
-var ReleasePrivacySchema = z22.object({
-  surfacesScanned: z22.number().int().nonnegative(),
-  rawFindings: z22.number().int().nonnegative()
+var ReleasePrivacySchema = z24.object({
+  surfacesScanned: z24.number().int().nonnegative(),
+  rawFindings: z24.number().int().nonnegative()
 }).strict();
-var ReleaseContractSchema = z22.object({
-  roundTrips: z22.number().int().nonnegative(),
-  allSettled: z22.boolean()
+var ReleaseContractSchema = z24.object({
+  roundTrips: z24.number().int().nonnegative(),
+  allSettled: z24.boolean()
 }).strict();
-var ReleaseHealthSchema = z22.object({
-  samples: z22.number().int().nonnegative(),
-  bounded: z22.boolean(),
-  idempotent: z22.boolean()
+var ReleaseHealthSchema = z24.object({
+  samples: z24.number().int().nonnegative(),
+  bounded: z24.boolean(),
+  idempotent: z24.boolean()
 }).strict();
-var ReleasePerformanceSchema = z22.object({
-  p95Millis: z22.number().nonnegative(),
-  budgetMillis: z22.number().positive(),
-  samples: z22.number().int().nonnegative()
+var ReleasePerformanceSchema = z24.object({
+  p95Millis: z24.number().nonnegative(),
+  budgetMillis: z24.number().positive(),
+  samples: z24.number().int().nonnegative()
 }).strict();
-var ReleaseEvidenceSchema = z22.object({
-  opencodeVersion: z22.string().min(1),
-  platform: z22.enum(["linux", "win32"]),
-  shadowCertificateDigest: z22.string().regex(/^[0-9a-f]{64}$/),
+var ReleaseEvidenceSchema = z24.object({
+  opencodeVersion: z24.string().min(1),
+  platform: z24.enum(["linux", "win32"]),
+  shadowCertificateDigest: z24.string().regex(/^[0-9a-f]{64}$/),
   determinism: ReleaseDeterminismSchema,
   crashRecovery: ReleaseCrashRecoverySchema,
   replayEquivalence: ReleaseReplayEquivalenceSchema,
@@ -18569,15 +20102,15 @@ var ReleaseEvidenceSchema = z22.object({
   health: ReleaseHealthSchema,
   performance: ReleasePerformanceSchema
 }).strict();
-var ReleaseCertificateSchema = z22.object({
-  version: z22.literal(2),
-  certificate: z22.literal("graph-release"),
-  platform: z22.enum(["linux", "win32"]),
-  opencodeVersion: z22.string().min(1),
-  shadowCertificateDigest: z22.string().regex(/^[0-9a-f]{64}$/),
+var ReleaseCertificateSchema = z24.object({
+  version: z24.literal(2),
+  certificate: z24.literal("graph-release"),
+  platform: z24.enum(["linux", "win32"]),
+  opencodeVersion: z24.string().min(1),
+  shadowCertificateDigest: z24.string().regex(/^[0-9a-f]{64}$/),
   evidence: ReleaseEvidenceSchema,
-  verdict: z22.enum(["pass", "fail"]),
-  failedGates: z22.array(z22.enum([
+  verdict: z24.enum(["pass", "fail"]),
+  failedGates: z24.array(z24.enum([
     "shadow-valid",
     "determinism",
     "crash-recovery",
@@ -18587,7 +20120,7 @@ var ReleaseCertificateSchema = z22.object({
     "health",
     "performance"
   ])),
-  digest: z22.string().regex(/^[0-9a-f]{64}$/)
+  digest: z24.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class ReleaseCertificateError extends Error {
@@ -18715,7 +20248,7 @@ function parseReleaseCertificate(value, opencodeVersion, expectedShadowDigest) {
   }
   return certificate;
 }
-var ShadowDivergenceCodeSchema = z22.enum([
+var ShadowDivergenceCodeSchema = z24.enum([
   "status",
   "order",
   "roles",
@@ -18724,13 +20257,13 @@ var ShadowDivergenceCodeSchema = z22.enum([
   "outcome"
 ]);
 var RECOMPUTED_DIVERGENCE_CODES = ["fixes"];
-var RecomputedDivergenceCodeSchema = z22.enum(RECOMPUTED_DIVERGENCE_CODES);
-var SoakPolicySchema = z22.object({
-  minimumGenuineObservations: z22.number().int().positive(),
-  minimumDistinctDays: z22.number().int().positive(),
-  requireGenuineUsageOnAllPlatforms: z22.boolean(),
-  supportedOpencodeVersions: z22.array(z22.string().min(1)).min(1),
-  criticalDivergenceCodes: z22.array(RecomputedDivergenceCodeSchema).min(1)
+var RecomputedDivergenceCodeSchema = z24.enum(RECOMPUTED_DIVERGENCE_CODES);
+var SoakPolicySchema = z24.object({
+  minimumGenuineObservations: z24.number().int().positive(),
+  minimumDistinctDays: z24.number().int().positive(),
+  requireGenuineUsageOnAllPlatforms: z24.boolean(),
+  supportedOpencodeVersions: z24.array(z24.string().min(1)).min(1),
+  criticalDivergenceCodes: z24.array(RecomputedDivergenceCodeSchema).min(1)
 }).strict();
 var DEFAULT_SOAK_POLICY = {
   minimumGenuineObservations: 100,
@@ -18739,46 +20272,46 @@ var DEFAULT_SOAK_POLICY = {
   supportedOpencodeVersions: [...SUPPORTED_OPENCODE_VERSIONS],
   criticalDivergenceCodes: ["fixes"]
 };
-var SoakPlatformEnumSchema = z22.enum(["linux", "win32", "darwin"]);
-var SoakPrivacyPairEvidenceSchema = z22.object({
-  surfacesScanned: z22.number().int().nonnegative(),
-  rawFindings: z22.number().int().nonnegative()
+var SoakPlatformEnumSchema = z24.enum(["linux", "win32", "darwin"]);
+var SoakPrivacyPairEvidenceSchema = z24.object({
+  surfacesScanned: z24.number().int().nonnegative(),
+  rawFindings: z24.number().int().nonnegative()
 }).strict();
-var SoakDuplicateEffectPairEvidenceSchema = z22.object({
-  effectsExamined: z22.number().int().nonnegative(),
-  duplicatesFound: z22.number().int().nonnegative()
+var SoakDuplicateEffectPairEvidenceSchema = z24.object({
+  effectsExamined: z24.number().int().nonnegative(),
+  duplicatesFound: z24.number().int().nonnegative()
 }).strict();
-var SoakModelVerificationPairEvidenceSchema = z22.object({
-  nodesChecked: z22.number().int().nonnegative(),
-  unverified: z22.number().int().nonnegative(),
-  mismatched: z22.number().int().nonnegative()
+var SoakModelVerificationPairEvidenceSchema = z24.object({
+  nodesChecked: z24.number().int().nonnegative(),
+  unverified: z24.number().int().nonnegative(),
+  mismatched: z24.number().int().nonnegative()
 }).strict();
-var SoakEvidenceSchema = z22.object({
-  totalObservations: z22.number().int().nonnegative(),
-  genuineUsageObservations: z22.number().int().nonnegative(),
-  ciSyntheticObservations: z22.number().int().nonnegative(),
-  recorderCount: z22.number().int().nonnegative(),
-  ineligibleObservations: z22.number().int().nonnegative(),
-  firstTimestamp: z22.string().datetime().nullable(),
-  lastTimestamp: z22.string().datetime().nullable(),
-  distinctDays: z22.number().int().nonnegative(),
-  criticalDivergences: z22.number().int().nonnegative().nullable(),
+var SoakEvidenceSchema = z24.object({
+  totalObservations: z24.number().int().nonnegative(),
+  genuineUsageObservations: z24.number().int().nonnegative(),
+  ciSyntheticObservations: z24.number().int().nonnegative(),
+  recorderCount: z24.number().int().nonnegative(),
+  ineligibleObservations: z24.number().int().nonnegative(),
+  firstTimestamp: z24.string().datetime().nullable(),
+  lastTimestamp: z24.string().datetime().nullable(),
+  distinctDays: z24.number().int().nonnegative(),
+  criticalDivergences: z24.number().int().nonnegative().nullable(),
   privacy: SoakPrivacyPairEvidenceSchema.nullable(),
   duplicateEffects: SoakDuplicateEffectPairEvidenceSchema.nullable(),
   modelVerification: SoakModelVerificationPairEvidenceSchema.nullable(),
-  platformsGenuine: z22.array(SoakPlatformEnumSchema),
-  platformsSynthetic: z22.array(SoakPlatformEnumSchema),
-  opencodeVersionsObserved: z22.array(z22.string().min(1)),
-  invalidChains: z22.number().int().nonnegative()
+  platformsGenuine: z24.array(SoakPlatformEnumSchema),
+  platformsSynthetic: z24.array(SoakPlatformEnumSchema),
+  opencodeVersionsObserved: z24.array(z24.string().min(1)),
+  invalidChains: z24.number().int().nonnegative()
 }).strict();
-var SoakCertificateSchema = z22.object({
-  version: z22.literal(1),
-  certificate: z22.literal("graph-soak"),
-  trustBoundary: z22.literal("contributors"),
+var SoakCertificateSchema = z24.object({
+  version: z24.literal(1),
+  certificate: z24.literal("graph-soak"),
+  trustBoundary: z24.literal("contributors"),
   policy: SoakPolicySchema,
   evidence: SoakEvidenceSchema,
-  verdict: z22.enum(["pass", "fail"]),
-  failedGates: z22.array(z22.enum([
+  verdict: z24.enum(["pass", "fail"]),
+  failedGates: z24.array(z24.enum([
     "minimum-observations",
     "minimum-duration",
     "chain-integrity",
@@ -18789,8 +20322,8 @@ var SoakCertificateSchema = z22.object({
     "os-diversity",
     "opencode-pin"
   ])),
-  ledgerDigest: z22.string().regex(/^[0-9a-f]{64}$/),
-  digest: z22.string().regex(/^[0-9a-f]{64}$/)
+  ledgerDigest: z24.string().regex(/^[0-9a-f]{64}$/),
+  digest: z24.string().regex(/^[0-9a-f]{64}$/)
 }).strict();
 
 class SoakCertificateError extends Error {
@@ -18916,7 +20449,7 @@ function parseSoakCertificate(value, expectedPolicy, expectedLedgerDigest) {
 }
 
 // src/lifecycle/root.ts
-import { isAbsolute, normalize, relative as relative2, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute2, normalize as normalize2, relative as relative2, resolve as resolve9 } from "node:path";
 
 // src/messages/lifecycleStorage.ts
 var lifecycleStorageMessages = {
@@ -18925,16 +20458,16 @@ var lifecycleStorageMessages = {
 
 // src/lifecycle/root.ts
 var resolveLifecycleRoot = (options) => {
-  const workspaceRoot = resolve8(options.workspaceRoot);
-  if (isAbsolute(options.configuredRoot)) {
-    return normalize(resolve8(options.configuredRoot));
+  const workspaceRoot = resolve9(options.workspaceRoot);
+  if (isAbsolute2(options.configuredRoot)) {
+    return normalize2(resolve9(options.configuredRoot));
   }
-  const resolved = resolve8(workspaceRoot, options.configuredRoot);
+  const resolved = resolve9(workspaceRoot, options.configuredRoot);
   const workspaceRelative = relative2(workspaceRoot, resolved);
-  if (workspaceRelative === ".." || workspaceRelative.startsWith(`..\\`) || workspaceRelative.startsWith("../") || isAbsolute(workspaceRelative)) {
+  if (workspaceRelative === ".." || workspaceRelative.startsWith(`..\\`) || workspaceRelative.startsWith("../") || isAbsolute2(workspaceRelative)) {
     throw new Error(lifecycleStorageMessages.configuredRootEscapesWorkspace);
   }
-  return normalize(resolved);
+  return normalize2(resolved);
 };
 
 // src/lifecycle/runtimeRecorder.ts
@@ -19438,62 +20971,62 @@ var realCacheAdapter = {
 };
 
 // src/memory/types.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 var SHARED_OWNER_KEY = "*";
-var OwnerKeySchema = z23.string().min(1);
-var MemoryKindSchema = z23.enum(["fact", "preference", "entity"]);
-var MemoryBaseSchema = z23.object({
-  id: z23.string().min(1),
+var OwnerKeySchema = z25.string().min(1);
+var MemoryKindSchema = z25.enum(["fact", "preference", "entity"]);
+var MemoryBaseSchema = z25.object({
+  id: z25.string().min(1),
   ownerKey: OwnerKeySchema,
-  confidence: z23.number().min(0).max(1),
-  validFrom: z23.number().finite(),
-  validUntil: z23.number().finite().nullable().default(null),
-  createdAt: z23.number().finite(),
-  invalidatedAt: z23.number().finite().nullable().default(null),
-  sourceHash: z23.string().min(1),
-  supersededBy: z23.string().min(1).nullable().default(null)
+  confidence: z25.number().min(0).max(1),
+  validFrom: z25.number().finite(),
+  validUntil: z25.number().finite().nullable().default(null),
+  createdAt: z25.number().finite(),
+  invalidatedAt: z25.number().finite().nullable().default(null),
+  sourceHash: z25.string().min(1),
+  supersededBy: z25.string().min(1).nullable().default(null)
 }).strict();
 var FactSchema = MemoryBaseSchema.extend({
-  kind: z23.literal("fact"),
-  subject: z23.string().min(1),
-  predicate: z23.string().min(1),
-  object: z23.string().min(1),
-  category: z23.string().min(1).nullable().default(null)
+  kind: z25.literal("fact"),
+  subject: z25.string().min(1),
+  predicate: z25.string().min(1),
+  object: z25.string().min(1),
+  category: z25.string().min(1).nullable().default(null)
 });
 var PreferenceSchema = MemoryBaseSchema.extend({
-  kind: z23.literal("preference"),
-  category: z23.string().min(1),
-  preference: z23.string().min(1),
-  context: z23.string().min(1).nullable().default(null),
-  lastAccessedAt: z23.number().finite().nullable().default(null),
-  accessCount: z23.number().int().min(0).default(0)
+  kind: z25.literal("preference"),
+  category: z25.string().min(1),
+  preference: z25.string().min(1),
+  context: z25.string().min(1).nullable().default(null),
+  lastAccessedAt: z25.number().finite().nullable().default(null),
+  accessCount: z25.number().int().min(0).default(0)
 });
 var EntitySchema = MemoryBaseSchema.extend({
-  kind: z23.literal("entity"),
-  canonicalName: z23.string().min(1),
-  type: z23.string().min(1),
-  aliases: z23.array(z23.string().min(1)).default([])
+  kind: z25.literal("entity"),
+  canonicalName: z25.string().min(1),
+  type: z25.string().min(1),
+  aliases: z25.array(z25.string().min(1)).default([])
 });
 var RelationSchema = MemoryBaseSchema.extend({
-  kind: z23.literal("relation"),
-  from: z23.string().min(1),
-  to: z23.string().min(1),
-  predicate: z23.string().min(1),
-  annotation: z23.string().min(1).nullable().default(null)
+  kind: z25.literal("relation"),
+  from: z25.string().min(1),
+  to: z25.string().min(1),
+  predicate: z25.string().min(1),
+  annotation: z25.string().min(1).nullable().default(null)
 });
-var MemoryRecordSchema = z23.discriminatedUnion("kind", [
+var MemoryRecordSchema = z25.discriminatedUnion("kind", [
   FactSchema,
   PreferenceSchema,
   EntitySchema,
   RelationSchema
 ]);
-var RecallQuerySchema = z23.object({
+var RecallQuerySchema = z25.object({
   ownerKey: OwnerKeySchema,
-  kinds: z23.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
-  asOf: z23.number().finite().nullable().default(null),
-  limit: z23.number().int().positive().default(8),
-  minSimilarity: z23.number().min(0).max(1).default(0.2),
-  includeShared: z23.boolean().default(true)
+  kinds: z25.array(MemoryKindSchema).default(["fact", "preference", "entity"]),
+  asOf: z25.number().finite().nullable().default(null),
+  limit: z25.number().int().positive().default(8),
+  minSimilarity: z25.number().min(0).max(1).default(0.2),
+  includeShared: z25.boolean().default(true)
 }).strict();
 
 // src/memory/rank.ts
@@ -20102,12 +21635,12 @@ function createLocalEmbedder(request, deps) {
 }
 
 // src/memory/embedText.ts
-function normalize2(parts) {
+function normalize3(parts) {
   return parts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
 }
 function recordEmbeddingText(record2) {
   if (record2.kind === "fact") {
-    return normalize2([
+    return normalize3([
       record2.subject,
       record2.predicate,
       record2.object,
@@ -20115,21 +21648,21 @@ function recordEmbeddingText(record2) {
     ]);
   }
   if (record2.kind === "preference") {
-    return normalize2([
+    return normalize3([
       record2.category,
       record2.preference,
       record2.context ?? ""
     ]);
   }
   if (record2.kind === "relation") {
-    return normalize2([
+    return normalize3([
       record2.from,
       record2.predicate,
       record2.to,
       record2.annotation ?? ""
     ]);
   }
-  return normalize2([record2.canonicalName, record2.type, ...record2.aliases]);
+  return normalize3([record2.canonicalName, record2.type, ...record2.aliases]);
 }
 
 // src/storage/index/memoryEmbeddings.ts
@@ -20211,7 +21744,7 @@ async function buildMemoryRuntimeFromConfig(config, deps, options = {}) {
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.20.0",
+  version: "0.21.0",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -20338,14 +21871,14 @@ async function readPackagedCertificate(path4) {
     return;
   }
 }
-async function readAndParseCertificate(storage, path4, parse2, digestExtractor, fallbackRead) {
+async function readAndParseCertificate(storage, path4, parse3, digestExtractor, fallbackRead) {
   try {
     const content = await storage.read(path4) ?? (fallbackRead === undefined ? undefined : await fallbackRead(path4));
     if (content === undefined) {
       return { status: "absent" };
     }
     const raw = JSON.parse(content);
-    const cert = parse2(raw);
+    const cert = parse3(raw);
     return { status: "valid", digest: digestExtractor(cert) };
   } catch (error) {
     if (isMissingFile(error)) {
@@ -21104,7 +22637,7 @@ async function readConfigFile(path4, resolution) {
     return storage.read(path4);
   }
   try {
-    return await readFile3(resolve9(path4), "utf8");
+    return await readFile3(resolve10(path4), "utf8");
   } catch (error) {
     throw new Error(`[openteam] config file named by --config could not be read: ${path4} (${describeFileReadError(error)})`);
   }
@@ -21127,7 +22660,7 @@ async function saveConfig(config, path4, resolution = { explicit: false }) {
     return;
   }
   const contents = serializeOpenTeamConfig(config);
-  const diskPath = resolve9(path4);
+  const diskPath = resolve10(path4);
   await mkdir2(dirname7(diskPath), { recursive: true });
   await writeFile2(diskPath, contents, "utf8");
 }
@@ -21173,8 +22706,8 @@ async function openBrowser(url) {
   }
 }
 function waitForSignal() {
-  return new Promise((resolve10) => {
-    const done = () => resolve10();
+  return new Promise((resolve11) => {
+    const done = () => resolve11();
     process.once("SIGINT", done);
     process.once("SIGTERM", done);
   });
@@ -21363,7 +22896,7 @@ async function main() {
         workspaceRoot,
         configuredRoot: initialConsoleConfig.lifecycle?.root ?? DEFAULT_LIFECYCLE_ROOT
       });
-      const legacyGraphRoot = resolve9(workspaceRoot, initialConsoleConfig.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT);
+      const legacyGraphRoot = resolve10(workspaceRoot, initialConsoleConfig.graph?.journalRoot ?? DEFAULT_GRAPH_JOURNAL_ROOT);
       const lifecycleAvailability = initialConsoleConfig.console.graphView?.enabled === true ? "enabled" : "history-disabled";
       const lifecycleHistoryReader = createLifecycleHistoryProvider({
         lifecycleRoot,