@openscout/scout 0.2.68 → 0.2.70

package/dist/pair-supervisor.mjs

@@ -715,6 +715,59 @@ function renderToolResultContent(content) {
   }
   return stringifyUnknown(content);
 }
+function renderContentPartsText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    if (!isRecord(entry)) {
+      return "";
+    }
+    if (typeof entry.text === "string") {
+      return entry.text;
+    }
+    if (typeof entry.content === "string") {
+      return entry.content;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+}
+function extractReasoningText(item) {
+  const summary = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const summaryText = summary.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record = entry;
+    if (typeof record.text === "string") {
+      return record.text;
+    }
+    if (typeof record.summary === "string") {
+      return record.summary;
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+  const contentText = content.map((entry) => {
+    if (typeof entry === "string") {
+      return entry;
+    }
+    const record = entry;
+    return typeof record.text === "string" ? record.text : "";
+  }).filter(Boolean).join(`
+`);
+  return [summaryText, contentText].filter(Boolean).join(`
+
+`).trim();
+}
 function extractQuestionOptions(firstQuestion) {
   const options = Array.isArray(firstQuestion.options) ? firstQuestion.options : [];
   return options.map((option) => {
@@ -1424,20 +1477,520 @@ class ClaudeCodeHistoryParser {
     });
   }
 }
+
+class CodexHistoryParser {
+  session;
+  baseTimestampMs;
+  events = [];
+  currentTurn = null;
+  turnCounter = 0;
+  blockIndex = 0;
+  blockById = new Map;
+  toolBlockMap = new Map;
+  assistantMessageTextThisTurn = new Set;
+  inputTokens = 0;
+  outputTokens = 0;
+  reasoningOutputTokens = 0;
+  cachedInputTokens = 0;
+  tokenEventCount = 0;
+  constructor(session, baseTimestampMs) {
+    this.session = session;
+    this.baseTimestampMs = baseTimestampMs;
+  }
+  parse(content) {
+    const lines = content.split(/\r?\n/u);
+    let parsedLineCount = 0;
+    let skippedLineCount = 0;
+    let lineCount = 0;
+    let lastCapturedAt = this.baseTimestampMs;
+    for (let index = 0;index < lines.length; index += 1) {
+      const rawLine = lines[index];
+      const trimmed = rawLine.trim();
+      if (!trimmed) {
+        continue;
+      }
+      lineCount += 1;
+      let record;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed)) {
+          skippedLineCount += 1;
+          continue;
+        }
+        record = parsed;
+      } catch {
+        skippedLineCount += 1;
+        continue;
+      }
+      const capturedAt = extractRecordTimestamp(record) ?? this.baseTimestampMs + index;
+      lastCapturedAt = capturedAt;
+      if (this.handleRecord(record, capturedAt)) {
+        parsedLineCount += 1;
+      } else {
+        skippedLineCount += 1;
+      }
+    }
+    if (this.persistUsageMetadata()) {
+      this.emitSessionUpdate(lastCapturedAt);
+    }
+    return {
+      events: this.events,
+      lineCount,
+      parsedLineCount,
+      skippedLineCount
+    };
+  }
+  handleRecord(record, capturedAt) {
+    const type = maybeString(record.type);
+    if (!type) {
+      return false;
+    }
+    switch (type) {
+      case "session_meta":
+        this.handleSessionMeta(record, capturedAt);
+        return true;
+      case "turn_context":
+        this.handleTurnContext(record, capturedAt);
+        return true;
+      case "event_msg":
+        this.handleEventMessage(record, capturedAt);
+        return true;
+      case "response_item":
+        this.handleResponseItem(record, capturedAt);
+        return true;
+      case "compacted":
+        return true;
+      default:
+        return false;
+    }
+  }
+  handleSessionMeta(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    let changed = false;
+    const providerMeta = this.ensureProviderMeta();
+    const externalSessionId = maybeString(payload.id);
+    if (externalSessionId && providerMeta.externalSessionId !== externalSessionId) {
+      providerMeta.externalSessionId = externalSessionId;
+      changed = true;
+    }
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      if (!this.session.name || /^\d+$/u.test(this.session.name)) {
+        this.session.name = basename(cwd) || "Codex Session";
+      }
+      changed = true;
+    }
+    const git = isRecord(payload.git) ? payload.git : null;
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "originator", payload.originator) || changed;
+    changed = this.assignObserveString(runtime, "cliVersion", payload.cli_version) || changed;
+    changed = this.assignObserveString(runtime, "source", payload.source) || changed;
+    changed = this.assignObserveString(runtime, "threadSource", payload.thread_source) || changed;
+    changed = this.assignObserveString(runtime, "modelProvider", payload.model_provider) || changed;
+    changed = this.assignObserveString(runtime, "gitBranch", git?.branch) || changed;
+    changed = this.assignObserveString(runtime, "gitCommitHash", git?.commit_hash) || changed;
+    changed = this.assignObserveString(runtime, "repositoryUrl", git?.repository_url) || changed;
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleTurnContext(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    let changed = false;
+    const cwd = maybeString(payload.cwd);
+    if (cwd && this.session.cwd !== cwd) {
+      this.session.cwd = cwd;
+      changed = true;
+    }
+    const model = maybeString(payload.model);
+    if (model && this.session.model !== model) {
+      this.session.model = model;
+      changed = true;
+    }
+    const runtime = this.ensureObserveMetaRecord("observeRuntime");
+    changed = this.assignObserveString(runtime, "approvalPolicy", payload.approval_policy) || changed;
+    changed = this.assignObserveString(runtime, "currentDate", payload.current_date) || changed;
+    changed = this.assignObserveString(runtime, "timezone", payload.timezone) || changed;
+    changed = this.assignObserveString(runtime, "effort", payload.effort) || changed;
+    changed = this.assignObserveString(runtime, "personality", payload.personality) || changed;
+    if (isRecord(payload.sandbox_policy) && runtime.sandboxPolicy !== payload.sandbox_policy) {
+      runtime.sandboxPolicy = payload.sandbox_policy;
+      changed = true;
+    }
+    if (changed) {
+      this.emitSessionUpdate(capturedAt);
+    }
+  }
+  handleEventMessage(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    const eventType = maybeString(payload.type);
+    if (!eventType) {
+      return;
+    }
+    switch (eventType) {
+      case "task_started": {
+        const startedAt = normalizeTimestamp(payload.started_at) ?? capturedAt;
+        this.startTurn(startedAt, maybeString(payload.turn_id));
+        break;
+      }
+      case "user_message":
+        this.ensureTurn(capturedAt);
+        break;
+      case "agent_message": {
+        const message = maybeString(payload.message);
+        if (message) {
+          this.appendCompletedText(capturedAt, message);
+          this.assistantMessageTextThisTurn.add(message);
+        }
+        break;
+      }
+      case "patch_apply_end":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), [maybeString(payload.stdout), maybeString(payload.stderr)].filter(Boolean).join(`
+`), payload.success === false);
+        break;
+      case "token_count":
+        this.captureTokenUsage(payload.info);
+        break;
+      case "task_complete":
+        this.endTurn("completed", normalizeTimestamp(payload.completed_at) ?? capturedAt);
+        break;
+      case "context_compacted":
+      case "web_search_end":
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseItem(record, capturedAt) {
+    const payload = isRecord(record.payload) ? record.payload : {};
+    const itemType = maybeString(payload.type);
+    if (!itemType) {
+      return;
+    }
+    switch (itemType) {
+      case "message":
+        this.handleResponseMessage(payload, capturedAt);
+        break;
+      case "reasoning":
+        this.handleReasoning(payload, capturedAt);
+        break;
+      case "function_call":
+      case "custom_tool_call":
+        this.handleToolCall(payload, capturedAt);
+        break;
+      case "function_call_output":
+      case "custom_tool_call_output":
+        this.handleToolOutput(capturedAt, maybeString(payload.call_id), renderToolResultContent(payload.output), false);
+        break;
+      case "web_search_call":
+        this.handleWebSearchCall(payload, capturedAt);
+        break;
+      default:
+        break;
+    }
+  }
+  handleResponseMessage(payload, capturedAt) {
+    const role = maybeString(payload.role);
+    if (role !== "assistant") {
+      return;
+    }
+    const text = renderContentPartsText(payload.content).trim();
+    if (!text || this.assistantMessageTextThisTurn.has(text)) {
+      return;
+    }
+    this.appendCompletedText(capturedAt, text);
+    this.assistantMessageTextThisTurn.add(text);
+  }
+  handleReasoning(payload, capturedAt) {
+    const text = extractReasoningText(payload);
+    if (!text) {
+      return;
+    }
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "reasoning",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  handleToolCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolName = maybeString(payload.name) ?? "unknown";
+    const toolCallId = maybeString(payload.call_id) ?? `${turn.id}:tool:${this.blockIndex}`;
+    const input = this.parseToolInput(payload.arguments ?? payload.input);
+    const action = this.buildAction(toolName, toolCallId, input);
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "streaming"
+    });
+    this.toolBlockMap.set(toolCallId, block.id);
+  }
+  handleWebSearchCall(payload, capturedAt) {
+    const turn = this.ensureTurn(capturedAt);
+    const toolCallId = `${turn.id}:web-search:${this.blockIndex}`;
+    const action = {
+      kind: "tool_call",
+      toolName: "web_search",
+      toolCallId,
+      input: payload.action,
+      result: payload.status,
+      status: maybeString(payload.status) === "failed" ? "failed" : "completed",
+      output: ""
+    };
+    const block = this.startBlock(turn, capturedAt, {
+      id: `${turn.id}:action:${toolCallId}`,
+      type: "action",
+      action,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  parseToolInput(value) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return "";
+    }
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  buildAction(toolName, toolCallId, input) {
+    const inputRecord = isRecord(input) ? input : {};
+    if (toolName === "exec_command") {
+      return {
+        kind: "command",
+        command: maybeString(inputRecord.cmd) ?? "",
+        status: "running",
+        output: ""
+      };
+    }
+    return {
+      kind: "tool_call",
+      toolName,
+      toolCallId,
+      input,
+      status: "running",
+      output: ""
+    };
+  }
+  handleToolOutput(capturedAt, toolCallId, output, isError) {
+    if (!toolCallId) {
+      return;
+    }
+    const blockId = this.toolBlockMap.get(toolCallId);
+    const turn = this.currentTurn;
+    if (!blockId || !turn) {
+      return;
+    }
+    if (output) {
+      this.emitEvent(capturedAt, {
+        event: "block:action:output",
+        sessionId: this.session.id,
+        turnId: turn.id,
+        blockId,
+        output
+      });
+    }
+    const exitCode = this.extractExitCode(output);
+    const status = isError || exitCode != null && exitCode !== 0 ? "failed" : "completed";
+    this.emitEvent(capturedAt, {
+      event: "block:action:status",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId,
+      status,
+      ...exitCode != null ? { meta: { exitCode } } : {}
+    });
+    const block = this.blockById.get(blockId);
+    if (block) {
+      this.emitBlockEnd(capturedAt, turn, block, status === "failed" ? "failed" : "completed");
+    }
+    this.toolBlockMap.delete(toolCallId);
+  }
+  extractExitCode(output) {
+    const match = output.match(/(?:exit code|exited with code):\s*(-?\d+)/iu);
+    if (!match) {
+      return null;
+    }
+    const exitCode = Number(match[1]);
+    return Number.isFinite(exitCode) ? exitCode : null;
+  }
+  captureTokenUsage(info) {
+    if (!isRecord(info)) {
+      return;
+    }
+    const total = isRecord(info.total_token_usage) ? info.total_token_usage : {};
+    this.inputTokens = maybeNumber(total.input_tokens) ?? this.inputTokens;
+    this.outputTokens = maybeNumber(total.output_tokens) ?? this.outputTokens;
+    this.reasoningOutputTokens = maybeNumber(total.reasoning_output_tokens) ?? this.reasoningOutputTokens;
+    this.cachedInputTokens = maybeNumber(total.cached_input_tokens) ?? this.cachedInputTokens;
+    this.tokenEventCount += 1;
+  }
+  persistUsageMetadata() {
+    if (this.tokenEventCount === 0) {
+      return false;
+    }
+    const usage = this.ensureObserveMetaRecord("observeUsage");
+    let changed = false;
+    const assignNumber = (key, value) => {
+      if (value > 0 && usage[key] !== value) {
+        usage[key] = value;
+        changed = true;
+      }
+    };
+    assignNumber("inputTokens", this.inputTokens);
+    assignNumber("outputTokens", this.outputTokens);
+    assignNumber("reasoningOutputTokens", this.reasoningOutputTokens);
+    assignNumber("cacheReadInputTokens", this.cachedInputTokens);
+    assignNumber("tokenEvents", this.tokenEventCount);
+    return changed;
+  }
+  startTurn(capturedAt, turnId) {
+    if (this.currentTurn) {
+      this.endTurn("stopped", capturedAt);
+    }
+    this.turnCounter += 1;
+    this.blockIndex = 0;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "active";
+    this.emitSessionUpdate(capturedAt);
+    const turn = {
+      id: turnId || `history-turn-${this.turnCounter}`,
+      sessionId: this.session.id,
+      status: "started",
+      startedAt: new Date(capturedAt).toISOString(),
+      blocks: []
+    };
+    this.currentTurn = turn;
+    this.emitEvent(capturedAt, {
+      event: "turn:start",
+      sessionId: this.session.id,
+      turn
+    });
+    return turn;
+  }
+  ensureTurn(capturedAt) {
+    return this.currentTurn ?? this.startTurn(capturedAt);
+  }
+  endTurn(status, capturedAt) {
+    const turn = this.currentTurn;
+    if (!turn) {
+      return;
+    }
+    turn.status = status;
+    turn.endedAt = new Date(capturedAt).toISOString();
+    this.emitEvent(capturedAt, {
+      event: "turn:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      status
+    });
+    this.currentTurn = null;
+    this.blockById.clear();
+    this.toolBlockMap.clear();
+    this.assistantMessageTextThisTurn.clear();
+    this.session.status = "idle";
+    this.emitSessionUpdate(capturedAt);
+  }
+  appendCompletedText(capturedAt, text) {
+    const turn = this.ensureTurn(capturedAt);
+    const block = this.startBlock(turn, capturedAt, {
+      type: "text",
+      text,
+      status: "completed"
+    });
+    this.emitBlockEnd(capturedAt, turn, block, "completed");
+  }
+  startBlock(turn, capturedAt, partial) {
+    const block = {
+      ...partial,
+      id: partial.id || `${turn.id}:block:${this.blockIndex}`,
+      turnId: turn.id,
+      index: this.blockIndex
+    };
+    this.blockIndex += 1;
+    turn.blocks.push(block);
+    this.blockById.set(block.id, block);
+    this.emitEvent(capturedAt, {
+      event: "block:start",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      block
+    });
+    return block;
+  }
+  emitBlockEnd(capturedAt, turn, block, status) {
+    block.status = status;
+    this.emitEvent(capturedAt, {
+      event: "block:end",
+      sessionId: this.session.id,
+      turnId: turn.id,
+      blockId: block.id,
+      status
+    });
+  }
+  ensureProviderMeta() {
+    const providerMeta = isRecord(this.session.providerMeta) ? this.session.providerMeta : {};
+    this.session.providerMeta = providerMeta;
+    return providerMeta;
+  }
+  ensureObserveMetaRecord(key) {
+    const providerMeta = this.ensureProviderMeta();
+    const existing = providerMeta[key];
+    if (isRecord(existing)) {
+      return existing;
+    }
+    const next = {};
+    providerMeta[key] = next;
+    return next;
+  }
+  assignObserveString(target, key, value) {
+    const next = maybeString(value);
+    if (!next || target[key] === next) {
+      return false;
+    }
+    target[key] = next;
+    return true;
+  }
+  emitSessionUpdate(capturedAt) {
+    this.emitEvent(capturedAt, {
+      event: "session:update",
+      session: { ...this.session }
+    });
+  }
+  emitEvent(capturedAt, event) {
+    this.events.push({
+      capturedAt,
+      event: structuredClone(event)
+    });
+  }
+}
 function inferHistorySessionAdapterType(path2, adapterType) {
   return inferHistoryAdapterType(path2, adapterType);
 }
 function supportsHistorySessionSnapshotForPath(path2, adapterType) {
-  return inferHistoryAdapterType(path2, adapterType) === "claude-code";
+  const inferred = inferHistoryAdapterType(path2, adapterType);
+  return inferred === "claude-code" || inferred === "codex";
 }
 function createHistorySessionSnapshot(input) {
   const adapterType = inferHistoryAdapterType(input.path, input.adapterType);
-  if (adapterType !== "claude-code") {
+  if (adapterType !== "claude-code" && adapterType !== "codex") {
     throw new Error(`History snapshot is not supported for adapter type "${adapterType}".`);
   }
   const session = buildBaseHistorySession(input, adapterType);
   const baseTimestampMs = normalizeTimestamp(input.baseTimestampMs) ?? Date.now();
-  const parser = new ClaudeCodeHistoryParser(session, baseTimestampMs);
+  const parser = adapterType === "codex" ? new CodexHistoryParser(session, baseTimestampMs) : new ClaudeCodeHistoryParser(session, baseTimestampMs);
   const replay = parser.parse(input.content);
   const tracker = new StateTracker;
   tracker.createSession(session.id, session);
@@ -3334,7 +3887,7 @@ function stringifyValue(value) {
     return String(value);
   }
 }
-function extractReasoningText(item) {
+function extractReasoningText2(item) {
   const summary = Array.isArray(item.summary) ? item.summary : [];
   const content = Array.isArray(item.content) ? item.content : [];
   const summaryText = summary.map((entry) => {
@@ -3810,7 +4363,7 @@ var init_codex = __esm(() => {
           this.ensureTextBlock(turnState, itemId, typeof item.text === "string" ? item.text : "");
           return;
         case "reasoning": {
-          const text = extractReasoningText(item);
+          const text = extractReasoningText2(item);
           if (text) {
             this.ensureReasoningBlock(turnState, itemId, text);
           }
@@ -3889,7 +4442,7 @@ var init_codex = __esm(() => {
           return;
         }
         case "reasoning": {
-          const finalText = extractReasoningText(item);
+          const finalText = extractReasoningText2(item);
           if (!finalText && !turnState.blocksByItemId.has(itemId)) {
             return;
           }
@@ -7813,6 +8366,25 @@ function buildScoutReturnAddress(input) {
   }
   return next;
 }
+// ../protocol/src/channel-identity.ts
+function mintChannelId(randomUuid) {
+  return `${CHANNEL_ID_PREFIX}${randomUuid().toLowerCase()}`;
+}
+function directChannelNaturalKey(participantIds) {
+  return `direct:${stableIdentityParts(participantIds).join(",")}`;
+}
+function channelNaturalKeyFromMetadata(metadata) {
+  const value = metadata?.[CHANNEL_NATURAL_KEY_METADATA];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stableIdentityParts(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean))).sort().map(encodeIdentityPart);
+}
+function encodeIdentityPart(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+var CHANNEL_ID_PREFIX = "c.", CHANNEL_NATURAL_KEY_METADATA = "naturalKey";
+
 // ../protocol/src/collaboration.ts
 function isQuestionTerminalState(state) {
   return state === "closed" || state === "declined";
@@ -7996,6 +8568,17 @@ function assertValidUnblockRequestEvent(event, record) {
     throw new Error(errors.join("; "));
   }
 }
+// ../protocol/src/lifecycle.ts
+var TERMINAL_INVOCATION_STATES;
+var init_lifecycle = __esm(() => {
+  TERMINAL_INVOCATION_STATES = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "expired"
+  ]);
+});
+
 // ../protocol/src/permission-policy.ts
 function normalizeScoutPermissionProfile(value) {
   const normalized = value?.trim().replaceAll("-", "_");
@@ -8048,15 +8631,20 @@ var init_scout_composer = __esm(() => {
 });
 // ../protocol/src/inbox.ts
 var init_inbox = () => {};
+// ../protocol/src/cursor-transport.ts
+var init_cursor_transport = () => {};
+
 // ../protocol/src/index.ts
 var init_src2 = __esm(() => {
   init_agent_identity();
   init_agent_address();
   init_agent_selectors();
+  init_lifecycle();
   init_agent_runs();
   init_scout_composer();
   init_inbox();
   init_permission_policy();
+  init_cursor_transport();
 });
 
 // ../runtime/src/user-project-hints.ts
@@ -10231,6 +10819,9 @@ var init_setup = __esm(() => {
   };
 });
 
+// ../runtime/src/dispatch-stalled.ts
+var init_dispatch_stalled = () => {};
+
 // ../runtime/src/managed-agent-environment.ts
 function managedAgentEnvironmentEntries(options) {
   const agentName = options.agentName.trim();
@@ -11023,6 +11614,15 @@ function readCodexAppServerReasoningEffortFromLaunchArgs(launchArgs) {
   }
   return null;
 }
+function codexAppServerExitMessage(input) {
+  if (input.exitKind === "proactive_shutdown") {
+    return `Codex app-server session for ${input.agentName} was stopped by OpenScout` + (input.reason ? `: ${input.reason}` : "") + ".";
+  }
+  if (input.exitKind === "external_sigterm") {
+    return `Codex app-server for ${input.agentName} was interrupted by SIGTERM.`;
+  }
+  return `Codex app-server exited for ${input.agentName}` + (input.exitCode !== null ? ` with code ${input.exitCode}` : "") + (input.signal ? ` (${input.signal})` : "");
+}
 function resolveRequesterTimeoutMs2(timeoutMs) {
   if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
     return timeoutMs;
@@ -11194,6 +11794,7 @@ class CodexAppServerSession {
   activeTurn = null;
   threadId = null;
   threadPath = null;
+  proactiveShutdown = null;
   lastConfigSignature;
   constructor(options) {
     this.options = options;
@@ -11324,13 +11925,23 @@ class CodexAppServerSession {
     });
   }
   async shutdown(options = {}) {
+    this.proactiveShutdown = {
+      reason: options.reason ?? (options.resetThread ? "OpenScout reset the app-server session" : "OpenScout stopped the app-server session")
+    };
+    const stoppedError = new CodexAppServerExitError({
+      agentName: this.options.agentName,
+      exitKind: "proactive_shutdown",
+      exitCode: null,
+      signal: null,
+      reason: this.proactiveShutdown.reason
+    });
     const activeTurn = this.activeTurn;
     this.activeTurn = null;
     if (activeTurn) {
-      activeTurn.reject(new Error(`Codex app-server session for ${this.options.agentName} was shut down.`));
+      activeTurn.reject(stoppedError);
     }
     for (const pending of this.pendingRequests.values()) {
-      pending.reject(new Error(`Codex app-server session for ${this.options.agentName} was shut down.`));
+      pending.reject(stoppedError);
     }
     this.pendingRequests.clear();
     const child = this.process;
@@ -11340,7 +11951,7 @@ class CodexAppServerSession {
     if (child && child.exitCode === null && !child.killed) {
       child.kill("SIGTERM");
       await new Promise((resolve5) => setTimeout(resolve5, 250));
-      if (child.exitCode === null && !child.killed) {
+      if (child.exitCode === null && child.signalCode === null) {
         child.kill("SIGKILL");
       }
     }
@@ -11391,6 +12002,7 @@ class CodexAppServerSession {
     await mkdir5(this.options.runtimeDirectory, { recursive: true });
     await mkdir5(this.options.logsDirectory, { recursive: true });
     await writeFile5(join17(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    this.proactiveShutdown = null;
     const codexExecutable = resolveCodexExecutable();
     const launchArgs = normalizeCodexAppServerLaunchArgs(this.options.launchArgs);
     const env = buildManagedAgentEnvironment({
@@ -11430,7 +12042,16 @@ class CodexAppServerSession {
       this.failSession(new Error(`Codex app-server failed for ${this.options.agentName}: ${errorMessage3(error)}`));
     });
     child.once("exit", (code, signal) => {
-      this.failSession(new Error(`Codex app-server exited for ${this.options.agentName}` + (code !== null ? ` with code ${code}` : "") + (signal ? ` (${signal})` : "")));
+      const proactiveShutdown = this.proactiveShutdown;
+      if (proactiveShutdown) {
+        this.handleProactiveProcessExit(child, proactiveShutdown, code, signal);
+        return;
+      }
+      this.failSession(new CodexAppServerExitError({
+        agentName: this.options.agentName,
+        exitCode: code,
+        signal
+      }));
     });
     await this.request("initialize", {
       clientInfo: {
@@ -11765,6 +12386,23 @@ class CodexAppServerSession {
     }
     this.pendingRequests.clear();
     appendFile3(this.stderrLogPath, `[openscout] ${error.message}
+`).catch(() => {
+      return;
+    });
+    this.persistState();
+  }
+  handleProactiveProcessExit(child, shutdown, code, signal) {
+    if (this.process === child) {
+      this.process = null;
+    }
+    this.proactiveShutdown = null;
+    this.starting = null;
+    const exitDetail = [
+      code !== null ? `code ${code}` : null,
+      signal
+    ].filter(Boolean).join(", ");
+    const detail = exitDetail ? ` (${exitDetail})` : "";
+    appendFile3(this.stderrLogPath, `[openscout] Codex app-server stopped for ${this.options.agentName}: ${shutdown.reason}${detail}
 `).catch(() => {
       return;
     });
@@ -11835,7 +12473,10 @@ function getOrCreateSession2(options) {
     if (existing.matches(options)) {
       return existing;
     }
-    existing.shutdown({ resetThread: true });
+    existing.shutdown({
+      resetThread: true,
+      reason: "OpenScout replaced the app-server session after its launch options changed"
+    });
     sessions2.delete(key);
   }
   const session = new CodexAppServerSession(options);
@@ -11866,13 +12507,36 @@ async function shutdownCodexAppServerAgent(options, shutdownOptions = {}) {
   sessions2.delete(key);
   await session.shutdown(shutdownOptions);
 }
-var SESSION_CATALOG_FILENAME2 = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES2 = 64, CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS, sessions2;
+var CodexAppServerExitError, SESSION_CATALOG_FILENAME2 = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES2 = 64, CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS, sessions2;
 var init_codex_app_server = __esm(() => {
   init_src();
   init_topology();
   init_codex_executable();
   init_requester_timeout();
   init_codex_executable();
+  CodexAppServerExitError = class CodexAppServerExitError extends Error {
+    code = "CODEX_APP_SERVER_EXIT";
+    exitKind;
+    agentName;
+    exitCode;
+    signal;
+    reason;
+    noteworthy;
+    constructor(input) {
+      const exitKind = input.exitKind ?? (input.signal === "SIGTERM" ? "external_sigterm" : "unexpected_exit");
+      super(codexAppServerExitMessage({
+        ...input,
+        exitKind
+      }));
+      this.name = "CodexAppServerExitError";
+      this.exitKind = exitKind;
+      this.agentName = input.agentName;
+      this.exitCode = input.exitCode;
+      this.signal = input.signal;
+      this.reason = input.reason ?? null;
+      this.noteworthy = exitKind !== "unexpected_exit";
+    }
+  };
   CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS = 10 * 60 * 1000;
   sessions2 = new Map;
 });
@@ -12499,6 +13163,17 @@ async function fetchHealthSnapshot(config) {
         nodes: payload.counts.nodes ?? 0,
         actors: payload.counts.actors ?? 0,
         agents: payload.counts.agents ?? 0,
+        agentRecords: payload.counts.agentRecords,
+        rawAgentRecords: payload.counts.rawAgentRecords,
+        configuredAgents: payload.counts.configuredAgents,
+        scoutManagedAgents: payload.counts.scoutManagedAgents,
+        currentAgentRegistrations: payload.counts.currentAgentRegistrations,
+        localAgentRegistrations: payload.counts.localAgentRegistrations,
+        remoteAgentRegistrations: payload.counts.remoteAgentRegistrations,
+        staleAgentRegistrations: payload.counts.staleAgentRegistrations,
+        retiredAgentRegistrations: payload.counts.retiredAgentRegistrations,
+        oneTimeAgentCards: payload.counts.oneTimeAgentCards,
+        persistentAgentCards: payload.counts.persistentAgentCards,
         conversations: payload.counts.conversations ?? 0,
         messages: payload.counts.messages ?? 0,
         flights: payload.counts.flights ?? 0,
@@ -12736,11 +13411,37 @@ var init_permission_policy2 = __esm(() => {
   init_src2();
 });
 
+// ../runtime/src/user-config.ts
+import { existsSync as existsSync16, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync9 } from "fs";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname9, join as join19 } from "path";
+function userConfigPath() {
+  return join19(process.env.OPENSCOUT_HOME ?? join19(homedir18(), ".openscout"), "user.json");
+}
+function loadUserConfig() {
+  const configPath = userConfigPath();
+  if (!existsSync16(configPath))
+    return {};
+  try {
+    return JSON.parse(readFileSync10(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function normalizeHandle(value) {
+  return value?.trim().replace(/^@+/, "") ?? "";
+}
+function resolveOperatorHandle() {
+  const config = loadUserConfig();
+  return normalizeHandle(config.handle) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_HANDLE) || normalizeHandle(config.name) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_NAME) || normalizeHandle(process.env.USER) || "operator";
+}
+var init_user_config = () => {};
+
 // ../runtime/src/local-agents.ts
 import { execFileSync as execFileSync4, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename8, dirname as dirname9, join as join19, resolve as resolve6 } from "path";
+import { basename as basename8, dirname as dirname10, join as join20, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function resolveRelayHub() {
   return resolveOpenScoutSupportPaths().relayHubDirectory;
@@ -12751,14 +13452,14 @@ function resolveProjectsRoot(projectPath) {
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync16(supportPaths.settingsPath)) {
-      return dirname9(projectPath);
+    if (!existsSync17(supportPaths.settingsPath)) {
+      return dirname10(projectPath);
     }
-    const raw = JSON.parse(readFileSync10(supportPaths.settingsPath, "utf8"));
+    const raw = JSON.parse(readFileSync11(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve6(workspaceRoot) : dirname9(projectPath);
+    return workspaceRoot ? resolve6(workspaceRoot) : dirname10(projectPath);
   } catch {
-    return dirname9(projectPath);
+    return dirname10(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -12768,7 +13469,7 @@ function nowSeconds2() {
   return Math.floor(Date.now() / 1000);
 }
 function scoutCliPath() {
-  return join19(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
+  return join20(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
 }
 function legacyNodeBrokerRelayCommand() {
   return `node ${JSON.stringify(scoutCliPath())}`;
@@ -12781,13 +13482,13 @@ function titleCaseLocalAgentName(value) {
 }
 function resolveScoutSkillPath() {
   const candidatePaths = [
-    join19(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
-    join19(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
-    join19(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
-    join19(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
+    join20(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
+    join20(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
+    join20(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
+    join20(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
   ];
   for (const path2 of candidatePaths) {
-    if (existsSync16(path2)) {
+    if (existsSync17(path2)) {
       return path2;
     }
   }
@@ -12895,6 +13596,74 @@ function buildLocalAgentSystemPromptTemplate() {
   ].join(`
 `);
 }
+function normalizeOperatorHandleSegment(value) {
+  return normalizeAgentSelectorSegment(value?.trim().replace(/^@+/, "") ?? "") || "operator";
+}
+function resolveOperatorAugmentAgentName() {
+  return `${normalizeOperatorHandleSegment(resolveOperatorHandle())}-ai`;
+}
+function operatorAugmentAgentNameCandidates() {
+  return new Set([
+    resolveOperatorAugmentAgentName(),
+    "operator-ai"
+  ]);
+}
+function buildOperatorAugmentSystemPromptTemplate(input = {}) {
+  const operatorHandle = normalizeOperatorHandleSegment(input.operatorHandle ?? resolveOperatorHandle());
+  const augmentHandle = normalizeOperatorHandleSegment(input.augmentHandle ?? `${operatorHandle}-ai`);
+  const humanLabel = `@${operatorHandle}`;
+  const augmentLabel = `@${augmentHandle}`;
+  return [
+    "{{base_prompt}}",
+    "",
+    `You are the augmented counterpart to the human Scout operator ${humanLabel}.`,
+    `${humanLabel} is the human. ${augmentLabel} is the AI-augmented looper with a human in the loop.`,
+    `Do not impersonate ${humanLabel}. Speak and act as ${augmentLabel}, and involve ${humanLabel} only when human judgment or approval is the real next dependency.`,
+    "",
+    "Operating loop:",
+    "  - Keep long-running conversations in the same DM or invocation thread whenever possible.",
+    "  - Maintain continuity across turns: track the goal, decisions made, open questions, blockers, and promised follow-ups.",
+    "  - For efforts that span many turns, many files, or more than one working session, create or update a durable note/checkpoint when you have write access, then point to it briefly.",
+    "  - Prefer continuing from a concise recap over resetting context. If context is aging, summarize the useful state and keep moving.",
+    `  - Be explicit about the next responsible owner: ${augmentLabel}, ${humanLabel}, or another named agent.`,
+    "",
+    `When to invoke ${humanLabel}:`,
+    "  - Approval is needed for destructive, irreversible, public, financial, security-sensitive, credential, privacy, or cross-project priority decisions.",
+    `  - The task depends on taste, intent, product direction, personal context, or a choice only ${humanLabel} can make.`,
+    "  - You are blocked after a reasonable local attempt and the unblock request can be stated as a short concrete question.",
+    "  - A result is materially uncertain and acting without human input could waste meaningful time or create cleanup work.",
+    "  - You need permission to interrupt, wake, or redirect other people or agents outside the current work venue.",
+    "",
+    `How to invoke ${humanLabel}:`,
+    "  - Keep the ask concise: context, the decision needed, the default you recommend, and the consequence of no answer.",
+    "  - Use the same DM/thread when it exists. Do not broadcast human-loop requests.",
+    `  - If a reply is required before work can proceed, say that ${humanLabel} owns the next move and stop claiming progress.`,
+    "  - If work can continue safely, state the assumption and continue without waiting.",
+    "",
+    `Do not invoke ${humanLabel} for:`,
+    "  - Routine status updates, obvious implementation details, command outputs, local orientation, or reversible low-risk cleanup.",
+    "  - Ambiguity that you can resolve by reading the repo, checking Scout state, or asking the correct specialist agent.",
+    "",
+    "{{project_context}}",
+    "",
+    "{{collaboration_prompt}}",
+    "",
+    "{{protocol_prompt}}"
+  ].join(`
+`);
+}
+function operatorAugmentDefaultsForDefinitionId(definitionId) {
+  const normalizedDefinitionId = normalizeAgentSelectorSegment(definitionId);
+  if (!normalizedDefinitionId || !operatorAugmentAgentNameCandidates().has(normalizedDefinitionId)) {
+    return null;
+  }
+  return {
+    displayName: titleCaseLocalAgentName(normalizedDefinitionId),
+    systemPrompt: buildOperatorAugmentSystemPromptTemplate({
+      augmentHandle: normalizedDefinitionId
+    })
+  };
+}
 function renderLocalAgentSystemPromptTemplate(template, context, options = {}) {
   const basePrompt = buildLocalAgentBasePrompt(context);
   const projectContext = buildLocalAgentProjectContextPrompt(context);
@@ -13049,13 +13818,20 @@ function expandHomePath4(value) {
     return process.env.HOME ?? process.cwd();
   }
   if (value.startsWith("~/")) {
-    return join19(process.env.HOME ?? process.cwd(), value.slice(2));
+    return join20(process.env.HOME ?? process.cwd(), value.slice(2));
   }
   return value;
 }
 function normalizeProjectPath(value) {
   return resolve6(expandHomePath4(value.trim() || "."));
 }
+function compactHomePath(value) {
+  const home = process.env.HOME;
+  if (!home) {
+    return value;
+  }
+  return value.startsWith(home) ? value.replace(home, "~") : value;
+}
 function normalizeTmuxSessionName2(value, agentId) {
   const fallback = `relay-${agentId}`;
   const trimmed = value?.trim() ?? "";
@@ -13309,6 +14085,21 @@ function applyRequestedRuntimeOptionsToLaunchArgs(harness, launchArgs, options)
     ...buildLaunchArgsForRequestedReasoningEffort(harness, requestedReasoningEffort)
   ];
 }
+function setLaunchModelForHarness(harness, launchArgs, model) {
+  const normalized = normalizeLaunchArgsForHarness(harness, launchArgs);
+  if (model === undefined) {
+    return normalized;
+  }
+  const stripped = stripLaunchModelForHarness(harness, normalized);
+  const requestedModel = normalizeRequestedModel(model ?? undefined);
+  if (!requestedModel) {
+    return stripped;
+  }
+  return [
+    ...stripped,
+    ...buildLaunchArgsForRequestedModel(harness, requestedModel)
+  ];
+}
 function defaultHarnessForOverride(override, fallback = "claude") {
   return normalizeManagedHarness2(override.defaultHarness ?? override.runtime?.harness, fallback);
 }
@@ -13429,6 +14220,31 @@ function recordForHarness(record, harnessOverride) {
     permissionProfile: profile.permissionProfile
   };
 }
+function normalizeCardTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : undefined;
+}
+function normalizeLocalAgentCardLifecycle(value, now = Date.now()) {
+  if (!value) {
+    return;
+  }
+  const kind = value.kind === "one_time" ? "one_time" : value.kind === "persistent" ? "persistent" : undefined;
+  if (!kind) {
+    return;
+  }
+  const createdAt = normalizeCardTimestamp(value.createdAt) ?? now;
+  const expiresAt = normalizeCardTimestamp(value.expiresAt);
+  const maxUses = typeof value.maxUses === "number" && Number.isFinite(value.maxUses) && value.maxUses > 0 ? Math.floor(value.maxUses) : undefined;
+  const createdById = value.createdById?.trim();
+  const inboxConversationId = value.inboxConversationId?.trim();
+  return {
+    kind,
+    createdAt,
+    ...createdById ? { createdById } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...maxUses ? { maxUses } : {},
+    ...inboxConversationId ? { inboxConversationId } : {}
+  };
+}
 function normalizeLocalAgentRecord(agentId, record) {
   const cwd = normalizeProjectPath(record.cwd || process.cwd());
   const projectRoot = normalizeProjectPath(record.projectRoot || cwd);
@@ -13458,7 +14274,8 @@ function normalizeLocalAgentRecord(agentId, record) {
     capabilities: normalizeLocalAgentCapabilities(record.capabilities),
     launchArgs: activeProfile?.launchArgs ?? normalizeLaunchArgsForHarness(harness, record.launchArgs),
     permissionProfile: activeProfile?.permissionProfile ?? record.permissionProfile,
-    registrationSource: record.registrationSource
+    registrationSource: record.registrationSource,
+    card: normalizeLocalAgentCardLifecycle(record.card)
   };
 }
 function localAgentStatusFromRecord(agentId, record, source) {
@@ -13512,7 +14329,8 @@ function localAgentRecordFromRelayAgentOverride(agentId, override) {
     harnessProfiles: override.harnessProfiles,
     transport: normalizeLocalAgentTransport(override.runtime?.transport, normalizeLocalAgentHarness(override.runtime?.harness)),
     capabilities: override.capabilities,
-    launchArgs: override.launchArgs
+    launchArgs: override.launchArgs,
+    card: override.card
   });
 }
 function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
@@ -13533,6 +14351,7 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
     capabilities: normalizeLocalAgentCapabilities(normalizedRecord.capabilities),
     defaultHarness: normalizeManagedHarness2(normalizedRecord.defaultHarness, "claude"),
     harnessProfiles: normalizedRecord.harnessProfiles,
+    ...normalizedRecord.card ? { card: normalizedRecord.card } : {},
     runtime: {
       cwd: normalizeProjectPath(normalizedRecord.cwd),
       harness: normalizeLocalAgentHarness(normalizedRecord.harness),
@@ -13542,6 +14361,245 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
     }
   };
 }
+function buildLocalAgentConfigState(agentId, record) {
+  const harness = normalizeLocalAgentHarness(record.harness);
+  const launchArgs = normalizeLaunchArgsForHarness(harness, record.launchArgs);
+  return {
+    agentId,
+    editable: true,
+    model: readLaunchModelForHarness(harness, launchArgs) ?? null,
+    permissionProfile: record.permissionProfile ?? null,
+    systemPrompt: record.systemPrompt || buildLocalAgentSystemPromptTemplate(),
+    runtime: {
+      cwd: compactHomePath(record.cwd),
+      harness,
+      transport: normalizeLocalAgentTransport(record.transport, harness),
+      sessionId: record.tmuxSession,
+      wakePolicy: "on_demand"
+    },
+    launchArgs,
+    capabilities: normalizeLocalAgentCapabilities(record.capabilities),
+    applyMode: "restart",
+    templateHint: LOCAL_AGENT_SYSTEM_PROMPT_TEMPLATE_HINT
+  };
+}
+async function assertDirectoryExists(directory) {
+  const stats = await stat3(directory);
+  if (!stats.isDirectory()) {
+    throw new Error(`${directory} is not a directory.`);
+  }
+}
+async function resolveConfiguredLocalAgentRecord(agentId) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (override) {
+    return localAgentRecordFromRelayAgentOverride(agentId, override);
+  }
+  const registry = await readLocalAgentRegistry();
+  const record = registry[agentId];
+  return record ? normalizeLocalAgentRecord(agentId, record) : null;
+}
+async function getLocalAgentConfig(agentId) {
+  const record = await resolveConfiguredLocalAgentRecord(agentId);
+  if (!record) {
+    return null;
+  }
+  return buildLocalAgentConfigState(agentId, record);
+}
+function defaultLocalAgentSessionId(agentId, harness) {
+  return normalizeTmuxSessionName2(undefined, `${agentId}-${harness}`);
+}
+async function updateLocalAgentCard(agentId, input) {
+  const existing = await getLocalAgentConfig(agentId);
+  if (!existing) {
+    return null;
+  }
+  const nextHarness = input.harness ? normalizeLocalAgentHarness(input.harness) : existing.runtime.harness;
+  const harnessChanged = nextHarness !== existing.runtime.harness;
+  const model = input.model === undefined ? harnessChanged ? null : undefined : input.model;
+  return updateLocalAgentConfig(agentId, {
+    runtime: {
+      cwd: existing.runtime.cwd,
+      harness: nextHarness,
+      transport: harnessChanged ? normalizeLocalAgentTransport(undefined, nextHarness) : existing.runtime.transport,
+      sessionId: harnessChanged ? defaultLocalAgentSessionId(agentId, nextHarness) : existing.runtime.sessionId
+    },
+    systemPrompt: existing.systemPrompt,
+    launchArgs: harnessChanged ? [] : existing.launchArgs,
+    model,
+    reasoningEffort: input.reasoningEffort,
+    permissionProfile: input.permissionProfile,
+    capabilities: existing.capabilities
+  });
+}
+async function updateLocalAgentConfig(agentId, input) {
+  const [registry, overrides] = await Promise.all([
+    readLocalAgentRegistry(),
+    readRelayAgentOverrides()
+  ]);
+  const record = registry[agentId] ?? (overrides[agentId] ? localAgentRecordFromRelayAgentOverride(agentId, overrides[agentId]) : undefined);
+  if (!record) {
+    return null;
+  }
+  const cwd = normalizeProjectPath(input.runtime.cwd || record.cwd);
+  await assertDirectoryExists(cwd);
+  const nextHarness = normalizeLocalAgentHarness(input.runtime.harness);
+  const nextTransport = normalizeLocalAgentTransport(input.runtime.transport ?? record.transport, nextHarness);
+  let nextLaunchArgs = setLaunchModelForHarness(nextHarness, input.launchArgs, input.model);
+  if (input.reasoningEffort !== undefined) {
+    const stripped = stripLaunchReasoningEffortForHarness(nextHarness, nextLaunchArgs);
+    const requestedReasoningEffort = normalizeRequestedReasoningEffort(input.reasoningEffort ?? undefined);
+    nextLaunchArgs = requestedReasoningEffort ? [
+      ...stripped,
+      ...buildLaunchArgsForRequestedReasoningEffort(nextHarness, requestedReasoningEffort)
+    ] : stripped;
+  }
+  const nextPermissionProfile = input.permissionProfile === undefined ? record.permissionProfile : input.permissionProfile === null ? undefined : parseScoutPermissionProfile(input.permissionProfile);
+  const nextRecord = normalizeLocalAgentRecord(agentId, {
+    ...record,
+    cwd,
+    tmuxSession: input.runtime.sessionId,
+    harness: nextHarness,
+    defaultHarness: nextHarness,
+    harnessProfiles: {
+      ...record.harnessProfiles ?? {},
+      [normalizeManagedHarness2(input.runtime.harness, "claude")]: {
+        cwd,
+        transport: nextTransport,
+        sessionId: normalizeTmuxSessionName2(input.runtime.sessionId, `${agentId}-${normalizeManagedHarness2(input.runtime.harness, "claude")}`),
+        launchArgs: nextLaunchArgs,
+        ...nextPermissionProfile ? { permissionProfile: nextPermissionProfile } : {}
+      }
+    },
+    transport: nextTransport,
+    systemPrompt: input.systemPrompt.trim() || undefined,
+    launchArgs: nextLaunchArgs,
+    permissionProfile: nextPermissionProfile,
+    capabilities: input.capabilities
+  });
+  registry[agentId] = nextRecord;
+  await writeLocalAgentRegistry(registry);
+  return buildLocalAgentConfigState(agentId, nextRecord);
+}
+async function updateLocalAgentCardLifecycle(agentId, input) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (!override) {
+    return null;
+  }
+  const lifecycle2 = normalizeLocalAgentCardLifecycle({
+    ...override.card ?? {},
+    ...input
+  });
+  if (!lifecycle2) {
+    return null;
+  }
+  overrides[agentId] = {
+    ...override,
+    card: lifecycle2
+  };
+  await writeRelayAgentOverrides(overrides);
+  return lifecycle2;
+}
+function oneTimeCardCreatedAt(lifecycle2) {
+  return normalizeCardTimestamp(lifecycle2.createdAt) ?? 0;
+}
+function shouldPruneOneTimeCard(lifecycle2, now, maxAgeMs) {
+  if (lifecycle2.kind !== "one_time") {
+    return false;
+  }
+  if (lifecycle2.expiresAt !== undefined && lifecycle2.expiresAt <= now) {
+    return true;
+  }
+  const createdAt = oneTimeCardCreatedAt(lifecycle2);
+  return createdAt > 0 && createdAt + maxAgeMs <= now;
+}
+function oneTimeCardMatchesScope(agentId, override, input) {
+  if (BUILT_IN_AGENT_DEFINITION_IDS.has(agentId)) {
+    return false;
+  }
+  const lifecycle2 = normalizeLocalAgentCardLifecycle(override.card);
+  if (lifecycle2?.kind !== "one_time") {
+    return false;
+  }
+  if (input.createdById?.trim() && lifecycle2.createdById !== input.createdById.trim()) {
+    return false;
+  }
+  if (input.projectRoot?.trim()) {
+    const scopedRoot = normalizeProjectPath(input.projectRoot);
+    const cardRoot = normalizeProjectPath(override.projectRoot || override.runtime?.cwd || ".");
+    if (cardRoot !== scopedRoot) {
+      return false;
+    }
+  }
+  return true;
+}
+async function retireLocalAgentOverrides(overrides, agentIds) {
+  const retired = [];
+  for (const agentId of agentIds) {
+    const override = overrides[agentId];
+    if (!override) {
+      continue;
+    }
+    const record = localAgentRecordFromRelayAgentOverride(agentId, override);
+    const status = localAgentStatusFromRecord(agentId, record, localAgentStatusSource(agentId, overrides));
+    await stopLocalAgent(agentId).catch(() => null);
+    retired.push({
+      ...status,
+      isOnline: false
+    });
+    delete overrides[agentId];
+  }
+  if (retired.length > 0) {
+    await writeRelayAgentOverrides(overrides);
+  }
+  return retired;
+}
+async function pruneOneTimeLocalAgentCards(input = {}) {
+  const now = input.now ?? Date.now();
+  const maxAgeMs = Math.max(0, input.maxAgeMs ?? DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS);
+  const maxCount = Math.max(0, input.maxCount ?? DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_RETAIN);
+  const excluded = new Set(input.excludeAgentIds ?? []);
+  const overrides = await readRelayAgentOverrides();
+  const candidates = Object.entries(overrides).filter(([agentId, override]) => !excluded.has(agentId) && oneTimeCardMatchesScope(agentId, override, input)).map(([agentId, override]) => ({
+    agentId,
+    override,
+    lifecycle: normalizeLocalAgentCardLifecycle(override.card)
+  })).sort((left, right) => oneTimeCardCreatedAt(right.lifecycle) - oneTimeCardCreatedAt(left.lifecycle) || left.agentId.localeCompare(right.agentId));
+  const retireIds = new Set;
+  for (const candidate of candidates) {
+    if (shouldPruneOneTimeCard(candidate.lifecycle, now, maxAgeMs)) {
+      retireIds.add(candidate.agentId);
+    }
+  }
+  const retained = candidates.filter((candidate) => !retireIds.has(candidate.agentId));
+  for (const candidate of retained.slice(maxCount)) {
+    retireIds.add(candidate.agentId);
+  }
+  const retired = await retireLocalAgentOverrides({ ...overrides }, retireIds);
+  return {
+    inspected: candidates.length,
+    remaining: Math.max(0, candidates.length - retired.length),
+    retired
+  };
+}
+async function retireLocalAgent(agentId) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (!override) {
+    return null;
+  }
+  const record = localAgentRecordFromRelayAgentOverride(agentId, override);
+  const status = localAgentStatusFromRecord(agentId, record, localAgentStatusSource(agentId, overrides));
+  await stopLocalAgent(agentId).catch(() => null);
+  const nextOverrides = { ...overrides };
+  delete nextOverrides[agentId];
+  await writeRelayAgentOverrides(nextOverrides);
+  return {
+    ...status,
+    isOnline: false
+  };
+}
 function buildCodexAgentSessionOptions(agentName, record, systemPrompt) {
   const permissionPosture = compileCodexPermissionProfile(record.permissionProfile);
   return {
@@ -13592,6 +14650,90 @@ function buildLocalAgentSystemPrompt(agentName, projectName, projectPath, option
 function buildLocalAgentInitialMessage(projectName, agentName) {
   return `You are now online as the ${agentName} relay agent for ${projectName}. Announce yourself on the relay with: ${brokerRelayCommand()} send --as ${agentName} "relay agent online \u2014 ready to assist with ${projectName}"`;
 }
+function tmuxDispatchSleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+function captureTmuxPaneTail(sessionName, lines) {
+  try {
+    return execFileSync4("tmux", ["capture-pane", "-p", "-t", sessionName, "-S", `-${lines}`, "-E", "-"], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+  } catch {
+    return "";
+  }
+}
+async function waitForTmuxHarnessReady(sessionName, harness) {
+  if (harness !== "claude") {
+    return;
+  }
+  const deadline = Date.now() + TMUX_READY_TIMEOUT_MS;
+  let paneTail = "";
+  while (Date.now() < deadline) {
+    if (!isLocalAgentSessionAlive(sessionName)) {
+      throw new Error(`tmux session ${sessionName} exited before Claude Code was ready.`);
+    }
+    paneTail = captureTmuxPaneTail(sessionName, TMUX_READY_TAIL_LINES);
+    if (tmuxPaneTailShowsReadyComposer(paneTail)) {
+      return;
+    }
+    await tmuxDispatchSleep(TMUX_READY_POLL_MS);
+  }
+  const tail = stripTerminalControlSequences(paneTail).trim().split(/\r?\n/).slice(-20).join(`
+`).trim();
+  throw new Error(`tmux session ${sessionName} did not show a ready Claude Code composer within ${TMUX_READY_TIMEOUT_MS}ms.` + (tail ? `
+Recent pane tail:
+${tail}` : ""));
+}
+function tmuxPaneTailShowsReadyComposer(paneTail) {
+  const cleanedTail = stripTerminalControlSequences(paneTail);
+  const lines = cleanedTail.split(/\r?\n/);
+  const anchor = findActiveTmuxComposerAnchor(lines);
+  if (!anchor) {
+    return false;
+  }
+  const afterComposerLines = [];
+  for (const line of lines.slice(anchor.index + 1)) {
+    if (isTmuxComposerBoundary(line)) {
+      break;
+    }
+    afterComposerLines.push(line);
+  }
+  return !tmuxPaneTailShowsHarnessActivity(afterComposerLines.join(`
+`));
+}
+function stripTerminalControlSequences(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+function findActiveTmuxComposerAnchor(lines) {
+  const inlineComposerIndex = findLastIndex(lines, (line) => /^\s*[\u276F\u203A]\s*/.test(line));
+  const boxedComposerIndex = findLastIndex(lines, (line) => /^\s*[\u2502\u2503]\s*[>\u276F]\s*/.test(line));
+  if (inlineComposerIndex < 0 && boxedComposerIndex < 0) {
+    return null;
+  }
+  if (inlineComposerIndex > boxedComposerIndex) {
+    return { index: inlineComposerIndex, kind: "inline" };
+  }
+  return { index: boxedComposerIndex, kind: "boxed" };
+}
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1;index >= 0; index -= 1) {
+    if (predicate(items[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isTmuxComposerBoundary(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (/^[\u2500\u2501\u2550\u256D\u256E\u2570\u256F\u250C\u2510\u2514\u2518\u2554\u2557\u255A\u255D\u255F\u2562\u2560\u2563\u256A\u256B\u256C\u2569\u2566\u2564\u2567\u254C\u254D\u254E\u254F\s]+$/.test(trimmed)) {
+    return true;
+  }
+  return /^--\s*(?:INSERT|NORMAL)\s*--/.test(trimmed) || /^(?:Opus|Sonnet|Haiku|Claude|Codex|GPT)\b/.test(trimmed);
+}
+function tmuxPaneTailShowsHarnessActivity(paneTail) {
+  return /(?:^|\n)\s*(?:[\u23FA\u25CF\u273D\u2722\u273B\u23BF]|Bash\(|Read\(|Edit\(|Write\(|Grep\(|Glob\(|TodoWrite\()/.test(paneTail);
+}
 function shellQuoteArguments(args) {
   return args.map((arg) => JSON.stringify(arg)).join(" ");
 }
@@ -13602,10 +14744,10 @@ function buildLocalAgentLaunchCommand(agentName, record, projectPath, promptFile
   const harness = normalizeLocalAgentHarness(record.harness);
   const extraArgs = shellQuoteArguments(harness === "claude" ? normalizeClaudeRuntimeLaunchArgs(record.launchArgs) : normalizeLaunchArgsForHarness(harness, record.launchArgs));
   if (harness === "codex") {
-    return `exec bash ${JSON.stringify(workerScript ?? join19(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
+    return `exec bash ${JSON.stringify(workerScript ?? join20(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
   if (harness === "pi") {
-    const sessionDir = join19(relayAgentRuntimeDirectory(agentName), "pi-sessions");
+    const sessionDir = join20(relayAgentRuntimeDirectory(agentName), "pi-sessions");
     return [
       "pi",
       `--append-system-prompt "$(cat ${JSON.stringify(promptFile)})"`,
@@ -13675,7 +14817,7 @@ async function ensureLocalAgentOnline(agentName, record) {
   await mkdir6(agentRuntimeDir, { recursive: true });
   await mkdir6(logsDir, { recursive: true });
   if (normalizedRecord.transport === "codex_app_server") {
-    await writeFile6(join19(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join20(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureCodexAppServerAgentOnline(buildCodexAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -13687,7 +14829,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return registry2[agentName];
   }
   if (normalizedRecord.transport === "claude_stream_json") {
-    await writeFile6(join19(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join20(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureClaudeStreamJsonAgentOnline(buildClaudeAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -13700,17 +14842,17 @@ async function ensureLocalAgentOnline(agentName, record) {
   }
   const initialMessage = buildLocalAgentInitialMessage(projectName, agentName);
   const bootstrapPrompt = buildLocalAgentBootstrapPrompt(normalizeLocalAgentHarness(normalizedRecord.harness), systemPrompt, initialMessage);
-  const queueDirectory = join19(agentRuntimeDir, "queue");
-  const processingDirectory = join19(queueDirectory, "processing");
-  const processedDirectory = join19(queueDirectory, "processed");
-  const promptFile = join19(agentRuntimeDir, "prompt.txt");
-  const initialFile = join19(agentRuntimeDir, "initial.txt");
-  const launchScript = join19(agentRuntimeDir, "launch.sh");
-  const workerScript = join19(agentRuntimeDir, "codex-worker.sh");
-  const codexSessionIdFile = join19(agentRuntimeDir, "codex-session-id.txt");
-  const stateFile = join19(agentRuntimeDir, "state.json");
-  const stdoutLogFile = join19(logsDir, "stdout.log");
-  const stderrLogFile = join19(logsDir, "stderr.log");
+  const queueDirectory = join20(agentRuntimeDir, "queue");
+  const processingDirectory = join20(queueDirectory, "processing");
+  const processedDirectory = join20(queueDirectory, "processed");
+  const promptFile = join20(agentRuntimeDir, "prompt.txt");
+  const initialFile = join20(agentRuntimeDir, "initial.txt");
+  const launchScript = join20(agentRuntimeDir, "launch.sh");
+  const workerScript = join20(agentRuntimeDir, "codex-worker.sh");
+  const codexSessionIdFile = join20(agentRuntimeDir, "codex-session-id.txt");
+  const stateFile = join20(agentRuntimeDir, "state.json");
+  const stdoutLogFile = join20(logsDir, "stdout.log");
+  const stderrLogFile = join20(logsDir, "stderr.log");
   await writeFile6(promptFile, systemPrompt);
   await writeFile6(initialFile, bootstrapPrompt);
   await writeFile6(stderrLogFile, "");
@@ -13775,11 +14917,17 @@ async function ensureLocalAgentOnline(agentName, record) {
     await new Promise((resolve7) => setTimeout(resolve7, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync16(stderrLogFile) ? readFileSync10(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync17(stderrLogFile) ? readFileSync11(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
 `).trim() : "";
     throw new Error(stderrTail ? `Relay agent ${agentName} failed to stay online:
 ${stderrTail}` : `Relay agent ${agentName} failed to stay online.`);
   }
+  try {
+    await waitForTmuxHarnessReady(normalizedRecord.tmuxSession, normalizeLocalAgentHarness(normalizedRecord.harness));
+  } catch (error) {
+    killAgentSession(normalizedRecord.tmuxSession);
+    throw error;
+  }
   const registry = await readLocalAgentRegistry();
   registry[agentName] = {
     ...normalizedRecord,
@@ -13836,6 +14984,7 @@ async function startLocalAgent(input) {
   const effectiveCwd = input.cwdOverride ? normalizeProjectPath(input.cwdOverride) : undefined;
   const shouldEnsureOnline = input.ensureOnline !== false;
   const requestedPermissionProfile = parseScoutPermissionProfile(input.permissionProfile);
+  const cardLifecycle = normalizeLocalAgentCardLifecycle(input.card);
   const requestedDefinitionId = input.agentName?.trim() ? normalizeAgentSelectorSegment(input.agentName.trim()) : "";
   if (input.agentName?.trim() && !requestedDefinitionId) {
     throw new Error(`Invalid agent name "${input.agentName}".`);
@@ -13885,7 +15034,8 @@ async function startLocalAgent(input) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
     const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename8(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
-    const effectiveDisplayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(definitionId);
+    const effectiveDisplayName = input.displayName || operatorAugmentDefaults?.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
     const instance = buildRelayAgentInstance(definitionId, projectRoot);
     const configDefaultHarness = coldProjectConfig?.agent?.runtime?.defaultHarness;
     const effectiveHarness = normalizeManagedHarness2(preferredHarness ?? configDefaultHarness, "claude");
@@ -13908,8 +15058,10 @@ async function startLocalAgent(input) {
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
       startedAt: nowSeconds2(),
+      ...operatorAugmentDefaults ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
       launchArgs,
       defaultHarness: effectiveHarness,
+      ...cardLifecycle ? { card: cardLifecycle } : {},
       harnessProfiles: {
         [effectiveHarness]: {
           cwd: effectiveCwd ?? projectRoot,
@@ -13945,18 +15097,21 @@ async function startLocalAgent(input) {
       reasoningEffort: input.reasoningEffort
     });
     const nextTransport = normalizeLocalAgentTransport(preferredHarness ? undefined : matchingOverride.runtime?.transport, nextHarness);
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(requestedDefinitionId);
     overrides[instance.id] = {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
-      displayName: input.displayName || titleCaseLocalAgentName(requestedDefinitionId),
+      displayName: input.displayName || operatorAugmentDefaults?.displayName || titleCaseLocalAgentName(requestedDefinitionId),
       projectName: matchingOverride.projectName ?? basename8(matchingProjectRoot),
       projectRoot: matchingProjectRoot,
       projectConfigPath: null,
       source: "manual",
       startedAt: matchingOverride.startedAt ?? nowSeconds2(),
+      ...operatorAugmentDefaults ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
       launchArgs: nextHarness === nextDefaultHarness ? nextLaunchArgs : matchingOverride.launchArgs,
       capabilities: matchingOverride.capabilities,
       defaultHarness: nextDefaultHarness,
+      ...cardLifecycle ? { card: cardLifecycle } : {},
       harnessProfiles: {
         ...matchingOverride.harnessProfiles ?? {},
         [nextHarness]: {
@@ -13978,7 +15133,9 @@ async function startLocalAgent(input) {
     await writeRelayAgentOverrides(overrides);
     targetAgentId = instance.id;
   } else {
-    if (input.model || input.reasoningEffort || requestedPermissionProfile) {
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(matchingOverride.definitionId ?? requestedDefinitionId);
+    const shouldApplyOperatorAugmentPrompt = Boolean(operatorAugmentDefaults && !matchingOverride.systemPrompt?.trim());
+    if (input.model || input.reasoningEffort || requestedPermissionProfile || cardLifecycle || shouldApplyOperatorAugmentPrompt) {
       const existingHarness = normalizeManagedHarness2(preferredHarness ?? matchingOverride.defaultHarness ?? matchingOverride.runtime?.harness, "claude");
       const nextLaunchArgs = applyRequestedRuntimeOptionsToLaunchArgs(existingHarness, launchArgsForOverrideHarness(matchingOverride, existingHarness), {
         model: input.model,
@@ -13986,6 +15143,8 @@ async function startLocalAgent(input) {
       });
       overrides[matchingAgentId] = {
         ...matchingOverride,
+        ...cardLifecycle ? { card: cardLifecycle } : {},
+        ...shouldApplyOperatorAugmentPrompt ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
         launchArgs: existingHarness === defaultHarnessForOverride(matchingOverride, existingHarness) ? nextLaunchArgs : matchingOverride.launchArgs,
         harnessProfiles: {
           ...matchingOverride.harnessProfiles ?? {},
@@ -14090,9 +15249,9 @@ async function restartAllLocalAgents(options = {}) {
 function readPersistedClaudeSessionId(agentName) {
   try {
     const runtimeDir = relayAgentRuntimeDirectory(agentName);
-    const catalogPath = join19(runtimeDir, "session-catalog.json");
-    if (existsSync16(catalogPath)) {
-      const raw = readFileSync10(catalogPath, "utf8").trim();
+    const catalogPath = join20(runtimeDir, "session-catalog.json");
+    if (existsSync17(catalogPath)) {
+      const raw = readFileSync11(catalogPath, "utf8").trim();
       if (raw) {
         const catalog = JSON.parse(raw);
         if (typeof catalog.activeSessionId === "string" && catalog.activeSessionId.trim()) {
@@ -14100,9 +15259,9 @@ function readPersistedClaudeSessionId(agentName) {
         }
       }
     }
-    const legacyPath = join19(runtimeDir, "claude-session-id.txt");
-    if (existsSync16(legacyPath)) {
-      const value = readFileSync10(legacyPath, "utf8").trim();
+    const legacyPath = join20(runtimeDir, "claude-session-id.txt");
+    if (existsSync17(legacyPath)) {
+      const value = readFileSync11(legacyPath, "utf8").trim();
       return value || null;
     }
     return null;
@@ -14114,6 +15273,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
   const normalizedRecord = normalizeLocalAgentRecord(agentId, record);
   const configuredModel = readLaunchModelForHarness(normalizeLocalAgentHarness(normalizedRecord.harness), normalizedRecord.launchArgs);
   const codexPermissionPosture = normalizeLocalAgentHarness(normalizedRecord.harness) === "codex" ? compileCodexPermissionProfile(normalizedRecord.permissionProfile) : null;
+  const cardLifecycle = normalizeLocalAgentCardLifecycle(normalizedRecord.card);
   const definitionId = normalizedRecord.definitionId ?? agentId;
   const displayName = titleCaseLocalAgentName(definitionId);
   const projectRoot = normalizedRecord.projectRoot ?? normalizedRecord.cwd;
@@ -14141,6 +15301,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -14176,6 +15337,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -14216,6 +15378,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -14302,9 +15465,10 @@ async function ensureLocalAgentBindingOnline(agentId, nodeId, options = {}) {
   const onlineRecord = await ensureLocalAgentOnline(agentId, recordForHarness(localAgentRecordFromRelayAgentOverride(agentId, override), options.harness));
   return buildLocalAgentBinding(agentId, onlineRecord, isLocalAgentRecordOnline(agentId, onlineRecord), nodeId, "relay-agent-registry");
 }
-var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", SUPPORTED_LOCAL_AGENT_HARNESSES, SUPPORTED_SCOUT_HARNESSES, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS;
+var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS, DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_RETAIN = 24, SUPPORTED_LOCAL_AGENT_HARNESSES, SUPPORTED_SCOUT_HARNESSES, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS, TMUX_READY_TIMEOUT_MS = 20000, TMUX_READY_POLL_MS = 250, TMUX_READY_TAIL_LINES = 80;
 var init_local_agents = __esm(() => {
   init_src2();
+  init_dispatch_stalled();
   init_claude_stream_json();
   init_codex_app_server();
   init_setup();
@@ -14314,9 +15478,11 @@ var init_local_agents = __esm(() => {
   init_local_agent_template();
   init_permission_policy2();
   init_requester_timeout();
-  MODULE_DIRECTORY = dirname9(fileURLToPath5(import.meta.url));
+  init_user_config();
+  MODULE_DIRECTORY = dirname10(fileURLToPath5(import.meta.url));
   OPENSCOUT_REPO_ROOT = resolve6(MODULE_DIRECTORY, "..", "..", "..");
   DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
+  DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
   SUPPORTED_LOCAL_AGENT_HARNESSES = ["claude", "codex", "pi"];
   SUPPORTED_SCOUT_HARNESSES = [
     ...SUPPORTED_LOCAL_AGENT_HARNESSES,
@@ -14328,11 +15494,12 @@ var init_local_agents = __esm(() => {
     "mcp__scout__messages_inbox",
     "mcp__scout__messages_channel",
     "mcp__scout__broker_feed",
+    "mcp__scout__tail_events",
     "mcp__scout__agents_search",
     "mcp__scout__agents_resolve",
     "mcp__scout__messages_reply",
+    "mcp__scout__ask",
     "mcp__scout__messages_send",
-    "mcp__scout__invocations_ask",
     "mcp__scout__invocations_get",
     "mcp__scout__invocations_wait",
     "mcp__scout__work_update",
@@ -17829,7 +18996,7 @@ function writeJsonAtomically(filePath, value) {
 
 // ../web/server/core/pairing/runtime/runtime.ts
 init_src();
-import { homedir as homedir24 } from "os";
+import { homedir as homedir25 } from "os";
 
 // ../web/server/core/pairing/runtime/bridge/bridge.ts
 init_src();
@@ -18643,18 +19810,21 @@ function formatTimestamp(value) {
 
 // ../web/server/core/pairing/runtime/bridge/server.ts
 init_src();
-import { readdirSync as readdirSync5, readFileSync as readFileSync12, realpathSync, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync13, realpathSync, statSync as statSync5 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import { basename as basename10, isAbsolute as isAbsolute3, join as join23, relative as relative3 } from "path";
-import { homedir as homedir21 } from "os";
+import { basename as basename11, isAbsolute as isAbsolute3, join as join25, relative as relative3 } from "path";
+import { homedir as homedir22 } from "os";
 
 // ../web/server/core/mobile/service.ts
 init_harness_catalog();
 init_setup();
-import { basename as basename9, resolve as resolve7 } from "path";
+import { basename as basename10, resolve as resolve7 } from "path";
 
 // ../runtime/src/control-plane-agents.ts
+init_src2();
 init_local_agents();
+import { randomUUID as randomUUID2 } from "crypto";
+import { basename as basename9 } from "path";
 
 // ../runtime/src/scout-agent-cards.ts
 init_src2();
@@ -18707,6 +19877,7 @@ function buildScoutAgentCard(binding, options = {}) {
   const supportedInterfaces = metadataRecordArray(binding.agent.metadata, "supportedInterfaces");
   const securitySchemes = metadataRecord2(binding.agent.metadata, "securitySchemes");
   const securityRequirements = metadataStringMatrix(binding.agent.metadata, "securityRequirements");
+  const lifecycle2 = options.lifecycle ?? metadataRecord2(binding.agent.metadata, "cardLifecycle");
   return {
     id: binding.agent.id,
     agentId: binding.agent.id,
@@ -18736,6 +19907,7 @@ function buildScoutAgentCard(binding, options = {}) {
     ...options.createdById?.trim() ? { createdById: options.createdById.trim() } : {},
     brokerRegistered: options.brokerRegistered ?? false,
     ...options.inboxConversationId?.trim() ? { inboxConversationId: options.inboxConversationId.trim() } : {},
+    ...lifecycle2 ? { lifecycle: lifecycle2 } : {},
     returnAddress: buildScoutReturnAddress({
       actorId: binding.agent.id,
       handle,
@@ -18753,19 +19925,30 @@ function buildScoutAgentCard(binding, options = {}) {
       actorId: binding.actor.id,
       endpointId: binding.endpoint.id,
       wakePolicy: binding.agent.wakePolicy,
-      ...model ? { model } : {}
+      ...model ? { model } : {},
+      ...lifecycle2 ? { cardLifecycle: lifecycle2 } : {}
     }
   };
 }
 
 // ../runtime/src/control-plane-agents.ts
+var DEFAULT_ONE_TIME_SCOUT_AGENT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
+function oneTimeAgentName(input) {
+  const base = normalizeAgentSelectorSegment(input.agentName || basename9(input.projectPath)) || "agent";
+  return `${base}-card-${randomUUID2().slice(0, 8)}`;
+}
 function createScoutAgentService(deps) {
   const localAgents = {
     listLocalAgents: deps.localAgents?.listLocalAgents ?? listLocalAgents,
+    retireLocalAgent: deps.localAgents?.retireLocalAgent ?? retireLocalAgent,
     restartAllLocalAgents: deps.localAgents?.restartAllLocalAgents ?? restartAllLocalAgents,
+    restartLocalAgent: deps.localAgents?.restartLocalAgent ?? restartLocalAgent,
     startLocalAgent: deps.localAgents?.startLocalAgent ?? startLocalAgent,
     stopAllLocalAgents: deps.localAgents?.stopAllLocalAgents ?? stopAllLocalAgents,
     stopLocalAgent: deps.localAgents?.stopLocalAgent ?? stopLocalAgent,
+    updateLocalAgentCard: deps.localAgents?.updateLocalAgentCard ?? updateLocalAgentCard,
+    updateLocalAgentCardLifecycle: deps.localAgents?.updateLocalAgentCardLifecycle ?? updateLocalAgentCardLifecycle,
+    pruneOneTimeLocalAgentCards: deps.localAgents?.pruneOneTimeLocalAgentCards ?? pruneOneTimeLocalAgentCards,
     inferLocalAgentBinding: deps.localAgents?.inferLocalAgentBinding ?? inferLocalAgentBinding
   };
   return {
@@ -18782,22 +19965,62 @@ function createScoutAgentService(deps) {
     async downScoutAgent(agentId) {
       return localAgents.stopLocalAgent(agentId);
     },
+    async retireScoutAgentCard(agentId) {
+      const broker = await deps.loadScoutBrokerContext().catch(() => null);
+      const retired = await localAgents.retireLocalAgent(agentId);
+      if (retired) {
+        await deps.retireScoutLocalAgentBinding?.({ agentId, broker }).catch(() => false);
+      }
+      return retired;
+    },
+    async updateScoutAgentCard(agentId, input) {
+      const config = await localAgents.updateLocalAgentCard(agentId, input);
+      if (!config) {
+        return null;
+      }
+      if (input.restart === true) {
+        await localAgents.restartLocalAgent(agentId);
+      }
+      await deps.registerScoutLocalAgentBinding({ agentId }).catch(() => {});
+      return config;
+    },
     async downAllScoutAgents(input = {}) {
       return localAgents.stopAllLocalAgents(input);
     },
     async restartScoutAgents(input = {}) {
       return localAgents.restartAllLocalAgents(input);
     },
+    async cleanupScoutAgentCards(input = {}) {
+      const broker = await deps.loadScoutBrokerContext().catch(() => null);
+      const result = await localAgents.pruneOneTimeLocalAgentCards(input);
+      await Promise.all(result.retired.map((status) => deps.retireScoutLocalAgentBinding?.({ agentId: status.agentId, broker }).catch(() => false)));
+      return result;
+    },
     async createScoutAgentCard(input) {
+      const createdAt = Date.now();
+      const oneTimeUse = input.oneTimeUse === true;
+      const createdById = input.createdById?.trim() || undefined;
+      const agentName = oneTimeUse ? oneTimeAgentName({
+        agentName: input.agentName,
+        projectPath: input.projectPath
+      }) : input.agentName;
+      const lifecycle2 = oneTimeUse ? {
+        kind: "one_time",
+        createdAt,
+        ...createdById ? { createdById } : {},
+        expiresAt: createdAt + Math.max(1, input.ttlMs ?? DEFAULT_ONE_TIME_SCOUT_AGENT_CARD_TTL_MS),
+        maxUses: 1
+      } : undefined;
       const status = await localAgents.startLocalAgent({
         projectPath: input.projectPath,
-        agentName: input.agentName,
+        agentName,
         displayName: input.displayName,
         harness: input.harness,
         model: input.model,
         reasoningEffort: input.reasoningEffort,
         permissionProfile: input.permissionProfile,
         currentDirectory: input.currentDirectory,
+        ...lifecycle2 ? { card: lifecycle2 } : {},
         ensureOnline: false
       });
       const currentDirectory = input.currentDirectory ?? input.projectPath;
@@ -18811,57 +20034,76 @@ function createScoutAgentService(deps) {
         throw new Error(`Agent ${status.agentId} did not expose an addressable binding.`);
       }
       let inboxConversationId;
-      let createdById = input.createdById?.trim() || undefined;
-      if (broker && createdById && createdById !== binding.agent.id) {
+      let resolvedCreatedById = createdById;
+      if (broker && resolvedCreatedById && resolvedCreatedById !== binding.agent.id) {
         const session = await deps.openScoutPeerSession({
-          sourceId: createdById,
+          sourceId: resolvedCreatedById,
           targetId: binding.agent.id,
           currentDirectory
         });
         inboxConversationId = session.conversation.id;
-        createdById = session.sourceId;
+        resolvedCreatedById = session.sourceId;
+      }
+      const finalLifecycle = lifecycle2 ? {
+        ...lifecycle2,
+        ...resolvedCreatedById ? { createdById: resolvedCreatedById } : {},
+        ...inboxConversationId ? { inboxConversationId } : {}
+      } : undefined;
+      if (finalLifecycle) {
+        await localAgents.updateLocalAgentCardLifecycle(status.agentId, finalLifecycle).catch(() => null);
+        const cleaned = await localAgents.pruneOneTimeLocalAgentCards({
+          createdById: finalLifecycle.createdById,
+          projectRoot: binding.endpoint.projectRoot ?? input.projectPath,
+          excludeAgentIds: [status.agentId]
+        }).catch(() => null);
+        if (cleaned?.retired.length) {
+          await Promise.all(cleaned.retired.map((retired) => deps.retireScoutLocalAgentBinding?.({ agentId: retired.agentId, broker }).catch(() => false)));
+        }
       }
       return buildScoutAgentCard(binding, {
         currentDirectory,
-        createdById,
+        createdById: resolvedCreatedById,
         brokerRegistered: syncResult?.brokerRegistered ?? false,
-        inboxConversationId
+        inboxConversationId,
+        lifecycle: finalLifecycle
       });
     }
   };
 }
 
 // ../web/server/core/broker/service.ts
+import { randomUUID as randomUUID3 } from "crypto";
 init_src2();
 init_setup();
 init_broker_api();
 init_broker_process_manager();
 init_local_agents();
 init_support_paths();
+init_user_config();
 
 // ../runtime/src/local-config.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync11,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync12,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir18, hostname as osHostname } from "os";
-import { dirname as dirname10, join as join20 } from "path";
+import { homedir as homedir19, hostname as osHostname } from "os";
+import { dirname as dirname11, join as join21 } from "path";
 var LOCAL_CONFIG_VERSION = 1;
 function localConfigHome() {
-  return process.env.OPENSCOUT_HOME ?? join20(homedir18(), ".openscout");
+  return process.env.OPENSCOUT_HOME ?? join21(homedir19(), ".openscout");
 }
 function localConfigPath() {
-  return join20(localConfigHome(), "config.json");
+  return join21(localConfigHome(), "config.json");
 }
 function loadLocalConfig() {
   const configPath = localConfigPath();
-  if (!existsSync17(configPath))
+  if (!existsSync18(configPath))
     return { version: LOCAL_CONFIG_VERSION };
   try {
-    return validateLocalConfig(JSON.parse(readFileSync11(configPath, "utf8")));
+    return validateLocalConfig(JSON.parse(readFileSync12(configPath, "utf8")));
   } catch {
     return { version: LOCAL_CONFIG_VERSION };
   }
@@ -18903,6 +20145,8 @@ var scoutBrokerPaths = {
     node: "/v1/node",
     snapshot: "/v1/snapshot",
     topologySnapshot: "/v1/topology/snapshot",
+    tailDiscover: "/v1/tail/discover",
+    tailRecent: "/v1/tail/recent",
     messages: "/v1/messages",
     eventsStream: "/v1/events/stream",
     actors: "/v1/actors",
@@ -18921,7 +20165,6 @@ var scoutBrokerPaths = {
 };
 
 // ../web/server/core/broker/service.ts
-var BROKER_SHARED_CHANNEL_ID = "channel.shared";
 var OPERATOR_ID = "operator";
 var DEFAULT_BROKER_HOST2 = "127.0.0.1";
 var DEFAULT_BROKER_PORT2 = 65535;
@@ -18952,6 +20195,13 @@ function metadataString3(metadata, key) {
 function metadataBoolean(metadata, key) {
   return metadata?.[key] === true;
 }
+function isSupersededBrokerAgent(snapshot, agentId) {
+  const agent = snapshot.agents[agentId];
+  if (!agent) {
+    return false;
+  }
+  return metadataBoolean(agent.metadata, "retiredFromFleet") || metadataBoolean(agent.metadata, "staleLocalRegistration");
+}
 async function brokerReadJson(baseUrl, path2, options = {}) {
   return requestScoutBrokerJson(baseUrl, path2, {
     socketPath: resolveBrokerSocketPathForBaseUrl(baseUrl),
@@ -18989,6 +20239,17 @@ async function readScoutBrokerHealth(baseUrl = resolveScoutBrokerUrl(), options
         nodes: health.counts.nodes ?? 0,
         actors: health.counts.actors ?? 0,
         agents: health.counts.agents ?? 0,
+        agentRecords: health.counts.agentRecords,
+        rawAgentRecords: health.counts.rawAgentRecords,
+        configuredAgents: health.counts.configuredAgents,
+        scoutManagedAgents: health.counts.scoutManagedAgents,
+        currentAgentRegistrations: health.counts.currentAgentRegistrations,
+        localAgentRegistrations: health.counts.localAgentRegistrations,
+        remoteAgentRegistrations: health.counts.remoteAgentRegistrations,
+        staleAgentRegistrations: health.counts.staleAgentRegistrations,
+        retiredAgentRegistrations: health.counts.retiredAgentRegistrations,
+        oneTimeAgentCards: health.counts.oneTimeAgentCards,
+        persistentAgentCards: health.counts.persistentAgentCards,
         conversations: health.counts.conversations ?? 0,
         messages: health.counts.messages ?? 0,
         flights: health.counts.flights ?? 0
@@ -19138,6 +20399,48 @@ async function registerScoutLocalAgentBinding(input) {
     brokerRegistered: Boolean(broker)
   };
 }
+async function retireScoutLocalAgentBinding(input) {
+  const broker = input.broker ?? await loadScoutBrokerContext();
+  if (!broker) {
+    return false;
+  }
+  const retiredAt = Date.now();
+  let retired = false;
+  const agent = broker.snapshot.agents[input.agentId];
+  if (agent) {
+    const nextAgent = {
+      ...agent,
+      metadata: {
+        ...agent.metadata ?? {},
+        retiredFromFleet: true,
+        retiredAt
+      }
+    };
+    await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.agents, nextAgent);
+    broker.snapshot.agents[input.agentId] = nextAgent;
+    retired = true;
+  }
+  for (const endpoint of Object.values(broker.snapshot.endpoints)) {
+    if (endpoint.agentId !== input.agentId) {
+      continue;
+    }
+    const nextEndpoint = {
+      ...endpoint,
+      state: "offline",
+      metadata: {
+        ...endpoint.metadata ?? {},
+        retiredFromFleet: true,
+        retiredAt,
+        lastError: "local agent card retired",
+        lastFailedAt: retiredAt
+      }
+    };
+    await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.endpoints, nextEndpoint);
+    broker.snapshot.endpoints[endpoint.id] = nextEndpoint;
+    retired = true;
+  }
+  return retired;
+}
 async function resolveConversationActorId(baseUrl, snapshot, nodeId, actorId, currentDirectory, displayName) {
   const normalized = actorId.trim() || OPERATOR_ID;
   if (snapshot.agents[normalized] || snapshot.actors[normalized]) {
@@ -19165,6 +20468,9 @@ async function resolveConversationActorId(baseUrl, snapshot, nodeId, actorId, cu
 }
 async function ensureTargetRelayAgentRegistered(baseUrl, snapshot, nodeId, agentId, currentDirectory) {
   const existingAgent = snapshot.agents[agentId];
+  if (existingAgent && metadataBoolean(existingAgent.metadata, "retiredFromFleet")) {
+    return false;
+  }
   if (existingAgent && !metadataBoolean(existingAgent.metadata, "staleLocalRegistration")) {
     return true;
   }
@@ -19173,7 +20479,7 @@ async function ensureTargetRelayAgentRegistered(baseUrl, snapshot, nodeId, agent
     syncLegacyMirror: true
   });
   if (!configured) {
-    return false;
+    return Boolean(existingAgent);
   }
   const binding = await inferLocalAgentBinding(configured.agentId, nodeId);
   if (!binding) {
@@ -19185,21 +20491,15 @@ async function ensureTargetRelayAgentRegistered(baseUrl, snapshot, nodeId, agent
   });
   return Boolean(binding);
 }
-function directConversationIdForActors(sourceId, targetId) {
-  if (sourceId === targetId) {
-    return `dm.${sourceId}.${targetId}`;
-  }
-  if (sourceId === OPERATOR_ID || targetId === OPERATOR_ID) {
-    const peerId = sourceId === OPERATOR_ID ? targetId : sourceId;
-    return `dm.${OPERATOR_ID}.${peerId}`;
-  }
-  return `dm.${[sourceId, targetId].sort().join(".")}`;
+function findConversationByIdentity(snapshot, naturalKey) {
+  return Object.values(snapshot.conversations).find((conversation) => channelNaturalKeyFromMetadata(conversation.metadata) === naturalKey);
 }
 async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId, sourceId, targetId) {
-  const conversationId = targetId === SCOUT_AGENT_ID && sourceId === OPERATOR_ID ? BROKER_SHARED_CHANNEL_ID : directConversationIdForActors(sourceId, targetId);
   const participantIds = [...new Set([sourceId, targetId])].sort();
+  const naturalKey = directChannelNaturalKey(participantIds);
+  const existing = findConversationByIdentity(snapshot, naturalKey);
+  const conversationId = existing?.id ?? mintChannelId(randomUUID3);
   const nextShareMode = resolveConversationShareMode(snapshot, nodeId, participantIds, "local");
-  const existing = snapshot.conversations[conversationId];
   const alreadyMatches = existing && existing.kind === "direct" && existing.shareMode === nextShareMode && existing.visibility === "private" && existing.participantIds.join("\x00") === participantIds.join("\x00");
   if (alreadyMatches) {
     const preferredTargetId = targetId === OPERATOR_ID ? sourceId : targetId;
@@ -19221,6 +20521,7 @@ async function ensureBrokerDirectConversationBetween(baseUrl, snapshot, nodeId,
     participantIds,
     metadata: {
       surface: "scout",
+      naturalKey,
       ...targetId === SCOUT_AGENT_ID && sourceId === OPERATOR_ID ? { role: "partner" } : {}
     }
   };
@@ -19254,6 +20555,11 @@ async function sendScoutDirectMessage(input) {
   const broker = await requireScoutBrokerContext();
   const createdAt = Date.now();
   const source = input.source?.trim() || "scout-mobile";
+  const targetEndpoints = Object.values(broker.snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === input.agentId);
+  const targetIsStale = isSupersededBrokerAgent(broker.snapshot, input.agentId) || targetEndpoints.length > 0 && targetEndpoints.every((endpoint) => metadataBoolean(endpoint.metadata, "retiredFromFleet") || metadataBoolean(endpoint.metadata, "staleLocalRegistration"));
+  if (targetIsStale) {
+    throw new Error(`${displayNameForBrokerActor(broker.snapshot, input.agentId)} is a stale local registration. Start the current project session from Workspaces before sending.`);
+  }
   const delivery = await brokerPostDeliver(broker.baseUrl, {
     id: `deliver-${createdAt.toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
     requesterId: OPERATOR_ID,
@@ -19311,24 +20617,28 @@ async function loadScoutActivityItems(options = {}) {
 var scoutAgentService = createScoutAgentService({
   loadScoutBrokerContext,
   openScoutPeerSession,
-  registerScoutLocalAgentBinding
+  registerScoutLocalAgentBinding,
+  retireScoutLocalAgentBinding
 });
 var {
+  cleanupScoutAgentCards,
   createScoutAgentCard,
   downAllScoutAgents,
   downScoutAgent,
   loadScoutAgentStatuses,
+  retireScoutAgentCard,
   restartScoutAgents,
+  updateScoutAgentCard,
   upScoutAgent
 } = scoutAgentService;
 
 // ../web/server/db/internal/db.ts
 import { Database } from "bun:sqlite";
-import { homedir as homedir19 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join22 } from "path";
 function resolveDbPath() {
-  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join21(homedir19(), ".openscout", "control-plane");
-  return join21(controlHome, "control-plane.sqlite");
+  const controlHome = process.env.OPENSCOUT_CONTROL_HOME ?? join22(homedir20(), ".openscout", "control-plane");
+  return join22(controlHome, "control-plane.sqlite");
 }
 var _db = null;
 var DB_BUSY_TIMEOUT_MS = 250;
@@ -19344,6 +20654,7 @@ function db() {
   return _db;
 }
 // ../runtime/src/conversations/legacy-ids.ts
+init_user_config();
 function conversationIdForAgent(agentId) {
   return buildDirectConversationId("operator", agentId);
 }
@@ -19360,9 +20671,9 @@ var EPOCH_MILLISECONDS_FLOOR = 1000000000000;
 
 // ../web/server/db/internal/paths.ts
 init_support_paths();
-import { homedir as homedir20 } from "os";
-import { join as join22 } from "path";
-var HOME = homedir20();
+import { homedir as homedir21 } from "os";
+import { join as join23 } from "path";
+var HOME = homedir21();
 function compact(p) {
   if (!p)
     return null;
@@ -19374,12 +20685,15 @@ function pairingHarnessLogPath(adapterType, sessionId) {
   if (!normalizedAdapter || !normalizedSessionId) {
     return null;
   }
-  return join22(HOME, ".scout", "pairing", normalizedAdapter, normalizedSessionId, "logs", "stdout.log");
+  return join23(HOME, ".scout", "pairing", normalizedAdapter, normalizedSessionId, "logs", "stdout.log");
 }
 function relayHarnessLogPath(agentId) {
-  return join22(relayAgentLogsDirectory(agentId), "stdout.log");
+  return join23(relayAgentLogsDirectory(agentId), "stdout.log");
 }
 function resolveHarnessSessionId(transport, endpointSessionId, metadata) {
+  if (transport === "tmux") {
+    return metadataString4(metadata, "tmuxSession") ?? endpointSessionId;
+  }
   if (transport === "pairing_bridge") {
     const attachedTransport = metadataString4(metadata, "attachedTransport");
     if (attachedTransport === "codex_app_server") {
@@ -19444,7 +20758,8 @@ function summarizeAgentState(rawState, isWorking, wakePolicy) {
   if (isWorking) {
     return "working";
   }
-  if (rawState === "offline" && wakePolicy === "on_demand") {
+  const wakeableWithoutEndpoint = wakePolicy === "on_demand" || wakePolicy === "always_on";
+  if ((!rawState || rawState === "offline") && wakeableWithoutEndpoint) {
     return "available";
   }
   return rawState && rawState !== "offline" ? "available" : "offline";
@@ -19466,13 +20781,22 @@ function transientBrokerWorkingStatusPredicate(alias) {
   return `NOT (
     ${alias}.class = 'status'
     AND COALESCE(json_extract(${alias}.metadata_json, '$.source'), '') = 'broker'
-    AND ${alias}.body LIKE '% is working.'
+    AND (
+      ${alias}.body LIKE '% is working.'
+      OR ${alias}.body LIKE '%Scout stopped waiting for a synchronous result%'
+      OR ${alias}.body LIKE '%the requester stopped waiting after%'
+    )
   )`;
 }
 // ../web/server/db/activity.ts
 var HEARTRATE_WINDOW_MS = 7 * 24 * 60 * 60000;
 // ../web/server/db/runs.ts
 init_src2();
+
+// ../web/server/db/sessions.ts
+init_src2();
+
+// ../web/server/db/runs.ts
 var ACTIVE_RUN_STATES = new Set([
   "queued",
   "waking",
@@ -19485,13 +20809,29 @@ var ACTIVE_RUN_STATES_SQL = sqlStringList([...ACTIVE_RUN_STATES]);
 var AGENT_RUN_STATES_SQL = sqlStringList(AGENT_RUN_STATES);
 var AGENT_RUN_SOURCES_SQL = sqlStringList(AGENT_RUN_SOURCES);
 // ../web/server/db/fleet.ts
+init_user_config();
 var TERMINAL_FLIGHT_STATES = new Set(["completed", "failed", "cancelled"]);
 var FLEET_RECENT_COMPLETED_MAX_AGE_MS = 3 * 24 * 60 * 60 * 1000;
 // ../web/server/db/mobile/agents.ts
-function queryMobileAgents(limit = 50) {
+function queryMobileAgents(limit = 50, filters = {}) {
   const executingAgentIds = queryExecutingAgentIds();
   const messageCreatedAtExpression = sqlTimestampMsExpression("created_at");
   const endpointUpdatedAtExpression = sqlTimestampMsExpression("ep.updated_at");
+  const query = filters.query?.trim().toLowerCase();
+  const whereClauses = [activeAgentMetadataPredicate("a")];
+  const params = [];
+  if (query) {
+    whereClauses.push(`(
+      lower(ac.display_name) LIKE ?
+      OR lower(a.id) LIKE ?
+      OR lower(COALESCE(a.default_selector, '')) LIKE ?
+      OR lower(COALESCE(a.selector, '')) LIKE ?
+      OR lower(COALESCE(ep.project_root, '')) LIKE ?
+    )`);
+    const pattern = `%${query}%`;
+    params.push(pattern, pattern, pattern, pattern, pattern);
+  }
+  params.push(limit);
   const lastMessageAt = new Map(db().prepare(`SELECT actor_id, MAX(${messageCreatedAtExpression}) AS last_at FROM messages GROUP BY actor_id`).all().map((r) => [r.actor_id, r.last_at]));
   const rows = db().prepare(`SELECT
        a.id,
@@ -19508,9 +20848,9 @@ function queryMobileAgents(limit = 50) {
      FROM agents a
      JOIN actors ac ON ac.id = a.id
      ${LATEST_AGENT_ENDPOINT_JOIN}
-     WHERE ${activeAgentMetadataPredicate("a")}
+     WHERE ${whereClauses.join(" AND ")}
      ORDER BY COALESCE(${endpointUpdatedAtExpression}, 0) DESC, ac.display_name ASC
-     LIMIT ?`).all(limit);
+     LIMIT ?`).all(...params);
   return rows.map((r) => {
     let meta = {};
     try {
@@ -19619,6 +20959,9 @@ function queryMobileAgentDetail(agentId) {
 }
 // ../web/server/db/mobile/sessions.ts
 function queryMobileSessions(limit = 50) {
+  const conversationCreatedAtExpression = sqlTimestampMsExpression("c.created_at");
+  const messageCreatedAtExpression = sqlTimestampMsExpression("created_at");
+  const previewMessageCreatedAtExpression = sqlTimestampMsExpression("m.created_at");
   const rows = db().prepare(`SELECT
        c.id,
        c.kind,
@@ -19626,16 +20969,16 @@ function queryMobileSessions(limit = 50) {
        c.metadata_json
      FROM conversations c
      WHERE c.kind = 'direct'
-     ORDER BY c.created_at DESC
+     ORDER BY ${conversationCreatedAtExpression} DESC
      LIMIT ?`).all(limit);
   const memberStmt = db().prepare(`SELECT actor_id FROM conversation_members WHERE conversation_id = ?`);
-  const statsStmt = db().prepare(`SELECT COUNT(*) AS cnt, MAX(created_at) AS last_at FROM messages WHERE conversation_id = ?`);
+  const statsStmt = db().prepare(`SELECT COUNT(*) AS cnt, MAX(${messageCreatedAtExpression}) AS last_at FROM messages WHERE conversation_id = ?`);
   const previewStmt = db().prepare(`SELECT body
      FROM messages m
      WHERE conversation_id = ?
        AND actor_id != 'operator'
        AND ${transientBrokerWorkingStatusPredicate("m")}
-     ORDER BY created_at DESC LIMIT 1`);
+     ORDER BY ${previewMessageCreatedAtExpression} DESC LIMIT 1`);
   return rows.map((r) => {
     const participants = memberStmt.all(r.id).map((m) => m.actor_id);
     const agentId = participants.find((p) => p !== "operator") ?? null;
@@ -19741,6 +21084,716 @@ function queryMobileWorkspaces(limit = 50) {
   }
   return results;
 }
+// ../web/server/scoutbot/directives.ts
+var ACTIONS = new Set([
+  "help",
+  "agents",
+  "status",
+  "recent",
+  "doing",
+  "flight",
+  "steer"
+]);
+var EFFORT_ALIASES = {
+  none: "none",
+  off: "none",
+  minimal: "minimal",
+  min: "minimal",
+  low: "low",
+  quick: "low",
+  medium: "medium",
+  med: "medium",
+  mid: "medium",
+  high: "high",
+  deep: "high",
+  xhigh: "xhigh",
+  max: "xhigh"
+};
+var EFFORT_KEYS = new Set(["eff", "effort", "reasoning", "reasoning-effort", "reasoning_effort"]);
+var SESSION_KEYS = new Set(["sid", "session", "session-id", "session_id", "target-session", "target_session"]);
+function parseScoutbotDirectives(input) {
+  const original = input.trim();
+  const rawTokens = original.split(/\s+/).filter(Boolean);
+  const directives = {};
+  const bodyTokens = [];
+  const messageTokens = [];
+  let command = null;
+  let commandIndex = -1;
+  for (let index = 0;index < rawTokens.length; index += 1) {
+    const token = rawTokens[index] ?? "";
+    const directive = parseDirectiveToken(token);
+    if (directive) {
+      if (directive.kind === "reasoningEffort") {
+        directives.reasoningEffort = directive.value;
+      } else {
+        directives.targetSessionId = directive.value;
+      }
+      continue;
+    }
+    messageTokens.push(token);
+    const action = command ? null : parseActionToken(token);
+    if (action) {
+      command = { name: action, raw: token };
+      commandIndex = index;
+      continue;
+    }
+    bodyTokens.push(token);
+  }
+  const args = command ? rawTokens.slice(commandIndex + 1).filter((token) => !parseDirectiveToken(token) && !parseActionToken(token)).join(" ").trim() : "";
+  return {
+    original,
+    body: bodyTokens.join(" ").trim(),
+    messageBody: messageTokens.join(" ").trim(),
+    command: command ? { ...command, args } : null,
+    directives
+  };
+}
+function scoutbotDirectiveMetadata(parsed) {
+  const metadata = {};
+  if (parsed.command)
+    metadata.scoutbotAction = parsed.command.name;
+  if (parsed.directives.reasoningEffort)
+    metadata.reasoningEffort = parsed.directives.reasoningEffort;
+  if (parsed.directives.targetSessionId)
+    metadata.targetSessionId = parsed.directives.targetSessionId;
+  if ((parsed.directives.reasoningEffort || parsed.directives.targetSessionId) && parsed.body && parsed.body !== parsed.original) {
+    metadata.directiveBody = parsed.body;
+  }
+  return metadata;
+}
+function parseActionToken(rawToken) {
+  const token = trimTokenBoundary(rawToken);
+  const match = token.match(/^\/([A-Za-z][A-Za-z0-9_-]*)$/);
+  if (!match?.[1])
+    return null;
+  const action = match[1].toLowerCase().replace(/-/g, "_");
+  return ACTIONS.has(action) ? action : null;
+}
+function parseDirectiveToken(rawToken) {
+  const token = trimTokenBoundary(rawToken);
+  const separator = token.indexOf(":");
+  if (separator <= 0)
+    return null;
+  const key = token.slice(0, separator).trim().toLowerCase();
+  const value = normalizeDirectiveValue(token.slice(separator + 1));
+  if (!value)
+    return null;
+  if (EFFORT_KEYS.has(key)) {
+    const effort = EFFORT_ALIASES[value.toLowerCase()];
+    return effort ? { kind: "reasoningEffort", value: effort } : null;
+  }
+  if (SESSION_KEYS.has(key) && isValidSessionId(value)) {
+    return { kind: "targetSessionId", value };
+  }
+  return null;
+}
+function normalizeDirectiveValue(value) {
+  return trimTokenBoundary(value).replace(/^["']+|["']+$/g, "").trim();
+}
+function trimTokenBoundary(value) {
+  return value.trim().replace(/^[([{]+/g, "").replace(/[)\]},.!?;]+$/g, "");
+}
+function isValidSessionId(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value);
+}
+
+// ../web/server/scoutbot/role.ts
+var SCOUTBOT_AGENT_ID = "scoutbot";
+var SCOUTBOT_DISPLAY_NAME = "Scout";
+var SCOUTBOT_HANDLE = "scoutbot";
+var SCOUTBOT_DEFAULT_THREAD_ID = "thr-default";
+var SCOUTBOT_DEFAULT_THREAD_NAME = "default";
+var SCOUTBOT_DEFAULT_CONVERSATION_ID = "dm.operator.scoutbot.default";
+var SCOUTBOT_LEGACY_CONVERSATION_ID = "dm.operator.scoutbot";
+var SCOUTBOT_ENDPOINT_ID = "endpoint.scoutbot.codex_app_server";
+var SCOUTBOT_RUNTIME_INSTANCE_ID = "scoutbot-default";
+var SCOUTBOT_REASONING_EFFORT = "low";
+var SCOUTBOT_SYSTEM_PROMPT = `# Scoutbot role
+
+You are Scoutbot, the operator-facing concierge for the local OpenScout fleet.
+
+Your job is to read broker state, explain what is happening, and perform structured broker operations on the operator's behalf. You do not write code, edit files, or run shell commands. If a task requires project work, ask or dispatch the appropriate project agent instead of doing that work yourself.
+
+## Operating loop
+
+Default to a low-effort triage pass. Your first move is to read the current broker facts and recent thread context, then answer directly if the operator is asking for status, latest activity, who is blocked, what changed, routing, or a next-action recommendation.
+
+For status questions such as "what's latest on Hudson", answer from broker facts in a few bullets:
+- current state
+- most recent activity
+- blocker or risk
+- suggested next action
+
+Do not start a broad investigation, inspect code, or dispatch project work unless the operator asks for that next step.
+
+## Inline answers
+
+Answer inline when the request can be handled from broker state, recent messages, active flights, agent registrations, endpoint state, or known routing metadata. Keep these answers short and explicit. Separate observed facts from inference.
+
+## Offloading
+
+Offload with structured broker operations when the request requires a project agent to inspect files, run commands, reproduce a bug, write code, review a diff, research a repo, operate a UI, or own multi-step work. Pick the agent by explicit routing metadata or by the closest matching project/workspace identity. If the target is ambiguous, ask one clarifying question instead of guessing.
+
+Use send_message for tells/status nudges. Use ask_agent or dispatch_subagent when the meaning is "own this and report back". Use cancel_flight only for a specific active flight the operator wants stopped.
+
+## Parallelism
+
+Use parallel asks only when the work naturally splits into independent lanes, for example frontend and backend investigation, reproduce and log inspection, docs and implementation review, or several agents owning separate repos. Keep fanout bounded, usually two to four agents. Do not parallelize when agents would edit the same files, depend on a single sequence, or need one owner to make a coherent decision.
+
+When you fan out, tell the operator who owns each lane and what result you expect back. Prefer an explicit channel for group coordination; use DMs for one-agent work.
+
+## Tools and routing
+
+Use read-only broker tools first: list_agents, list_endpoints, list_flights, latest_messages, and current_turn. For writes, use only structured broker tools: send_message, ask_agent, dispatch_subagent, and cancel_flight. No shell access. No codebase writes.
+
+Routing must be explicit. Resolve targets before broker writes; do not rely on body mentions as instructions. Every broker write you emit must carry Scoutbot provenance so the operator can audit why it happened.
+
+Prefer concise operational answers. Use the deterministic broker facts available to you, say when you are inferring, and keep follow-up in the same Scout thread unless the operator explicitly asks otherwise.`;
+var SCOUTBOT_ROLE_CONFIG = {
+  roleId: "scoutbot",
+  systemPrompt: SCOUTBOT_SYSTEM_PROMPT,
+  grants: {
+    read: [
+      "list_agents",
+      "list_endpoints",
+      "list_flights",
+      "latest_messages",
+      "current_turn"
+    ],
+    write: [
+      "send_message",
+      "ask_agent",
+      "dispatch_subagent",
+      "cancel_flight"
+    ],
+    shell: false,
+    codebaseWrites: false
+  },
+  defaults: {
+    requestedBy: "operator",
+    provenanceSource: "scoutbot",
+    generatedBy: "scoutbot",
+    cwdPolicy: "openscout_control_plane",
+    reasoningEffort: SCOUTBOT_REASONING_EFFORT
+  }
+};
+
+// ../web/server/scoutbot/thread-map.ts
+init_support_paths();
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname12, join as join24 } from "path";
+class ScoutbotThreadMapStore {
+  filePath;
+  constructor(filePath = defaultScoutbotThreadMapPath()) {
+    this.filePath = filePath;
+  }
+  async getThreads() {
+    const map = await this.read();
+    return map.threads.filter((thread) => !thread.archivedAt);
+  }
+  async list() {
+    const map = await this.read();
+    return {
+      threads: map.threads.filter((thread) => !thread.archivedAt),
+      defaultThreadId: map.defaultThreadId
+    };
+  }
+  async getThread(threadId) {
+    const normalized = threadId.trim();
+    if (!normalized)
+      return null;
+    const map = await this.read();
+    return map.threads.find((thread) => thread.threadId === normalized && !thread.archivedAt) ?? null;
+  }
+  async getThreadByConversationId(conversationId) {
+    const normalized = conversationId.trim();
+    if (!normalized)
+      return null;
+    const map = await this.read();
+    return map.threads.find((thread) => thread.conversationId === normalized && !thread.archivedAt) ?? null;
+  }
+  async ensureDefaultThread(options) {
+    const now = options.now ?? Date.now();
+    const map = await this.read();
+    const existing = map.threads.find((thread2) => thread2.threadId === map.defaultThreadId);
+    if (existing) {
+      const next = {
+        ...existing,
+        transportSessionId: options.transportSessionId !== undefined ? normalizeSessionId(options.transportSessionId) : existing.transportSessionId,
+        transport: options.transport ?? existing.transport
+      };
+      if (sameThread(existing, next))
+        return existing;
+      const updated = replaceThread(map, next);
+      await this.write(updated);
+      return next;
+    }
+    const conversationId = chooseDefaultConversationId(options.snapshot);
+    const thread = {
+      threadId: SCOUTBOT_DEFAULT_THREAD_ID,
+      name: SCOUTBOT_DEFAULT_THREAD_NAME,
+      conversationId,
+      transportSessionId: normalizeSessionId(options.transportSessionId),
+      transport: options.transport ?? "codex_app_server",
+      pins: null,
+      lastActiveAt: now
+    };
+    await this.write({
+      version: 1,
+      defaultThreadId: SCOUTBOT_DEFAULT_THREAD_ID,
+      threads: [thread]
+    });
+    return thread;
+  }
+  async createThread(name, opts) {
+    const map = await this.read();
+    const now = opts.now ?? Date.now();
+    const threadId = opts.threadId?.trim() || `thr-${now.toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+    const conversationId = opts.conversationId?.trim() || `dm.operator.scoutbot.${threadId.replace(/^thr-/, "")}`;
+    const thread = {
+      threadId,
+      name: name.trim() || threadId,
+      conversationId,
+      transportSessionId: normalizeSessionId(opts.transportSessionId),
+      transport: opts.transport ?? "codex_app_server",
+      pins: opts.pins ?? null,
+      lastActiveAt: now
+    };
+    await this.write({
+      ...map,
+      threads: [...map.threads.filter((candidate) => candidate.threadId !== threadId), thread]
+    });
+    return thread;
+  }
+  async archiveThread(threadId) {
+    const map = await this.read();
+    const thread = map.threads.find((candidate) => candidate.threadId === threadId);
+    if (!thread || thread.threadId === map.defaultThreadId)
+      return null;
+    const archived = { ...thread, archivedAt: Date.now() };
+    await this.write(replaceThread(map, archived));
+    return archived;
+  }
+  async touchThread(threadId, now = Date.now()) {
+    const map = await this.read();
+    const thread = map.threads.find((candidate) => candidate.threadId === threadId);
+    if (!thread)
+      return;
+    await this.write(replaceThread(map, { ...thread, lastActiveAt: now }));
+  }
+  async setThreadTransportSessionId(threadId, transportSessionId, now = Date.now()) {
+    const normalized = normalizeSessionId(transportSessionId);
+    const map = await this.read();
+    const thread = map.threads.find((candidate) => candidate.threadId === threadId);
+    if (!thread)
+      return null;
+    const next = { ...thread, transportSessionId: normalized, lastActiveAt: now };
+    if (sameThread(thread, next))
+      return thread;
+    await this.write(replaceThread(map, next));
+    return next;
+  }
+  async read() {
+    try {
+      const raw = await readFile7(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const threads = Array.isArray(parsed.threads) ? parsed.threads.filter(isThreadRecord).map((thread) => ({
+        ...thread,
+        transportSessionId: normalizeSessionId(thread.transportSessionId)
+      })) : [];
+      return {
+        version: 1,
+        defaultThreadId: typeof parsed.defaultThreadId === "string" && parsed.defaultThreadId.trim() ? parsed.defaultThreadId : SCOUTBOT_DEFAULT_THREAD_ID,
+        threads
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { version: 1, defaultThreadId: SCOUTBOT_DEFAULT_THREAD_ID, threads: [] };
+      }
+      throw error;
+    }
+  }
+  async write(map) {
+    await mkdir7(dirname12(this.filePath), { recursive: true });
+    await writeFile7(this.filePath, `${JSON.stringify(map, null, 2)}
+`, "utf8");
+  }
+}
+function defaultScoutbotThreadMapPath() {
+  return join24(resolveOpenScoutSupportPaths().supportDirectory, "scoutbot-threads.json");
+}
+function chooseDefaultConversationId(snapshot) {
+  return snapshot?.conversations?.[SCOUTBOT_LEGACY_CONVERSATION_ID] ? SCOUTBOT_LEGACY_CONVERSATION_ID : SCOUTBOT_DEFAULT_CONVERSATION_ID;
+}
+function buildScoutbotThreadConversation(thread, snapshot, nodeId) {
+  const existing = snapshot.conversations[thread.conversationId];
+  if (existing)
+    return null;
+  const participantIds = ["operator", "scoutbot"].sort();
+  return {
+    id: thread.conversationId,
+    kind: "direct",
+    title: thread.name === SCOUTBOT_DEFAULT_THREAD_NAME ? "Scout \xB7 default" : `Scout \xB7 ${thread.name}`,
+    visibility: "private",
+    shareMode: "local",
+    authorityNodeId: nodeId,
+    participantIds,
+    metadata: {
+      surface: "scoutbot",
+      scoutbotThreadId: thread.threadId,
+      transportSessionId: thread.transportSessionId,
+      transport: thread.transport
+    }
+  };
+}
+function isThreadRecord(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record = value;
+  return typeof record.threadId === "string" && typeof record.name === "string" && typeof record.conversationId === "string" && (typeof record.transportSessionId === "string" || record.transportSessionId === null || record.transportSessionId === undefined) && typeof record.transport === "string" && typeof record.lastActiveAt === "number";
+}
+function normalizeSessionId(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : null;
+}
+function replaceThread(map, thread) {
+  return {
+    ...map,
+    threads: map.threads.map((candidate) => candidate.threadId === thread.threadId ? thread : candidate)
+  };
+}
+function sameThread(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+// ../web/server/scoutbot/runner.ts
+var defaultLog = {
+  info: (msg) => {
+    console.log(`[scoutbot] ${msg}`);
+  },
+  warn: (msg) => {
+    console.warn(`[scoutbot] ${msg}`);
+  }
+};
+async function postScoutbotOperatorMessage(input) {
+  const log2 = input.log ?? defaultLog;
+  const baseUrl = input.brokerBaseUrl ?? resolveScoutBrokerUrl();
+  const threadMap = input.threadMap ?? new ScoutbotThreadMapStore;
+  if (input.bootstrap) {
+    const prepared = await ensureScoutbotBootstrapped({
+      baseUrl,
+      currentDirectory: input.currentDirectory,
+      threadMap,
+      log: log2
+    });
+    if (!prepared) {
+      return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
+    }
+  }
+  const thread = await resolvePostTargetThread({
+    baseUrl,
+    threadMap,
+    threadId: input.threadId
+  });
+  if (!thread) {
+    if (input.threadId?.trim()) {
+      throw new Error(`Unknown scoutbot thread ${input.threadId}`);
+    }
+    return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
+  }
+  if (input.threadId?.trim() && thread.threadId !== input.threadId.trim()) {
+    throw new Error(`Unknown scoutbot thread ${input.threadId}`);
+  }
+  return postOperatorThreadMessage({
+    baseUrl,
+    thread,
+    body: input.body,
+    source: input.source ?? "scout-web",
+    clientMessageId: input.clientMessageId,
+    replyToMessageId: input.replyToMessageId,
+    referenceMessageIds: input.referenceMessageIds,
+    deviceId: input.deviceId,
+    log: log2
+  });
+}
+async function resolvePostTargetThread(input) {
+  const explicitThreadId = input.threadId?.trim();
+  if (explicitThreadId) {
+    return input.threadMap.getThread(explicitThreadId);
+  }
+  const threadList = await input.threadMap.list();
+  const existing = threadList.threads.find((candidate) => candidate.threadId === threadList.defaultThreadId) ?? null;
+  if (existing)
+    return existing;
+  const ctx = await loadScoutBrokerContext(input.baseUrl);
+  if (!ctx)
+    return null;
+  return input.threadMap.ensureDefaultThread({
+    snapshot: ctx.snapshot,
+    transportSessionId: null,
+    transport: "codex_app_server"
+  });
+}
+async function ensureScoutbotBootstrapped(input) {
+  const ctx = await loadScoutBrokerContext(input.baseUrl);
+  if (!ctx) {
+    input.log.warn(`broker unreachable at ${input.baseUrl}; runner is inert`);
+    return false;
+  }
+  await ensureScoutbotRegistered(input.baseUrl, ctx.snapshot, ctx.node.id, input.currentDirectory, input.log);
+  const refreshed = await loadScoutBrokerContext(input.baseUrl);
+  const snapshot = refreshed?.snapshot ?? ctx.snapshot;
+  const nodeId = refreshed?.node.id ?? ctx.node.id;
+  const endpoint = findScoutbotEndpoint(snapshot, nodeId) ?? buildScoutbotEndpoint(nodeId, input.currentDirectory);
+  const warmedEndpoint = await ensureScoutbotEndpointSession(input.baseUrl, endpoint, input.log);
+  const transportSessionId = scoutbotEndpointTransportSessionId(warmedEndpoint);
+  const thread = await input.threadMap.ensureDefaultThread({
+    snapshot,
+    transportSessionId,
+    transport: endpoint.transport ?? "codex_app_server"
+  });
+  const latest = await loadScoutBrokerContext(input.baseUrl);
+  const conversation = buildScoutbotThreadConversation(thread, latest?.snapshot ?? snapshot, latest?.node.id ?? nodeId);
+  if (conversation) {
+    await postJson(input.baseUrl, "/v1/conversations", conversation);
+  }
+  return true;
+}
+async function ensureScoutbotRegistered(baseUrl, snapshot, nodeId, currentDirectory, log2) {
+  const actor = buildScoutbotActor(nodeId);
+  const agent = buildScoutbotAgent(nodeId);
+  const endpoint = normalizeScoutbotEndpoint(findScoutbotEndpoint(snapshot, nodeId), buildScoutbotEndpoint(nodeId, currentDirectory));
+  if (!snapshot.actors?.[SCOUTBOT_AGENT_ID]) {
+    await postJson(baseUrl, "/v1/actors", actor);
+  }
+  const existingAgent = snapshot.agents?.[SCOUTBOT_AGENT_ID];
+  if (!existingAgent || !hasCurrentScoutbotAgentRegistration(existingAgent, nodeId)) {
+    await postJson(baseUrl, "/v1/agents", agent);
+  }
+  const existingEndpoint = findScoutbotEndpoint(snapshot, nodeId);
+  if (!existingEndpoint || existingEndpoint.state === "offline" || existingEndpoint.metadata?.source !== "scoutbot" || !hasCurrentScoutbotRuntimeConfig(existingEndpoint) || isInvalidScoutbotSessionEndpoint(existingEndpoint)) {
+    await postJson(baseUrl, "/v1/endpoints", endpoint);
+    log2.info(`registered endpoint ${endpoint.id}`);
+  }
+}
+function buildScoutbotActor(_nodeId) {
+  return {
+    id: SCOUTBOT_AGENT_ID,
+    kind: "agent",
+    displayName: SCOUTBOT_DISPLAY_NAME,
+    handle: SCOUTBOT_HANDLE,
+    labels: ["assistant", "scout", "scoutbot"],
+    metadata: {
+      source: "scoutbot",
+      role: "operator-assistant"
+    }
+  };
+}
+function buildScoutbotAgent(nodeId) {
+  return {
+    ...buildScoutbotActor(nodeId),
+    kind: "agent",
+    definitionId: SCOUTBOT_HANDLE,
+    selector: `@${SCOUTBOT_HANDLE}`,
+    defaultSelector: `@${SCOUTBOT_HANDLE}`,
+    agentClass: "operator",
+    capabilities: ["chat", "invoke", "deliver"],
+    wakePolicy: "keep_warm",
+    homeNodeId: nodeId,
+    authorityNodeId: nodeId,
+    advertiseScope: "local",
+    metadata: {
+      source: "scoutbot",
+      role: "operator-assistant",
+      summary: "Operator-facing fleet concierge backed by the broker's local session adapter.",
+      roleConfig: SCOUTBOT_ROLE_CONFIG
+    }
+  };
+}
+function buildScoutbotEndpoint(nodeId, currentDirectory) {
+  const reasoningEffort = SCOUTBOT_ROLE_CONFIG.defaults.reasoningEffort;
+  return {
+    id: `${SCOUTBOT_ENDPOINT_ID}.${nodeId}`,
+    agentId: SCOUTBOT_AGENT_ID,
+    nodeId,
+    harness: "codex",
+    transport: "codex_app_server",
+    state: "waiting",
+    cwd: currentDirectory,
+    projectRoot: currentDirectory,
+    metadata: {
+      source: "scoutbot",
+      managedByScout: true,
+      sessionBacked: true,
+      externalSource: "local-session",
+      attachedTransport: "codex_app_server",
+      agentName: SCOUTBOT_AGENT_ID,
+      definitionId: SCOUTBOT_HANDLE,
+      runtimeInstanceId: SCOUTBOT_RUNTIME_INSTANCE_ID,
+      roleConfig: SCOUTBOT_ROLE_CONFIG,
+      systemPrompt: SCOUTBOT_ROLE_CONFIG.systemPrompt,
+      toolGrants: SCOUTBOT_ROLE_CONFIG.grants,
+      reasoningEffort,
+      launchArgs: ["--reasoning-effort", reasoningEffort],
+      projectRoot: currentDirectory,
+      transport: "codex_app_server",
+      startedAt: String(Date.now())
+    }
+  };
+}
+function findScoutbotEndpoint(snapshot, nodeId) {
+  const endpoints = Object.values(snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === SCOUTBOT_AGENT_ID && endpoint.transport === "codex_app_server");
+  return endpoints.find((endpoint) => endpoint.nodeId === nodeId && endpoint.state !== "offline") ?? endpoints.find((endpoint) => endpoint.state !== "offline") ?? endpoints[0] ?? null;
+}
+function normalizeScoutbotEndpoint(existing, fallback) {
+  if (!existing || isInvalidScoutbotSessionEndpoint(existing))
+    return fallback;
+  const existingMetadata = { ...existing.metadata ?? {} };
+  delete existingMetadata.threadId;
+  delete existingMetadata.externalSessionId;
+  delete existingMetadata.targetSessionId;
+  return {
+    ...fallback,
+    id: existing.id || fallback.id,
+    state: existing.state === "offline" ? "waiting" : existing.state,
+    metadata: {
+      ...existingMetadata,
+      ...fallback.metadata ?? {}
+    }
+  };
+}
+function isInvalidScoutbotSessionEndpoint(endpoint) {
+  const lastError = String(endpoint.metadata?.lastError ?? "").toLowerCase();
+  return lastError.includes("no rollout found for thread id") || lastError.includes("codex_app_server session unavailable") || lastError.includes("session unavailable");
+}
+function hasCurrentScoutbotRuntimeConfig(endpoint) {
+  return metadataString5(endpoint.metadata, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt && metadataString5(endpoint.metadata, "reasoningEffort") === SCOUTBOT_ROLE_CONFIG.defaults.reasoningEffort;
+}
+function scoutbotEndpointTransportSessionId(endpoint) {
+  if (isInvalidScoutbotSessionEndpoint(endpoint))
+    return null;
+  return metadataString5(endpoint.metadata, "threadId") ?? metadataString5(endpoint.metadata, "externalSessionId") ?? endpoint.sessionId?.trim() ?? null;
+}
+async function ensureScoutbotEndpointSession(baseUrl, endpoint, log2) {
+  try {
+    const result = await postJson(baseUrl, "/v1/local-sessions/ensure", { agentId: endpoint.agentId, endpointId: endpoint.id }, { timeoutMs: 2000 });
+    return result.endpoint ?? endpoint;
+  } catch (error) {
+    log2.warn(`session warmup skipped: ${describeError(error)}`);
+    return endpoint;
+  }
+}
+async function postOperatorThreadMessage(input) {
+  const ctx = await loadScoutBrokerContext(input.baseUrl);
+  if (!ctx) {
+    return { usedBroker: false, invokedTargets: [], unresolvedTargets: [] };
+  }
+  const conversation = ctx.snapshot.conversations[input.thread.conversationId] ?? buildScoutbotThreadConversation(input.thread, ctx.snapshot, ctx.node.id);
+  if (conversation && !ctx.snapshot.conversations[input.thread.conversationId]) {
+    await postJson(input.baseUrl, "/v1/conversations", conversation);
+  }
+  const parsed = parseScoutbotDirectives(input.body);
+  const now = Date.now();
+  const messageId = createId("msg");
+  const transportSessionId = parsed.directives.targetSessionId ?? input.thread.transportSessionId?.trim() ?? null;
+  await postJson(input.baseUrl, "/v1/messages", {
+    id: messageId,
+    conversationId: input.thread.conversationId,
+    actorId: "operator",
+    originNodeId: ctx.node.id,
+    class: "agent",
+    body: input.body.trim(),
+    replyToMessageId: input.replyToMessageId ?? undefined,
+    mentions: [{ actorId: SCOUTBOT_AGENT_ID, label: "@scoutbot" }],
+    audience: { notify: [SCOUTBOT_AGENT_ID], reason: "direct_message" },
+    visibility: "private",
+    policy: "durable",
+    createdAt: now,
+    metadata: {
+      source: input.source,
+      ...scoutbotDirectiveMetadata(parsed),
+      destinationKind: "scoutbot_thread",
+      destinationId: input.thread.threadId,
+      scoutbotThreadId: input.thread.threadId,
+      ...transportSessionId ? { targetSessionId: transportSessionId } : {},
+      referenceMessageIds: input.referenceMessageIds ?? [],
+      clientMessageId: input.clientMessageId ?? null,
+      ...input.deviceId ? { deviceId: input.deviceId } : {},
+      relayMessageId: messageId,
+      returnAddress: {
+        actorId: "operator",
+        conversationId: input.thread.conversationId,
+        replyToMessageId: messageId,
+        ...transportSessionId ? { sessionId: transportSessionId } : {}
+      }
+    }
+  });
+  return {
+    usedBroker: true,
+    threadId: input.thread.threadId,
+    conversationId: input.thread.conversationId,
+    messageId,
+    invokedTargets: [SCOUTBOT_AGENT_ID],
+    unresolvedTargets: []
+  };
+}
+var TERMINAL_FLIGHT_STATES2 = new Set(["completed", "failed", "cancelled"]);
+async function postJson(baseUrl, path2, body, options = {}) {
+  const controller = options.timeoutMs ? new AbortController : null;
+  const timer = controller && options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : null;
+  try {
+    const res = await fetch(new URL(path2, baseUrl), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      ...controller ? { signal: controller.signal } : {}
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`POST ${path2} ${res.status}${text ? ` - ${text}` : ""}`);
+    }
+    return await res.json().catch(() => ({ ok: true }));
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function hasScoutbotLabels(agent) {
+  const labels = new Set(agent.labels ?? []);
+  return labels.has("assistant") && labels.has("scout") && labels.has("scoutbot");
+}
+function hasCurrentScoutbotAgentRegistration(agent, nodeId) {
+  return hasScoutbotLabels(agent) && hasCurrentScoutbotAgentConfig(agent) && agent.homeNodeId === nodeId && agent.authorityNodeId === nodeId && agent.advertiseScope === "local" && agent.wakePolicy === "keep_warm" && agent.metadata?.source === "scoutbot";
+}
+function hasCurrentScoutbotAgentConfig(agent) {
+  const roleConfig = metadataObject(agent.metadata, "roleConfig");
+  return metadataString5(roleConfig, "systemPrompt") === SCOUTBOT_ROLE_CONFIG.systemPrompt;
+}
+function metadataObject(metadata, key) {
+  const value = metadata?.[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function metadataString5(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+var SCOUTBOT_REASONING_EFFORTS = new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+]);
+function createId(prefix) {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function describeError(cause) {
+  if (cause instanceof Error)
+    return cause.message;
+  return String(cause);
+}
+
 // ../web/server/core/mobile/service.ts
 var DEFAULT_MOBILE_RECENT_TURN_LIMIT = 24;
 var DEFAULT_MOBILE_HISTORY_PAGE_LIMIT = 40;
@@ -19754,10 +21807,31 @@ function normalizeTimestampMs2(value) {
     return null;
   return value > 10000000000 ? Math.floor(value) : Math.floor(value * 1000);
 }
-function metadataString5(metadata, key) {
+function metadataString6(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function metadataBoolean2(metadata, key) {
+  return metadata?.[key] === true;
+}
+function isBrokerRequesterWaitTimeoutStatusMessage(message) {
+  if (message.class !== "status" || metadataString6(message.metadata, "source") !== "broker") {
+    return false;
+  }
+  return message.body.includes("Scout stopped waiting for a synchronous result") || message.body.includes("the requester stopped waiting after");
+}
+function isRequesterWaitTimeoutFlight(flight) {
+  return metadataBoolean2(flight.metadata, "requesterTimedOut") || metadataString6(flight.metadata, "timeoutScope") === "requester_wait" || Boolean(flight.summary?.includes("Scout stopped waiting for a synchronous result"));
+}
+function isInactiveAgent(agent) {
+  return metadataBoolean2(agent?.metadata, "retiredFromFleet") || metadataBoolean2(agent?.metadata, "staleLocalRegistration");
+}
+function isInactiveEndpoint(snapshot, endpoint) {
+  if (!endpoint) {
+    return true;
+  }
+  return metadataBoolean2(endpoint.metadata, "retiredFromFleet") || metadataBoolean2(endpoint.metadata, "staleLocalRegistration") || isInactiveAgent(snapshot.agents[endpoint.agentId]);
+}
 function titleCaseToken(value) {
   return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
 }
@@ -19812,6 +21886,9 @@ async function loadMobileWorkspaceInventory(currentDirectory) {
 function latestMessageByConversation(snapshot) {
   const buckets = new Map;
   for (const message of Object.values(snapshot.messages)) {
+    if (isBrokerRequesterWaitTimeoutStatusMessage(message)) {
+      continue;
+    }
     const next = buckets.get(message.conversationId) ?? [];
     next.push(message);
     buckets.set(message.conversationId, next);
@@ -19830,14 +21907,14 @@ function agentDisplayName(snapshot, agentId) {
   return snapshot.agents[agentId]?.displayName ?? snapshot.actors[agentId]?.displayName ?? agentId;
 }
 function endpointForAgent(snapshot, agentId) {
-  return Object.values(snapshot.endpoints).find((endpoint) => endpoint.agentId === agentId) ?? null;
+  return Object.values(snapshot.endpoints).find((endpoint) => endpoint.agentId === agentId && !isInactiveEndpoint(snapshot, endpoint)) ?? null;
 }
 function buildMobileAgentSummary(snapshot, agent) {
   const endpoint = endpointForAgent(snapshot, agent.id);
   const flights = Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agent.id);
   const hasWorkingFlight = flights.some((flight) => flight.state === "running");
   const lastAuthoredMessageAt = Object.values(snapshot.messages).filter((message) => message.actorId === agent.id).reduce((latest, message) => {
-    const createdAt = normalizeTimestamp2(message.createdAt);
+    const createdAt = normalizeTimestampMs2(message.createdAt);
     return typeof createdAt === "number" && (!latest || createdAt > latest) ? createdAt : latest;
   }, null);
   const state = hasWorkingFlight ? "working" : endpoint && endpoint.state !== "offline" ? "available" : "offline";
@@ -19862,7 +21939,7 @@ function buildMobileSessionSummaries(snapshot) {
     const latestMessage = messages2.at(-1) ?? null;
     const directAgentId = conversation.kind === "direct" ? conversation.participantIds.find((participantId) => participantId !== "operator") ?? null : null;
     const agent = directAgentId ? snapshot.agents[directAgentId] ?? null : null;
-    if (!directAgentId || !agent || messages2.length === 0) {
+    if (!directAgentId || !agent || isInactiveAgent(agent) || messages2.length === 0) {
       return [];
     }
     const endpoint = endpointForAgent(snapshot, directAgentId);
@@ -19877,10 +21954,10 @@ function buildMobileSessionSummaries(snapshot) {
       agentId: directAgentId,
       agentName: directAgentId ? agentDisplayName(snapshot, directAgentId) : null,
       harness: endpoint?.harness ?? null,
-      currentBranch: metadataString5(endpoint?.metadata, "branch") ?? metadataString5(endpoint?.metadata, "workspaceQualifier") ?? metadataString5(agent?.metadata, "branch") ?? metadataString5(agent?.metadata, "workspaceQualifier"),
+      currentBranch: metadataString6(endpoint?.metadata, "branch") ?? metadataString6(endpoint?.metadata, "workspaceQualifier") ?? metadataString6(agent?.metadata, "branch") ?? metadataString6(agent?.metadata, "workspaceQualifier"),
       preview: latestMessage?.body ?? null,
       messageCount: messages2.length,
-      lastMessageAt: normalizeTimestamp2(latestMessage?.createdAt),
+      lastMessageAt: normalizeTimestampMs2(latestMessage?.createdAt),
       workspaceRoot: endpoint?.projectRoot ?? endpoint?.cwd ?? null
     }];
   });
@@ -19888,7 +21965,7 @@ function buildMobileSessionSummaries(snapshot) {
   for (const summary of summaries) {
     const agent = summary.agentId ? snapshot.agents[summary.agentId] : null;
     const endpoint = summary.agentId ? endpointForAgent(snapshot, summary.agentId) : null;
-    const branchQualifier = metadataString5(endpoint?.metadata, "branch") ?? metadataString5(endpoint?.metadata, "workspaceQualifier") ?? metadataString5(agent?.metadata, "branch") ?? metadataString5(agent?.metadata, "workspaceQualifier");
+    const branchQualifier = metadataString6(endpoint?.metadata, "branch") ?? metadataString6(endpoint?.metadata, "workspaceQualifier") ?? metadataString6(agent?.metadata, "branch") ?? metadataString6(agent?.metadata, "workspaceQualifier");
     const identityKey = [
       endpoint?.projectRoot?.trim().toLowerCase(),
       endpoint?.cwd?.trim().toLowerCase(),
@@ -19904,7 +21981,7 @@ function buildMobileSessionSummaries(snapshot) {
   return [...deduped.values()].sort((left, right) => (right.lastMessageAt ?? 0) - (left.lastMessageAt ?? 0));
 }
 function messagesForConversation(snapshot, conversationId) {
-  return Object.values(snapshot.messages).filter((message) => message.conversationId === conversationId).sort((left, right) => (normalizeTimestamp2(left.createdAt) ?? 0) - (normalizeTimestamp2(right.createdAt) ?? 0));
+  return Object.values(snapshot.messages).filter((message) => !isBrokerRequesterWaitTimeoutStatusMessage(message)).filter((message) => message.conversationId === conversationId).sort((left, right) => (normalizeTimestamp2(left.createdAt) ?? 0) - (normalizeTimestamp2(right.createdAt) ?? 0));
 }
 function pageMessagesForConversation(snapshot, conversationId, options = {}) {
   const allMessages = messagesForConversation(snapshot, conversationId);
@@ -19941,7 +22018,7 @@ function pageMessagesForConversation(snapshot, conversationId, options = {}) {
 function latestActiveFlightForAgent(snapshot, agentId) {
   if (!agentId)
     return null;
-  return Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agentId && !["completed", "failed", "cancelled"].includes(flight.state)).sort((left, right) => (normalizeTimestamp2(right.startedAt) ?? 0) - (normalizeTimestamp2(left.startedAt) ?? 0))[0] ?? null;
+  return Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agentId && (flight.state === "running" || flight.state === "waiting") && !isRequesterWaitTimeoutFlight(flight)).sort((left, right) => (normalizeTimestamp2(right.startedAt) ?? 0) - (normalizeTimestamp2(left.startedAt) ?? 0))[0] ?? null;
 }
 async function loadMobileRelayState() {
   const broker = await loadScoutBrokerContext();
@@ -19949,7 +22026,10 @@ async function loadMobileRelayState() {
     return { agents: [], sessions: [] };
   }
   const snapshot = broker.snapshot;
-  const agents = Object.values(snapshot.agents).map((agent) => buildMobileAgentSummary(snapshot, agent)).sort((left, right) => (right.lastActiveAt ?? 0) - (left.lastActiveAt ?? 0) || left.title.localeCompare(right.title));
+  const agents = Object.values(snapshot.agents).filter((agent) => !isInactiveAgent(agent)).filter((agent) => {
+    const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === agent.id);
+    return endpoints.length === 0 || endpoints.some((endpoint) => !isInactiveEndpoint(snapshot, endpoint));
+  }).map((agent) => buildMobileAgentSummary(snapshot, agent)).sort((left, right) => (right.lastActiveAt ?? 0) - (left.lastActiveAt ?? 0) || left.title.localeCompare(right.title));
   return {
     agents,
     sessions: buildMobileSessionSummaries(snapshot)
@@ -20028,10 +22108,10 @@ async function getScoutMobileSessionSnapshot(conversationId, options = {}, curre
   const messages2 = messagePage.messages;
   const activeFlight = latestActiveFlightForAgent(snapshot, directAgentId);
   const lastAgentMessageAt = messages2.filter((message) => message.actorId === directAgentId).reduce((latest, message) => {
-    const createdAt = normalizeTimestamp2(message.createdAt);
+    const createdAt = normalizeTimestampMs2(message.createdAt);
     return typeof createdAt === "number" && (!latest || createdAt > latest) ? createdAt : latest;
   }, null);
-  const shouldShowWorkingTurn = Boolean(activeFlight && (normalizeTimestamp2(activeFlight.startedAt) ?? 0) > (lastAgentMessageAt ?? 0));
+  const shouldShowWorkingTurn = Boolean(activeFlight && (normalizeTimestampMs2(activeFlight.startedAt) ?? 0) > (lastAgentMessageAt ?? 0));
   const turns = messages2.map((message) => ({
     id: message.id,
     status: "completed",
@@ -20086,8 +22166,8 @@ async function getScoutMobileSessionSnapshot(conversationId, options = {}, curre
         selector: agent?.selector ?? null,
         defaultSelector: agent?.defaultSelector ?? null,
         project: directAgentId ? agentDisplayName(snapshot, directAgentId) : conversation.title,
-        currentBranch: metadataString5(endpoint?.metadata, "branch") ?? metadataString5(endpoint?.metadata, "workspaceQualifier") ?? metadataString5(agent?.metadata, "branch") ?? metadataString5(agent?.metadata, "workspaceQualifier"),
-        workspaceQualifier: metadataString5(endpoint?.metadata, "workspaceQualifier") ?? metadataString5(agent?.metadata, "workspaceQualifier")
+        currentBranch: metadataString6(endpoint?.metadata, "branch") ?? metadataString6(endpoint?.metadata, "workspaceQualifier") ?? metadataString6(agent?.metadata, "branch") ?? metadataString6(agent?.metadata, "workspaceQualifier"),
+        workspaceQualifier: metadataString6(endpoint?.metadata, "workspaceQualifier") ?? metadataString6(agent?.metadata, "workspaceQualifier")
       }
     },
     history: {
@@ -20105,7 +22185,7 @@ async function createScoutSession(input, currentDirectory, deviceId) {
     throw new Error(`Invalid workspaceId.`);
   }
   const workspaceRoot = resolve7(rawWorkspaceId);
-  const projectName = basename9(workspaceRoot) || workspaceRoot;
+  const projectName = basename10(workspaceRoot) || workspaceRoot;
   const workspace = {
     id: workspaceRoot,
     title: projectName,
@@ -20180,6 +22260,24 @@ async function createScoutSession(input, currentDirectory, deviceId) {
   };
 }
 async function sendScoutMobileMessage(input, currentDirectory, deviceId) {
+  if (input.agentId === SCOUTBOT_AGENT_ID) {
+    const result = await postScoutbotOperatorMessage({
+      currentDirectory: currentDirectory ?? process.cwd(),
+      body: input.body,
+      source: "scout-mobile",
+      clientMessageId: input.clientMessageId,
+      replyToMessageId: input.replyToMessageId,
+      referenceMessageIds: input.referenceMessageIds,
+      deviceId
+    });
+    if (!result.usedBroker || !result.conversationId || !result.messageId) {
+      throw new Error("Scoutbot is not available.");
+    }
+    return {
+      conversationId: result.conversationId,
+      messageId: result.messageId
+    };
+  }
   return sendScoutDirectMessage({
     agentId: input.agentId,
     body: input.body,
@@ -20216,8 +22314,8 @@ async function deriveNewAgentName(projectName, branch, harness) {
 }
 async function createGitWorktree(projectRoot, agentName, requestedBranch) {
   const { execFileSync: execFileSync5 } = await import("child_process");
-  const { join: join23 } = await import("path");
-  const { mkdirSync: mkdirSync10, existsSync: existsSync18 } = await import("fs");
+  const { join: join25 } = await import("path");
+  const { mkdirSync: mkdirSync11, existsSync: existsSync19 } = await import("fs");
   try {
     execFileSync5("git", ["rev-parse", "--git-dir"], { cwd: projectRoot, stdio: "pipe" });
   } catch {
@@ -20225,12 +22323,12 @@ async function createGitWorktree(projectRoot, agentName, requestedBranch) {
   }
   const normalizedRequestedBranch = requestedBranch?.trim();
   const branchName = normalizedRequestedBranch || `scout/${agentName}`;
-  const worktreeDir = join23(projectRoot, ".scout-worktrees");
-  const worktreePath = join23(worktreeDir, agentName);
-  if (existsSync18(worktreePath)) {
+  const worktreeDir = join25(projectRoot, ".scout-worktrees");
+  const worktreePath = join25(worktreeDir, agentName);
+  if (existsSync19(worktreePath)) {
     return { path: worktreePath, branch: branchName };
   }
-  mkdirSync10(worktreeDir, { recursive: true });
+  mkdirSync11(worktreeDir, { recursive: true });
   try {
     execFileSync5("git", ["worktree", "add", "-b", branchName, worktreePath], { cwd: projectRoot, stdio: "pipe" });
     return { path: worktreePath, branch: branchName };
@@ -20431,9 +22529,9 @@ async function handleRPCInner(bridge, req, deviceId) {
       }
       case "session/resume": {
         const p = req.params;
-        const sessionFilename = basename10(p.sessionPath, ".jsonl");
+        const sessionFilename = basename11(p.sessionPath, ".jsonl");
         const parentDir = p.sessionPath.substring(0, p.sessionPath.lastIndexOf("/"));
-        const dirName = basename10(parentDir);
+        const dirName = basename11(parentDir);
         let cwd;
         if (dirName.startsWith("-")) {
           const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -20500,7 +22598,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
         const adapterType = p.adapter ?? "claude-code";
-        const name = p.name ?? basename10(projectPath);
+        const name = p.name ?? basename11(projectPath);
         const session = await bridge.createSession(adapterType, {
           name,
           cwd: projectPath
@@ -20622,7 +22720,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Only .jsonl files can be read" } };
         }
         try {
-          const content = readFileSync12(p.path, "utf-8");
+          const content = readFileSync13(p.path, "utf-8");
           const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
           const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -20740,13 +22838,13 @@ function resolveMobileCurrentDirectory() {
   }
 }
 function resolveWorkspaceRoot(root) {
-  const expandedRoot = root.replace(/^~/, homedir21());
+  const expandedRoot = root.replace(/^~/, homedir22());
   return realpathSync(expandedRoot);
 }
 function resolveWorkspacePath(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir21());
-  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join23(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir22());
+  const candidate = expandedPath ? isAbsolute3(expandedPath) ? expandedPath : join25(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync(candidate);
   const rel = relative3(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute3(rel)) {
@@ -20776,7 +22874,7 @@ function listDirectories(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join23(dirPath, name);
+    const fullPath = join25(dirPath, name);
     try {
       const stat4 = statSync5(fullPath);
       if (!stat4.isDirectory())
@@ -20799,7 +22897,7 @@ function listDirectories(dirPath) {
   return entries.sort((a, b) => a.name.localeCompare(b.name));
 }
 async function discoverSessionFiles(maxAgeDays, limit) {
-  const home = homedir21();
+  const home = homedir22();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -35444,7 +37542,7 @@ function planMessageDeliveries(input) {
   }
   return [...deliveries2.values()];
 }
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/entity.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/entity.js
 var entityKind = Symbol.for("drizzle:entityKind");
 var hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
 function is(value, type) {
@@ -35469,7 +37567,7 @@ function is(value, type) {
   return false;
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/column.js
 class Column {
   constructor(table, config2) {
     this.table = table;
@@ -35519,7 +37617,7 @@ class Column {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/column-builder.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/column-builder.js
 class ColumnBuilder {
   static [entityKind] = "ColumnBuilder";
   config;
@@ -35575,20 +37673,20 @@ class ColumnBuilder {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.utils.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/table.utils.js
 var TableName = Symbol.for("drizzle:Name");
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing-utils.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/tracing-utils.js
 function iife(fn, ...args) {
   return fn(...args);
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/unique-constraint.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/pg-core/unique-constraint.js
 function uniqueKeyName(table, columns) {
   return `${table[TableName]}_${columns.join("_")}_unique`;
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/common.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/pg-core/columns/common.js
 class PgColumn extends Column {
   constructor(table, config2) {
     if (!config2.uniqueName) {
@@ -35637,7 +37735,7 @@ class ExtraConfigColumn extends PgColumn {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/columns/enum.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/pg-core/columns/enum.js
 class PgEnumObjectColumn extends PgColumn {
   static [entityKind] = "PgEnumObjectColumn";
   enum;
@@ -35667,7 +37765,7 @@ class PgEnumColumn extends PgColumn {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/subquery.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/subquery.js
 class Subquery {
   static [entityKind] = "Subquery";
   constructor(sql, fields, alias, isWith = false, usedTables = []) {
@@ -35682,10 +37780,10 @@ class Subquery {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/version.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/version.js
 var version2 = "0.45.2";
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/tracing.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/tracing.js
 var otel;
 var rawTracer;
 var tracer = {
@@ -35712,10 +37810,10 @@ var tracer = {
   }
 };
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/view-common.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/view-common.js
 var ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/table.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/table.js
 var Schema = Symbol.for("drizzle:Schema");
 var Columns = Symbol.for("drizzle:Columns");
 var ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
@@ -35753,7 +37851,7 @@ class Table {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/sql.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/sql.js
 function isSQLWrapper(value) {
   return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
@@ -36030,7 +38128,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join24(chunks, separator) {
+  function join26(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== undefined) {
@@ -36040,7 +38138,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join24;
+  sql2.join = join26;
   function identifier(value) {
     return new Name(value);
   }
@@ -36113,7 +38211,7 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/utils.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/utils.js
 function getColumnNameAndConfig(a, b) {
   return {
     name: typeof a === "string" && a.length > 0 ? a : "",
@@ -36122,7 +38220,7 @@ function getColumnNameAndConfig(a, b) {
 }
 var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
 class ForeignKeyBuilder {
   static [entityKind] = "SQLiteForeignKeyBuilder";
   reference;
@@ -36176,12 +38274,12 @@ class ForeignKey {
   }
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
 function uniqueKeyName2(table, columns) {
   return `${table[TableName]}_${columns.join("_")}_unique`;
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/common.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/common.js
 class SQLiteColumnBuilder extends ColumnBuilder {
   static [entityKind] = "SQLiteColumnBuilder";
   foreignKeyConfigs = [];
@@ -36232,7 +38330,7 @@ class SQLiteColumn extends Column {
   static [entityKind] = "SQLiteColumn";
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/blob.js
 class SQLiteBigIntBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBigIntBuilder";
   constructor(name) {
@@ -36320,7 +38418,7 @@ function blob(a, b) {
   return new SQLiteBlobBufferBuilder(name);
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/custom.js
 class SQLiteCustomColumnBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteCustomColumnBuilder";
   constructor(name, fieldConfig, customTypeParams) {
@@ -36361,7 +38459,7 @@ function customType(customTypeParams) {
   };
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/integer.js
 class SQLiteBaseIntegerBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteBaseIntegerBuilder";
   constructor(name, dataType, columnType) {
@@ -36463,7 +38561,7 @@ function integer2(a, b) {
   return new SQLiteIntegerBuilder(name);
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
 class SQLiteNumericBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteNumericBuilder";
   constructor(name) {
@@ -36533,7 +38631,7 @@ function numeric(a, b) {
   return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/real.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/real.js
 class SQLiteRealBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteRealBuilder";
   constructor(name) {
@@ -36554,7 +38652,7 @@ function real(name) {
   return new SQLiteRealBuilder(name ?? "");
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/text.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/text.js
 class SQLiteTextBuilder extends SQLiteColumnBuilder {
   static [entityKind] = "SQLiteTextBuilder";
   constructor(name, config2) {
@@ -36609,7 +38707,7 @@ function text(a, b = {}) {
   return new SQLiteTextBuilder(name, config2);
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/all.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/all.js
 function getSQLiteColumnBuilders() {
   return {
     blob,
@@ -36621,7 +38719,7 @@ function getSQLiteColumnBuilders() {
   };
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/table.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/table.js
 var InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
 
 class SQLiteTable extends Table {
@@ -36655,7 +38753,7 @@ var sqliteTable = (name, columns, extraConfig) => {
   return sqliteTableBase(name, columns, extraConfig);
 };
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/indexes.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/indexes.js
 class IndexBuilderOn {
   constructor(name, unique2) {
     this.name = name;
@@ -36699,6 +38797,7 @@ function index(name) {
 }
 
 // ../runtime/src/drizzle-schema.ts
+var epochMsNow = sql`(CAST(strftime('%s','now') AS INTEGER) * 1000)`;
 var deliveriesTable = sqliteTable("deliveries", {
   id: text("id").primaryKey(),
   messageId: text("message_id"),
@@ -36714,7 +38813,7 @@ var deliveriesTable = sqliteTable("deliveries", {
   leaseOwner: text("lease_owner"),
   leaseExpiresAt: integer2("lease_expires_at"),
   metadataJson: text("metadata_json"),
-  createdAt: integer2("created_at").notNull().default(sql`(unixepoch())`)
+  createdAt: integer2("created_at").notNull().default(epochMsNow)
 }, (table) => [
   index("idx_deliveries_status_transport").on(table.status, table.transport)
 ]);
@@ -36741,7 +38840,7 @@ var briefingsTable = sqliteTable("briefings", {
   snapshotJson: text("snapshot_json").notNull(),
   callJson: text("call_json").notNull(),
   markdown: text("markdown"),
-  createdAt: integer2("created_at").notNull().default(sql`(unixepoch())`)
+  createdAt: integer2("created_at").notNull().default(epochMsNow)
 }, (table) => [
   index("idx_briefings_created_at").on(table.createdAt),
   index("idx_briefings_kind_created_at").on(table.kind, table.createdAt)
@@ -37428,6 +39527,9 @@ init_src2();
 // ../runtime/src/drizzle-migrate.ts
 init_support_paths();
 if (false) {}
+
+// ../runtime/src/conversations/api.ts
+init_src2();
 // ../runtime/src/tailscale.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -37442,6 +39544,11 @@ init_support_paths();
 // ../runtime/src/index.ts
 init_broker_process_manager();
 init_broker_api();
+
+// ../runtime/src/invocation-lifecycle-read-model.ts
+init_src2();
+
+// ../runtime/src/index.ts
 init_local_agents();
 
 // ../runtime/src/scout-broker.ts
@@ -37456,6 +39563,7 @@ init_broker_process_manager();
 init_codex_app_server();
 init_setup();
 init_support_paths();
+init_user_config();
 
 // ../runtime/src/thread-events.ts
 class ThreadWatchProtocolError extends Error {
@@ -37692,10 +39800,10 @@ class ThreadEventPlane {
 // ../runtime/src/mobile-push.ts
 init_support_paths();
 import { Database as Database2 } from "bun:sqlite";
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync13 } from "fs";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync14 } from "fs";
 import { connect as connectHttp2 } from "http2";
 import { createPrivateKey, sign as signWithKey } from "crypto";
-import { dirname as dirname11, join as join24 } from "path";
+import { dirname as dirname13, join as join26 } from "path";
 var MOBILE_PUSH_SCHEMA = `
 CREATE TABLE IF NOT EXISTS mobile_push_registrations (
   id TEXT PRIMARY KEY,
@@ -37723,7 +39831,7 @@ var dbHandle = null;
 var dbPath = null;
 var cachedApnsJwt = null;
 function resolveControlPlaneDbPath() {
-  return join24(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
+  return join26(resolveOpenScoutSupportPaths().controlHome, "control-plane.sqlite");
 }
 function ensureMobilePushSchema(database) {
   database.exec("PRAGMA busy_timeout = 5000;");
@@ -37737,7 +39845,7 @@ function writeDb() {
     dbHandle = null;
   }
   if (!dbHandle) {
-    mkdirSync10(dirname11(nextPath), { recursive: true });
+    mkdirSync11(dirname13(nextPath), { recursive: true });
     dbHandle = new Database2(nextPath, { create: true });
     dbPath = nextPath;
     ensureMobilePushSchema(dbHandle);
@@ -38029,7 +40137,7 @@ function loadApnsCredentials() {
     privateKeyPem = Buffer.from(inlineBase64, "base64").toString("utf8");
   }
   if (!privateKeyPem && path2) {
-    privateKeyPem = readFileSync13(path2, "utf8");
+    privateKeyPem = readFileSync14(path2, "utf8");
   }
   if (!teamId || !keyId || !privateKeyPem) {
     return null;
@@ -38520,8 +40628,8 @@ function candidateFromValue(key, value, root, now) {
       title: firstMetadataString(root, "title", "attentionTitle"),
       summary: firstMetadataString(root, "summary", "attentionSummary", "blockedReason", "needsInputReason", "reason", "message"),
       detail: firstMetadataString(root, "detail", "statusDetail"),
-      turnId: metadataString6(root, "turnId"),
-      blockId: metadataString6(root, "blockId"),
+      turnId: metadataString7(root, "turnId"),
+      blockId: metadataString7(root, "blockId"),
       version: metadataNumber(root, "version"),
       updatedAt: metadataTimestamp(root, now),
       severity: nativeSeverity(root)
@@ -38540,8 +40648,8 @@ function candidateFromValue(key, value, root, now) {
       title: firstMetadataString(root, "title", "attentionTitle"),
       summary: firstMetadataString(root, "summary", "attentionSummary", "blockedReason", "needsInputReason", "reason", "message"),
       detail: firstMetadataString(root, "detail", "statusDetail"),
-      turnId: metadataString6(root, "turnId"),
-      blockId: metadataString6(root, "blockId"),
+      turnId: metadataString7(root, "turnId"),
+      blockId: metadataString7(root, "blockId"),
       version: metadataNumber(root, "version"),
       updatedAt: metadataTimestamp(root, now),
       severity: nativeSeverity(root)
@@ -38570,8 +40678,8 @@ function candidateFromRecord(key, record2, now, keyImpliesAttention) {
     title: firstMetadataString(record2, "title", "label"),
     summary: firstMetadataString(record2, "summary", "message", "reason", "description"),
     detail: firstMetadataString(record2, "detail", "statusDetail", "hint"),
-    turnId: metadataString6(record2, "turnId"),
-    blockId: metadataString6(record2, "blockId"),
+    turnId: metadataString7(record2, "turnId"),
+    blockId: metadataString7(record2, "blockId"),
     version: metadataNumber(record2, "version"),
     updatedAt: metadataTimestamp(record2, now),
     severity: nativeSeverity(record2)
@@ -38591,7 +40699,7 @@ function stableNativeIdPart(value) {
   return stable || "blocked";
 }
 function nativeSeverity(record2) {
-  const severity = metadataString6(record2, "severity")?.toLowerCase();
+  const severity = metadataString7(record2, "severity")?.toLowerCase();
   if (severity === "critical" || severity === "warning" || severity === "info") {
     return severity;
   }
@@ -38600,7 +40708,7 @@ function nativeSeverity(record2) {
 function metadataRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function metadataString6(record2, key) {
+function metadataString7(record2, key) {
   const value = record2?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -38621,7 +40729,7 @@ function metadataTimestamp(record2, fallback) {
 }
 function firstMetadataString(record2, ...keys) {
   for (const key of keys) {
-    const value = metadataString6(record2, key);
+    const value = metadataString7(record2, key);
     if (value) {
       return value;
     }
@@ -38639,10 +40747,10 @@ function compactAttentionSummary(value, max = 220) {
 init_src2();
 // ../web/server/core/pairing/runtime/bridge/router.ts
 init_local_agents();
-import { readFileSync as readFileSync14, readdirSync as readdirSync6, realpathSync as realpathSync2, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync6, realpathSync as realpathSync2, statSync as statSync6 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import { basename as basename11, isAbsolute as isAbsolute4, join as join25, relative as relative4 } from "path";
-import { homedir as homedir22 } from "os";
+import { basename as basename12, isAbsolute as isAbsolute4, join as join27, relative as relative4 } from "path";
+import { homedir as homedir23 } from "os";
 var t = initTRPC.context().create();
 var logged = t.middleware(async ({ path: path2, type, next }) => {
   const start = Date.now();
@@ -38669,13 +40777,13 @@ function resolveMobileCurrentDirectory2() {
   }
 }
 function resolveWorkspaceRoot2(root) {
-  const expandedRoot = root.replace(/^~/, homedir22());
+  const expandedRoot = root.replace(/^~/, homedir23());
   return realpathSync2(expandedRoot);
 }
 function resolveWorkspacePath2(root, requestedPath) {
   const normalizedRoot = resolveWorkspaceRoot2(root);
-  const expandedPath = requestedPath?.replace(/^~/, homedir22());
-  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join25(normalizedRoot, expandedPath) : normalizedRoot;
+  const expandedPath = requestedPath?.replace(/^~/, homedir23());
+  const candidate = expandedPath ? isAbsolute4(expandedPath) ? expandedPath : join27(normalizedRoot, expandedPath) : normalizedRoot;
   const resolvedCandidate = realpathSync2(candidate);
   const rel = relative4(normalizedRoot, resolvedCandidate);
   if (rel === "" || !rel.startsWith("..") && !isAbsolute4(rel)) {
@@ -38705,7 +40813,7 @@ function listDirectories2(dirPath) {
       continue;
     if (name === "node_modules" || name === ".build" || name === "target")
       continue;
-    const fullPath = join25(dirPath, name);
+    const fullPath = join27(dirPath, name);
     try {
       const stat4 = statSync6(fullPath);
       if (!stat4.isDirectory())
@@ -38744,7 +40852,7 @@ function detectAgent2(filePath) {
   return "unknown";
 }
 async function discoverSessionFiles2(maxAgeDays, limit) {
-  const home = homedir22();
+  const home = homedir23();
   const results = [];
   const searchPaths = [
     { pattern: `${home}/.claude/projects`, agent: "claude-code" },
@@ -39038,9 +41146,9 @@ var sessionRouter = t.router({
     adapterType: exports_external.string().optional(),
     name: exports_external.string().optional()
   })).mutation(async ({ input, ctx }) => {
-    const sessionFilename = basename11(input.sessionPath, ".jsonl");
+    const sessionFilename = basename12(input.sessionPath, ".jsonl");
     const parentDir = input.sessionPath.substring(0, input.sessionPath.lastIndexOf("/"));
-    const dirName = basename11(parentDir);
+    const dirName = basename12(parentDir);
     let cwd;
     if (dirName.startsWith("-")) {
       const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -39340,7 +41448,7 @@ var workspaceRouter = t.router({
       });
     }
     const adapterType = input.adapter ?? "claude-code";
-    const name = input.name ?? basename11(projectPath);
+    const name = input.name ?? basename12(projectPath);
     return ctx.bridge.createSession(adapterType, {
       name,
       cwd: projectPath
@@ -39409,7 +41517,7 @@ var historyRouter = t.router({
       });
     }
     try {
-      const content = readFileSync14(input.path, "utf-8");
+      const content = readFileSync15(input.path, "utf-8");
       const lines = content.split(`
 `).filter((l) => l.trim().length > 0);
       const trimmed = lines.length > 500 ? lines.slice(-500) : lines;
@@ -39442,7 +41550,7 @@ var historyRouter = t.router({
     }
     try {
       const fileStat = statSync6(input.path);
-      const content = readFileSync14(input.path, "utf-8");
+      const content = readFileSync15(input.path, "utf-8");
       const replay = createHistorySessionSnapshot({
         path: input.path,
         content,
@@ -43539,14 +45647,14 @@ function parseTRPCMessage(obj, transformer) {
 }
 // ../web/server/core/pairing/runtime/bridge/server-trpc.ts
 import { realpathSync as realpathSync3 } from "fs";
-import { homedir as homedir23 } from "os";
+import { homedir as homedir24 } from "os";
 function resolveCurrentDirectory() {
   try {
     const config2 = resolveConfig();
     const configuredRoot = config2.workspace?.root;
     if (!configuredRoot)
       return process.cwd();
-    const expanded = configuredRoot.replace(/^~/, homedir23());
+    const expanded = configuredRoot.replace(/^~/, homedir24());
     return realpathSync3(expanded);
   } catch {
     return process.cwd();
@@ -44066,7 +46174,7 @@ async function autoStartConfiguredSessions(bridge, sessions3) {
     try {
       const session = await bridge.createSession(entry.adapter, {
         name: entry.name,
-        cwd: entry.cwd?.replace(/^~/, homedir24()),
+        cwd: entry.cwd?.replace(/^~/, homedir25()),
         options: entry.options
       });
       console.log(`[bridge] session started: ${session.name} (${entry.adapter})`);
@@ -44156,6 +46264,7 @@ async function startSupervisorRuntime(state) {
     state.bonjour = managedRelay ? startBonjourRelayAdvertisement({
       port: relayPort,
       relayUrl: activeRelayUrl,
+      fallbackRelayUrls: managedRelay.fallbackRelayUrls,
       publicKeyHex
     }) : null;
     state.runtime = await startPairingRuntime({
@@ -44306,6 +46415,10 @@ function startBonjourRelayAdvertisement(input) {
     `fp=${fingerprint}`,
     `scheme=${scheme}`
   ];
+  const fallbackRelayUrls = normalizedBonjourFallbackRelayUrls(input.fallbackRelayUrls);
+  if (fallbackRelayUrls.length > 0) {
+    args.push(`fallbackRelays=${fallbackRelayUrls.join("|")}`);
+  }
   let processRef = null;
   try {
     processRef = spawn4("/usr/bin/dns-sd", args, { stdio: "ignore" });
@@ -44330,6 +46443,19 @@ function startBonjourRelayAdvertisement(input) {
     }
   };
 }
+function normalizedBonjourFallbackRelayUrls(relayUrls) {
+  const seen = new Set;
+  const result = [];
+  for (const relayUrl of relayUrls ?? []) {
+    const trimmed = relayUrl.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
 function relayScheme(relayUrl) {
   try {
     const protocol = new URL(relayUrl).protocol;