@openscout/scout 0.2.68 → 0.2.69

package/dist/runtime/broker-daemon.mjs

@@ -15491,7 +15491,13 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var PARENT_HOP_LIMIT = 10;
-async function listProcesses() {
+var PROCESS_LIST_CACHE_MS = readNonNegativeIntEnv("OPENSCOUT_TAIL_PROCESS_CACHE_MS", 1000);
+var processListCache = null;
+function readNonNegativeIntEnv(name, fallback) {
+  const raw = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(raw) && raw >= 0 ? raw : fallback;
+}
+async function readProcessListUncached() {
   const { stdout } = await execFileAsync("ps", ["-axww", "-o", "pid=,ppid=,etime=,command="], {
     maxBuffer: 32 * 1024 * 1024
   });
@@ -15513,6 +15519,24 @@ async function listProcesses() {
   }
   return out;
 }
+async function listProcesses() {
+  const now = Date.now();
+  if (processListCache && now < processListCache.expiresAt) {
+    return processListCache.promise;
+  }
+  let promise2 = readProcessListUncached();
+  promise2 = promise2.catch((error48) => {
+    if (processListCache?.promise === promise2) {
+      processListCache = null;
+    }
+    throw error48;
+  });
+  processListCache = {
+    expiresAt: now + PROCESS_LIST_CACHE_MS,
+    promise: promise2
+  };
+  return promise2;
+}
 function commandBasename(command) {
   const firstToken = command.split(/\s+/)[0] ?? "";
   const slashIdx = firstToken.lastIndexOf("/");
@@ -15608,6 +15632,19 @@ var DEFAULT_HOT_DISCOVERY_LIMIT = 64;
 var DEFAULT_SHALLOW_DISCOVERY_LIMIT = 160;
 var DEFAULT_DEEP_DISCOVERY_LIMIT = 160;
 var HEAD_READ_BYTES = 256 * 1024;
+var METADATA_CACHE_LIMIT = 512;
+var metadataCache = new Map;
+function rememberMetadata(file2, metadata) {
+  metadataCache.delete(file2.path);
+  metadataCache.set(file2.path, { ...file2, ...metadata });
+  while (metadataCache.size > METADATA_CACHE_LIMIT) {
+    const oldest = metadataCache.keys().next().value;
+    if (!oldest)
+      break;
+    metadataCache.delete(oldest);
+  }
+  return metadata;
+}
 function projectsRoot() {
   return process.env.OPENSCOUT_TAIL_CLAUDE_PROJECTS_ROOT ?? join(homedir(), ".claude", "projects");
 }
@@ -15654,8 +15691,12 @@ function parseJsonRecord(line) {
     return null;
   }
 }
-function readClaudeMetadata(filePath) {
-  const head = readFileHead(filePath);
+function readClaudeMetadata(file2) {
+  const cached2 = metadataCache.get(file2.path);
+  if (cached2 && cached2.mtimeMs === file2.mtimeMs && cached2.size === file2.size) {
+    return { cwd: cached2.cwd, sessionId: cached2.sessionId };
+  }
+  const head = readFileHead(file2.path);
   let cwd = null;
   let sessionId = null;
   for (const line of head.split(/\r?\n/)) {
@@ -15665,10 +15706,10 @@ function readClaudeMetadata(filePath) {
     cwd ??= typeof record2.cwd === "string" && record2.cwd.trim() ? record2.cwd : null;
     sessionId ??= typeof record2.sessionId === "string" && record2.sessionId.trim() ? record2.sessionId : typeof record2.session_id === "string" && record2.session_id.trim() ? record2.session_id : null;
     if (cwd && sessionId) {
-      return { cwd, sessionId };
+      return rememberMetadata(file2, { cwd, sessionId });
     }
   }
-  return { cwd, sessionId };
+  return rememberMetadata(file2, { cwd, sessionId });
 }
 function decodeProjectDir(dirName) {
   if (!dirName.startsWith("-"))
@@ -15875,7 +15916,7 @@ var ClaudeSource = {
     if (!existsSync(root))
       return [];
     return walkRecentJsonlFiles(root, scope).map((file2) => {
-      const meta3 = readClaudeMetadata(file2.path);
+      const meta3 = readClaudeMetadata(file2);
       const cwd = meta3.cwd ?? fallbackCwdForPath(file2.path);
       const sessionId = meta3.sessionId ?? basename(file2.path).replace(/\.jsonl$/, "");
       return {
@@ -15908,6 +15949,19 @@ var DEFAULT_HOT_DISCOVERY_LIMIT2 = 64;
 var DEFAULT_SHALLOW_DISCOVERY_LIMIT2 = 160;
 var DEFAULT_DEEP_DISCOVERY_LIMIT2 = 160;
 var HEAD_READ_BYTES2 = 512 * 1024;
+var METADATA_CACHE_LIMIT2 = 512;
+var metadataCache2 = new Map;
+function rememberMetadata2(file2, metadata) {
+  metadataCache2.delete(file2.path);
+  metadataCache2.set(file2.path, { ...file2, ...metadata });
+  while (metadataCache2.size > METADATA_CACHE_LIMIT2) {
+    const oldest = metadataCache2.keys().next().value;
+    if (!oldest)
+      break;
+    metadataCache2.delete(oldest);
+  }
+  return metadata;
+}
 function readPositiveIntEnv2(names, fallback) {
   for (const name of names) {
     const raw = Number.parseInt(process.env[name] ?? "", 10);
@@ -15991,8 +16045,12 @@ function parseJsonRecord2(line) {
 function metadataRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function readCodexMetadata(filePath) {
-  const head = readFileHead2(filePath);
+function readCodexMetadata(file2) {
+  const cached2 = metadataCache2.get(file2.path);
+  if (cached2 && cached2.mtimeMs === file2.mtimeMs && cached2.size === file2.size) {
+    return { cwd: cached2.cwd, sessionId: cached2.sessionId };
+  }
+  const head = readFileHead2(file2.path);
   let cwd = null;
   let sessionId = null;
   for (const line of head.split(/\r?\n/)) {
@@ -16006,12 +16064,13 @@ function readCodexMetadata(filePath) {
       cwd ??= typeof payload.cwd === "string" && payload.cwd.trim() ? payload.cwd : null;
       sessionId ??= typeof payload.id === "string" && payload.id.trim() ? payload.id : null;
       if (cwd || sessionId) {
-        if (cwd && sessionId)
-          return { cwd, sessionId };
+        if (cwd && sessionId) {
+          return rememberMetadata2(file2, { cwd, sessionId });
+        }
       }
     }
   }
-  return { cwd, sessionId };
+  return rememberMetadata2(file2, { cwd, sessionId });
 }
 function walkRecentJsonlFiles2(root, scope) {
   const cutoff = Date.now() - discoveryWindowMs2(scope);
@@ -16054,7 +16113,7 @@ function discoverCodexTranscripts(scope) {
     }
   }
   return [...byPath.values()].sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, discoveryLimit2(scope)).map((file2) => {
-    const meta3 = readCodexMetadata(file2.path);
+    const meta3 = readCodexMetadata(file2);
     const sessionId = meta3.sessionId ?? sessionIdFromCodexPath(file2.path);
     return {
       source: SOURCE_NAME2,
@@ -16261,6 +16320,7 @@ var RAW_MAX_STRING_LEN = 1000;
 var RAW_MAX_ARRAY_ITEMS = 25;
 var RAW_MAX_OBJECT_KEYS = 50;
 var RECENT_TRANSCRIPT_READ_BYTES = 512 * 1024;
+var RECENT_TRANSCRIPT_MAX_FILES = readPositiveIntEnv3("OPENSCOUT_TAIL_RECENT_TRANSCRIPT_MAX_FILES", 24);
 var sources = [ClaudeSource, CodexSource];
 var watchers = new Map;
 var aggregateBuffer = [];
@@ -16397,26 +16457,27 @@ function pushEvent(rawEvent) {
     } catch {}
   }
 }
-async function readNew(handle, fromOffset) {
-  const stats = await handle.stat();
-  if (stats.size <= fromOffset) {
+async function readNew(handle, fromOffset, fileSize) {
+  if (fileSize <= fromOffset) {
     return { text: "", nextOffset: fromOffset };
   }
-  const length = stats.size - fromOffset;
+  const length = fileSize - fromOffset;
   const buffer = Buffer.alloc(length);
   await handle.read(buffer, 0, length, fromOffset);
-  return { text: buffer.toString("utf8"), nextOffset: stats.size };
+  return { text: buffer.toString("utf8"), nextOffset: fileSize };
 }
 async function pumpWatcher(watcher) {
   let handle = null;
   try {
-    handle = await open(watcher.transcriptPath, "r");
-    const stats = await handle.stat();
+    const stats = await stat(watcher.transcriptPath);
     if (stats.size < watcher.offset) {
       watcher.offset = 0;
       watcher.carry = "";
     }
-    const { text, nextOffset } = await readNew(handle, watcher.offset);
+    if (stats.size <= watcher.offset)
+      return;
+    handle = await open(watcher.transcriptPath, "r");
+    const { text, nextOffset } = await readNew(handle, watcher.offset, stats.size);
     watcher.offset = nextOffset;
     if (!text)
       return;
@@ -18633,6 +18694,276 @@ function assertValidUnblockRequestEvent(event, record2) {
     throw new Error(errors3.join("; "));
   }
 }
+// packages/protocol/src/lifecycle.ts
+var TERMINAL_INVOCATION_STATES = new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "expired"
+]);
+var MAX_TERMINAL_SUMMARY_LENGTH = 256;
+function projectInvocationLifecycle(input) {
+  const deliveries = (input.deliveries ?? []).map((delivery) => projectOutcomeDelivery(delivery, input.deliveryAttempts?.[delivery.id] ?? []));
+  const peerDelivery = deliveries.find((delivery) => delivery.state === "dispatched_to_peer");
+  const expiresAt = input.expiresAt ?? expiresAtForInvocation(input.invocation);
+  const state = projectInvocationState({
+    invocation: input.invocation,
+    flight: input.flight,
+    deliveries,
+    now: input.now,
+    expiresAt
+  });
+  const terminal = projectTerminalResult({
+    state,
+    flight: input.flight,
+    now: input.now
+  });
+  const lifecycle = {
+    invocationId: input.invocation.id,
+    state
+  };
+  addOptional(lifecycle, "flightId", input.flight?.id);
+  addOptional(lifecycle, "targetAgentId", input.flight?.targetAgentId ?? input.invocation.targetAgentId);
+  addOptional(lifecycle, "targetEndpointId", stringMetadata(input.flight?.metadata, "targetEndpointId"));
+  addOptional(lifecycle, "peerNodeId", peerDelivery?.peerNodeId ?? input.invocation.targetNodeId);
+  addOptional(lifecycle, "peerFlightId", peerDelivery?.peerFlightId);
+  addOptional(lifecycle, "workId", inferWorkId(input.invocation));
+  addOptional(lifecycle, "actionId", stringMetadata(input.invocation.metadata, "actionId"));
+  addOptional(lifecycle, "idempotencyKey", stringMetadata(input.invocation.metadata, "idempotencyKey"));
+  addOptional(lifecycle, "acknowledgedAt", dispatchAcknowledgedAt(input.flight?.metadata) ?? peerDelivery?.deliveredAt);
+  addOptional(lifecycle, "startedAt", input.flight?.startedAt);
+  addOptional(lifecycle, "completedAt", input.flight?.completedAt ?? terminal?.completedAt);
+  addOptional(lifecycle, "expiresAt", expiresAt);
+  addOptional(lifecycle, "lastProgressAt", lastProgressAt(input.flight, deliveries));
+  addOptional(lifecycle, "waitingOn", input.waitingOn ?? waitingOnFromMetadata(input.flight?.metadata));
+  addOptional(lifecycle, "terminal", terminal);
+  addOptional(lifecycle, "deliveries", deliveries.length > 0 ? deliveries : undefined);
+  addOptional(lifecycle, "metadata", lifecycleMetadata(input.invocation, input.flight));
+  return lifecycle;
+}
+function projectInvocationState(input) {
+  const flightState = input.flight?.state;
+  if (flightState === "completed" || flightState === "failed" || flightState === "cancelled") {
+    return flightState;
+  }
+  if (input.expiresAt !== undefined && input.now !== undefined && input.expiresAt <= input.now) {
+    return "expired";
+  }
+  if (input.deliveries?.some((delivery) => delivery.state === "dispatched_to_peer")) {
+    return "acknowledged";
+  }
+  if (flightState === "waiting") {
+    return "waiting";
+  }
+  if (flightState === "running") {
+    return "working";
+  }
+  if (flightState === "waking") {
+    return "dispatching";
+  }
+  if (flightState === "queued") {
+    return "queued";
+  }
+  return input.invocation.ensureAwake ? "dispatching" : "queued";
+}
+function projectOutcomeDelivery(delivery, attempts = []) {
+  const sortedAttempts = [...attempts].sort((left, right) => left.createdAt - right.createdAt);
+  const lastAttempt = sortedAttempts[sortedAttempts.length - 1];
+  const latestFailedAttempt = [...sortedAttempts].reverse().find((attempt) => attempt.status === "failed");
+  const state = projectDeliveryState(delivery);
+  const deliveredAt = deliveredAtForDelivery(delivery, sortedAttempts);
+  const subject = deliverySubject(delivery);
+  const outcome = {
+    deliveryId: delivery.id,
+    subjectKind: subject.kind,
+    subjectId: subject.id,
+    transport: delivery.transport,
+    state,
+    attemptCount: sortedAttempts.length
+  };
+  addOptional(outcome, "peerNodeId", peerNodeId(delivery));
+  addOptional(outcome, "peerFlightId", stringMetadata(delivery.metadata, "peerFlightId"));
+  addOptional(outcome, "nextAttemptAt", numberMetadata(delivery.metadata, "nextAttemptAt"));
+  addOptional(outcome, "lastError", deliveryError(delivery, latestFailedAttempt));
+  addOptional(outcome, "lastAttemptAt", lastAttempt?.createdAt);
+  addOptional(outcome, "deliveredAt", deliveredAt);
+  addOptional(outcome, "metadata", delivery.metadata);
+  return outcome;
+}
+function projectDeliveryState(delivery) {
+  switch (delivery.status) {
+    case "accepted":
+    case "pending":
+      return "pending";
+    case "leased":
+      return "leased";
+    case "peer_acked":
+      return "dispatched_to_peer";
+    case "sent":
+    case "acknowledged":
+    case "running":
+    case "completed":
+      return "sent";
+    case "deferred":
+      return "retrying";
+    case "failed":
+      return "dead_lettered";
+    case "cancelled":
+      return isSuppressedDelivery(delivery) ? "suppressed" : "cancelled";
+    default:
+      return "pending";
+  }
+}
+function isTerminalInvocationState(state) {
+  return TERMINAL_INVOCATION_STATES.has(state);
+}
+function projectTerminalResult(input) {
+  if (!isTerminalInvocationState(input.state)) {
+    return;
+  }
+  const state = input.state;
+  const completedAt = input.flight?.completedAt ?? input.now;
+  if (completedAt === undefined) {
+    return;
+  }
+  const terminal = {
+    state,
+    completedAt
+  };
+  addOptional(terminal, "summary", compactTerminalSummary(input.flight));
+  addOptional(terminal, "errorClass", stringMetadata(input.flight?.metadata, "errorClass"));
+  addOptional(terminal, "exitCode", numberMetadata(input.flight?.metadata, "exitCode"));
+  addOptional(terminal, "sourceRecordId", input.flight?.id);
+  addOptional(terminal, "metadata", terminalMetadata(input.flight));
+  return terminal;
+}
+function compactTerminalSummary(flight) {
+  const summary = flight?.state === "failed" ? flight.error ?? flight.summary : flight?.summary;
+  if (!summary?.trim()) {
+    return;
+  }
+  const compacted = summary.replace(/\s+/g, " ").trim();
+  return compacted.length <= MAX_TERMINAL_SUMMARY_LENGTH ? compacted : `${compacted.slice(0, MAX_TERMINAL_SUMMARY_LENGTH - 3).trimEnd()}...`;
+}
+function terminalMetadata(flight) {
+  if (!flight?.metadata) {
+    return;
+  }
+  const metadata = {};
+  addOptional(metadata, "failureStage", stringMetadata(flight.metadata, "failureStage"));
+  addOptional(metadata, "failureReason", stringMetadata(flight.metadata, "failureReason"));
+  addOptional(metadata, "cancelledBy", stringMetadata(flight.metadata, "cancelledBy"));
+  addOptional(metadata, "expiredAt", numberMetadata(flight.metadata, "expiredAt"));
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function deliverySubject(delivery) {
+  const workId = stringMetadata(delivery.metadata, "workId") ?? stringMetadata(delivery.metadata, "collaborationRecordId");
+  if (workId) {
+    return { kind: "work_item", id: workId };
+  }
+  if (delivery.invocationId) {
+    return { kind: "invocation", id: delivery.invocationId };
+  }
+  if (delivery.messageId) {
+    return { kind: "message", id: delivery.messageId };
+  }
+  return { kind: "message", id: delivery.id };
+}
+function deliveredAtForDelivery(delivery, attempts) {
+  return numberMetadata(delivery.metadata, "deliveredAt") ?? numberMetadata(delivery.metadata, "peerAckedAt") ?? lastSuccessfulAttemptAt(attempts);
+}
+function lastSuccessfulAttemptAt(attempts) {
+  for (let index = attempts.length - 1;index >= 0; index -= 1) {
+    const attempt = attempts[index];
+    if (attempt?.status === "acknowledged" || attempt?.status === "sent") {
+      return attempt.createdAt;
+    }
+  }
+  return;
+}
+function deliveryError(delivery, latestFailedAttempt) {
+  const reason = stringMetadata(delivery.metadata, "failureReason");
+  const detail = stringMetadata(delivery.metadata, "failureDetail") ?? stringMetadata(delivery.metadata, "lastError") ?? latestFailedAttempt?.error;
+  const code = stringMetadata(delivery.metadata, "errorCode");
+  const status = numberMetadata(delivery.metadata, "httpStatus");
+  if (!reason && !detail && !code && status === undefined) {
+    return;
+  }
+  const error48 = {};
+  addOptional(error48, "reason", reason);
+  addOptional(error48, "detail", detail);
+  addOptional(error48, "retryable", booleanMetadata(delivery.metadata, "retryable"));
+  addOptional(error48, "code", code);
+  addOptional(error48, "status", status);
+  return error48;
+}
+function isSuppressedDelivery(delivery) {
+  return booleanMetadata(delivery.metadata, "suppressed") || booleanMetadata(delivery.metadata, "policySuppressed") || booleanMetadata(delivery.metadata, "suppressedByPolicy") || stringMetadata(delivery.metadata, "suppressionReason") !== undefined || stringMetadata(delivery.metadata, "failureReason") === "suppressed";
+}
+function peerNodeId(delivery) {
+  return stringMetadata(delivery.metadata, "peerNodeId") ?? delivery.targetNodeId;
+}
+function dispatchAcknowledgedAt(metadata) {
+  const dispatchAck = metadataObject(metadata, "dispatchAck");
+  return numberMetadata(dispatchAck, "acknowledgedAt");
+}
+function lastProgressAt(flight, deliveries) {
+  const deliveryAt = deliveries.map((delivery) => delivery.lastAttemptAt ?? delivery.deliveredAt).filter((value) => value !== undefined).sort((left, right) => right - left)[0];
+  return Math.max(flight?.completedAt ?? 0, flight?.startedAt ?? 0, deliveryAt ?? 0) || undefined;
+}
+function lifecycleMetadata(invocation, flight) {
+  const metadata = {};
+  addOptional(metadata, "invocationMetadata", invocation.metadata);
+  addOptional(metadata, "flightMetadata", flight?.metadata);
+  return Object.keys(metadata).length > 0 ? metadata : undefined;
+}
+function waitingOnFromMetadata(metadata) {
+  const waitingOn = metadataObject(metadata, "waitingOn");
+  if (!waitingOn) {
+    return;
+  }
+  const kind = stringMetadata(waitingOn, "kind");
+  const projected = {
+    kind: isWaitingOnKind(kind) ? kind : "unknown"
+  };
+  addOptional(projected, "label", stringMetadata(waitingOn, "label"));
+  addOptional(projected, "targetId", stringMetadata(waitingOn, "targetId"));
+  addOptional(projected, "metadata", metadataObject(waitingOn, "metadata"));
+  return projected;
+}
+function isWaitingOnKind(value) {
+  return value === "human" || value === "peer" || value === "approval" || value === "artifact" || value === "condition" || value === "agent" || value === "unknown";
+}
+function inferWorkId(invocation) {
+  return stringMetadata(invocation.metadata, "workId") ?? stringMetadata(invocation.context, "workId") ?? stringMetadata(metadataObject(invocation.context, "collaboration"), "recordId");
+}
+function expiresAtForInvocation(invocation) {
+  const metadataExpiresAt = numberMetadata(invocation.metadata, "expiresAt");
+  if (metadataExpiresAt !== undefined) {
+    return metadataExpiresAt;
+  }
+  return invocation.timeoutMs && Number.isFinite(invocation.timeoutMs) ? invocation.createdAt + invocation.timeoutMs : undefined;
+}
+function metadataObject(metadata, key) {
+  const value = metadata?.[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function stringMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanMetadata(metadata, key) {
+  return metadata?.[key] === true;
+}
+function addOptional(target, key, value) {
+  if (value !== undefined) {
+    target[key] = value;
+  }
+}
 // packages/protocol/src/permission-policy.ts
 var SCOUT_PERMISSION_PROFILES = [
   "observe",
@@ -19628,6 +19959,14 @@ class FileBackedBrokerJournal {
   getDurableAction(actionId) {
     return this.state.durableActions.get(actionId) ?? null;
   }
+  getDurableActionByIdempotencyKey(input) {
+    for (const action of this.state.durableActions.values()) {
+      if (action.authorityCellId === input.authorityCellId && action.kind === input.kind && action.idempotencyKey === input.idempotencyKey) {
+        return action;
+      }
+    }
+    return null;
+  }
   async rewriteEntries(entries) {
     await mkdir(dirname2(this.filePath), { recursive: true });
     const payload = entries.length > 0 ? `${entries.map((entry) => JSON.stringify(entry)).join(`
@@ -19820,12 +20159,12 @@ function normalizedRouteTargetValue(target) {
   if (!target) {
     return;
   }
-  const direct = target.kind === "agent_id" ? target.agentId : target.kind === "agent_label" ? target.label : target.kind === "binding_ref" ? target.ref : target.kind === "project_path" ? target.projectPath : target.kind === "channel" ? target.channel : target.value;
+  const direct = target.kind === "agent_id" ? target.agentId : target.kind === "agent_label" ? target.label : target.kind === "session_id" ? target.sessionId : target.kind === "binding_ref" ? target.ref : target.kind === "project_path" ? target.projectPath : target.kind === "channel" ? target.channel : target.value;
   const trimmed = direct?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : undefined;
 }
 function askedLabelForRouteTarget(input) {
-  return normalizedRouteTargetValue(input.target) ?? input.targetLabel?.trim() ?? input.targetAgentId?.trim() ?? "";
+  return normalizedRouteTargetValue(input.target) ?? input.targetSessionId?.trim() ?? input.targetLabel?.trim() ?? input.targetAgentId?.trim() ?? "";
 }
 function routeChannelForTarget(input) {
   const target = input.target;
@@ -19844,20 +20183,6 @@ function metadataStringValue(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
-function replacementForStaleAgent(snapshot, agent, helpers) {
-  if (!helpers.isStale(agent)) {
-    return;
-  }
-  const replacementAgentId = metadataStringValue(agent.metadata, "replacedByAgentId");
-  if (!replacementAgentId || replacementAgentId === agent.id) {
-    return;
-  }
-  const replacement = snapshot.agents[replacementAgentId];
-  if (!replacement || helpers.isStale(replacement)) {
-    return;
-  }
-  return replacement;
-}
 function isReservedProductIdentity(definitionId) {
   return definitionId === SCOUT_DISPATCHER_AGENT_ID || definitionId === OPENSCOUT_COORDINATOR_AGENT_ID;
 }
@@ -19898,6 +20223,31 @@ function buildAgentLabelCandidate(snapshot, agent) {
     aliases
   };
 }
+function stripHarnessQualifier(identity2) {
+  if (!identity2.harness) {
+    return null;
+  }
+  return constructAgentIdentity({
+    definitionId: identity2.definitionId,
+    workspaceQualifier: identity2.workspaceQualifier,
+    profile: identity2.profile,
+    model: identity2.model,
+    nodeQualifier: identity2.nodeQualifier
+  });
+}
+function resolutionFromDiagnosis(diagnosis, label) {
+  if (diagnosis.kind === "resolved") {
+    return { kind: "resolved", agent: diagnosis.match.agent };
+  }
+  if (diagnosis.kind === "ambiguous") {
+    return {
+      kind: "ambiguous",
+      label,
+      candidates: diagnosis.candidates.map((candidate) => candidate.agent)
+    };
+  }
+  return null;
+}
 function resolveAgentLabel(snapshot, label, options) {
   const trimmed = label.trim();
   if (!trimmed) {
@@ -19912,10 +20262,17 @@ function resolveAgentLabel(snapshot, label, options) {
   }
   const candidates = buildAgentLabelCandidates(snapshot, options.helpers);
   const diagnosis = diagnoseAgentIdentity(identity2, candidates);
+  const harnessAgnosticIdentity = stripHarnessQualifier(identity2);
   if (diagnosis.kind === "resolved") {
     return { kind: "resolved", agent: diagnosis.match.agent };
   }
   if (diagnosis.kind === "unknown") {
+    if (harnessAgnosticIdentity) {
+      const agnosticResolution = resolutionFromDiagnosis(diagnoseAgentIdentity(harnessAgnosticIdentity, candidates), identity2.label);
+      if (agnosticResolution) {
+        return agnosticResolution;
+      }
+    }
     const fallbackCandidates = buildAgentLabelCandidates(snapshot, options.helpers, {
       includeStale: true
     });
@@ -19923,7 +20280,7 @@ function resolveAgentLabel(snapshot, label, options) {
     if (fallbackDiagnosis.kind === "resolved") {
       return {
         kind: "resolved",
-        agent: replacementForStaleAgent(snapshot, fallbackDiagnosis.match.agent, options.helpers) ?? fallbackDiagnosis.match.agent
+        agent: fallbackDiagnosis.match.agent
       };
     }
     if (fallbackDiagnosis.kind === "ambiguous") {
@@ -19933,6 +20290,12 @@ function resolveAgentLabel(snapshot, label, options) {
         candidates: fallbackDiagnosis.candidates.map((candidate) => candidate.agent)
       };
     }
+    if (harnessAgnosticIdentity) {
+      const agnosticFallbackResolution = resolutionFromDiagnosis(diagnoseAgentIdentity(harnessAgnosticIdentity, fallbackCandidates), identity2.label);
+      if (agnosticFallbackResolution) {
+        return agnosticFallbackResolution;
+      }
+    }
     return { kind: "unknown", label: identity2.label };
   }
   const preferLocal = options.preferLocalNodeId?.trim();
@@ -20002,19 +20365,37 @@ function resolveProjectPathTarget(snapshot, projectPath, options) {
     candidates: candidates.filter((candidate) => candidate.rank === first.rank).map((candidate) => candidate.agent)
   };
 }
+function endpointMatchesSessionId(endpoint, sessionId) {
+  return endpoint.sessionId?.trim() === sessionId || endpoint.id === sessionId;
+}
+function resolveSessionTarget(snapshot, sessionId, options) {
+  const candidates = Object.values(snapshot.endpoints).filter((endpoint) => endpointMatchesSessionId(endpoint, sessionId)).map((endpoint) => snapshot.agents[endpoint.agentId]).filter((agent) => Boolean(agent)).map((agent) => agent);
+  const unique2 = [...new Map(candidates.map((agent) => [agent.id, agent])).values()];
+  if (unique2.length === 0) {
+    return { kind: "unknown", label: `session:${sessionId}` };
+  }
+  if (unique2.length === 1) {
+    return { kind: "resolved", agent: unique2[0] };
+  }
+  return {
+    kind: "ambiguous",
+    label: `session:${sessionId}`,
+    candidates: unique2
+  };
+}
 function resolveBrokerRouteTarget(snapshot, input, options) {
   const policy = input.routePolicy;
   const routeTarget = input.target;
   const preferLocalNodeId = policy?.preferLocalNodeId?.trim() || options.preferLocalNodeId;
   const directId = routeTarget?.kind === "agent_id" ? normalizedRouteTargetValue(routeTarget) : input.targetAgentId?.trim();
+  const directSessionId = routeTarget?.kind === "session_id" ? normalizedRouteTargetValue(routeTarget) : input.targetSessionId?.trim();
+  if (directSessionId) {
+    return resolveSessionTarget(snapshot, directSessionId, {
+      helpers: options.helpers
+    });
+  }
   if (directId) {
     const agent = snapshot.agents[directId];
-    if (agent) {
-      const replacement = replacementForStaleAgent(snapshot, agent, options.helpers);
-      if (replacement) {
-        return { kind: "resolved", agent: replacement };
-      }
-    }
     if (agent && (policy?.allowStaleDirectId ?? true)) {
       return { kind: "resolved", agent };
     }
@@ -21351,11 +21732,29 @@ function createPeerDeliveryWorker(deps, config2 = {}) {
 // packages/runtime/src/local-agents.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { execFileSync as execFileSync3, execSync } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir7, rm as rm5, stat as stat4, writeFile as writeFile7 } from "fs/promises";
-import { basename as basename9, dirname as dirname9, join as join18, resolve as resolve7 } from "path";
+import { basename as basename9, dirname as dirname10, join as join19, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
+// packages/runtime/src/dispatch-stalled.ts
+class DispatchStalledError extends Error {
+  code = "DISPATCH_STALLED";
+  sessionName;
+  paneTail;
+  retries;
+  constructor(input) {
+    super(`tmux dispatch for session ${input.sessionName} left the prompt in the composer after submit + ${input.retries} retr${input.retries === 1 ? "y" : "ies"}.`);
+    this.name = "DispatchStalledError";
+    this.sessionName = input.sessionName;
+    this.paneTail = input.paneTail;
+    this.retries = input.retries;
+  }
+}
+function isDispatchStalledError(error48) {
+  return error48 instanceof DispatchStalledError || Boolean(error48) && typeof error48 === "object" && error48.code === "DISPATCH_STALLED" && typeof error48.sessionName === "string";
+}
+
 // packages/runtime/src/claude-stream-json.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn2 } from "child_process";
@@ -26574,6 +26973,63 @@ function readCodexAppServerModelFromLaunchArgs(launchArgs) {
   }
   return null;
 }
+function readCodexAppServerReasoningEffortFromLaunchArgs(launchArgs) {
+  const normalized = normalizeCodexAppServerLaunchArgs(launchArgs);
+  for (let index = 0;index < normalized.length; index += 1) {
+    const current = normalized[index] ?? "";
+    if (current === "-c" || current === "--config") {
+      const reasoningEffort = parseCodexReasoningEffortConfig(normalized[index + 1]);
+      if (reasoningEffort) {
+        return reasoningEffort;
+      }
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--config=")) {
+      const reasoningEffort = parseCodexReasoningEffortConfig(current.slice("--config=".length));
+      if (reasoningEffort) {
+        return reasoningEffort;
+      }
+    }
+  }
+  return null;
+}
+
+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";
+  }
+}
+function isCodexAppServerExitError(error48) {
+  return error48 instanceof CodexAppServerExitError || Boolean(error48 && typeof error48 === "object" && error48.code === "CODEX_APP_SERVER_EXIT");
+}
+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;
@@ -26748,6 +27204,7 @@ class CodexAppServerSession {
   activeTurn = null;
   threadId = null;
   threadPath = null;
+  proactiveShutdown = null;
   lastConfigSignature;
   constructor(options) {
     this.options = options;
@@ -26878,13 +27335,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;
@@ -26894,7 +27361,7 @@ class CodexAppServerSession {
     if (child && child.exitCode === null && !child.killed) {
       child.kill("SIGTERM");
       await new Promise((resolve4) => setTimeout(resolve4, 250));
-      if (child.exitCode === null && !child.killed) {
+      if (child.exitCode === null && child.signalCode === null) {
         child.kill("SIGKILL");
       }
     }
@@ -26945,6 +27412,7 @@ class CodexAppServerSession {
     await mkdir4(this.options.runtimeDirectory, { recursive: true });
     await mkdir4(this.options.logsDirectory, { recursive: true });
     await writeFile4(join13(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    this.proactiveShutdown = null;
     const codexExecutable = resolveCodexExecutable();
     const launchArgs = normalizeCodexAppServerLaunchArgs(this.options.launchArgs);
     const env = buildManagedAgentEnvironment({
@@ -26984,7 +27452,16 @@ class CodexAppServerSession {
       this.failSession(new Error(`Codex app-server failed for ${this.options.agentName}: ${errorMessage3(error48)}`));
     });
     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: {
@@ -27319,6 +27796,23 @@ class CodexAppServerSession {
     }
     this.pendingRequests.clear();
     appendFile4(this.stderrLogPath, `[openscout] ${error48.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})` : "";
+    appendFile4(this.stderrLogPath, `[openscout] Codex app-server stopped for ${this.options.agentName}: ${shutdown.reason}${detail}
 `).catch(() => {
       return;
     });
@@ -27390,7 +27884,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);
@@ -31507,6 +32004,17 @@ async function fetchHealthSnapshot(config2) {
         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,
@@ -31731,11 +32239,42 @@ function compileCodexPermissionProfile(profileInput) {
   }
 }
 
+// packages/runtime/src/user-config.ts
+import { existsSync as existsSync13, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname9, join as join18 } from "path";
+function userConfigPath() {
+  return join18(process.env.OPENSCOUT_HOME ?? join18(homedir14(), ".openscout"), "user.json");
+}
+function loadUserConfig() {
+  const configPath = userConfigPath();
+  if (!existsSync13(configPath))
+    return {};
+  try {
+    return JSON.parse(readFileSync6(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function resolveOperatorName() {
+  const config2 = loadUserConfig();
+  return config2.name?.trim() || process.env.OPENSCOUT_OPERATOR_NAME?.trim() || process.env.USER?.trim() || "operator";
+}
+function normalizeHandle(value) {
+  return value?.trim().replace(/^@+/, "") ?? "";
+}
+function resolveOperatorHandle() {
+  const config2 = loadUserConfig();
+  return normalizeHandle(config2.handle) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_HANDLE) || normalizeHandle(config2.name) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_NAME) || normalizeHandle(process.env.USER) || "operator";
+}
+
 // packages/runtime/src/local-agents.ts
-var MODULE_DIRECTORY = dirname9(fileURLToPath5(import.meta.url));
+var MODULE_DIRECTORY = dirname10(fileURLToPath5(import.meta.url));
 var OPENSCOUT_REPO_ROOT = resolve7(MODULE_DIRECTORY, "..", "..", "..");
 var DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
 var DEFAULT_LOCAL_AGENT_HARNESS = "claude";
+var DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_RETAIN = 24;
 function resolveRelayHub() {
   return resolveOpenScoutSupportPaths().relayHubDirectory;
 }
@@ -31745,14 +32284,14 @@ function resolveProjectsRoot(projectPath) {
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync13(supportPaths.settingsPath)) {
-      return dirname9(projectPath);
+    if (!existsSync14(supportPaths.settingsPath)) {
+      return dirname10(projectPath);
     }
-    const raw = JSON.parse(readFileSync6(supportPaths.settingsPath, "utf8"));
+    const raw = JSON.parse(readFileSync7(supportPaths.settingsPath, "utf8"));
     const workspaceRoot = raw.discovery?.workspaceRoots?.find((entry) => typeof entry === "string" && entry.trim().length > 0);
-    return workspaceRoot ? resolve7(workspaceRoot) : dirname9(projectPath);
+    return workspaceRoot ? resolve7(workspaceRoot) : dirname10(projectPath);
   } catch {
-    return dirname9(projectPath);
+    return dirname10(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -31765,7 +32304,7 @@ function normalizeBrokerTimestamp(value) {
   return value > 10000000000 ? Math.floor(value / 1000) : value;
 }
 function scoutCliPath() {
-  return join18(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
+  return join19(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
 }
 function legacyNodeBrokerRelayCommand() {
   return `node ${JSON.stringify(scoutCliPath())}`;
@@ -31792,13 +32331,13 @@ var SUPPORTED_SCOUT_HARNESSES = [
 ];
 function resolveScoutSkillPath() {
   const candidatePaths = [
-    join18(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
-    join18(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
-    join18(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
-    join18(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
+    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")
   ];
   for (const path of candidatePaths) {
-    if (existsSync13(path)) {
+    if (existsSync14(path)) {
       return path;
     }
   }
@@ -31906,6 +32445,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);
@@ -32060,7 +32667,7 @@ function expandHomePath3(value) {
     return process.env.HOME ?? process.cwd();
   }
   if (value.startsWith("~/")) {
-    return join18(process.env.HOME ?? process.cwd(), value.slice(2));
+    return join19(process.env.HOME ?? process.cwd(), value.slice(2));
   }
   return value;
 }
@@ -32125,8 +32732,8 @@ var DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS = [
   "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",
@@ -32146,6 +32753,10 @@ function normalizeClaudeRuntimeLaunchArgs(value) {
     DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS.join(",")
   ];
 }
+function normalizeRequestedModel(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
 function readClaudeLaunchModel(launchArgs) {
   for (let index = 0;index < launchArgs.length; index += 1) {
     const current = launchArgs[index] ?? "";
@@ -32193,37 +32804,199 @@ function readLaunchModelForHarness(harness, launchArgs) {
   }
   return;
 }
-function normalizeManagedHarness2(value, fallback) {
-  return value === "codex" ? "codex" : value === "claude" ? "claude" : value === "cursor" ? "cursor" : value === "pi" ? "pi" : fallback;
-}
-function normalizeLocalHarnessProfiles(agentId, record2) {
-  const defaultHarness = normalizeManagedHarness2(typeof record2.defaultHarness === "string" ? record2.defaultHarness : record2.harness, "claude");
-  const nextProfiles = {};
-  for (const harness of ["claude", "codex", "cursor", "pi"]) {
-    const profile = record2.harnessProfiles?.[harness];
-    if (!profile) {
-      continue;
+function stripLaunchModelForHarness(harness, launchArgs) {
+  if (harness === "codex") {
+    const next = [];
+    const normalized = normalizeCodexAppServerLaunchArgs(launchArgs);
+    for (let index = 0;index < normalized.length; index += 1) {
+      const current = normalized[index] ?? "";
+      if (current === "-c" || current === "--config") {
+        const value = normalized[index + 1];
+        if (readCodexAppServerModelFromLaunchArgs(value ? [current, value] : [current])) {
+          index += 1;
+          continue;
+        }
+        next.push(current);
+        if (value) {
+          next.push(value);
+          index += 1;
+        }
+        continue;
+      }
+      if (current.startsWith("--config=")) {
+        if (readCodexAppServerModelFromLaunchArgs([current])) {
+          continue;
+        }
+      }
+      next.push(current);
     }
-    nextProfiles[harness] = {
-      cwd: normalizeProjectPath2(profile.cwd || record2.cwd || process.cwd()),
-      transport: normalizeLocalAgentTransport(profile.transport, harness),
-      sessionId: normalizeTmuxSessionName2(profile.sessionId, `${agentId}-${harness}`),
-      launchArgs: normalizeLaunchArgsForHarness(harness, profile.launchArgs),
-      ...profile.permissionProfile ? { permissionProfile: profile.permissionProfile } : {}
-    };
+    return next;
   }
-  const runtimeHarness = normalizeManagedHarness2(record2.harness, defaultHarness);
-  if (!nextProfiles[runtimeHarness]) {
-    nextProfiles[runtimeHarness] = {
-      cwd: normalizeProjectPath2(record2.cwd || process.cwd()),
-      transport: normalizeLocalAgentTransport(record2.transport, runtimeHarness),
-      sessionId: normalizeTmuxSessionName2(record2.tmuxSession, `${agentId}-${runtimeHarness}`),
-      launchArgs: normalizeLaunchArgsForHarness(runtimeHarness, record2.launchArgs),
-      ...record2.permissionProfile ? { permissionProfile: record2.permissionProfile } : {}
-    };
+  if (harness === "claude" || harness === "pi") {
+    const next = [];
+    const normalized = normalizeLocalAgentLaunchArgs(launchArgs);
+    for (let index = 0;index < normalized.length; index += 1) {
+      const current = normalized[index] ?? "";
+      if (current === "--model") {
+        index += 1;
+        continue;
+      }
+      if (current.startsWith("--model=")) {
+        continue;
+      }
+      next.push(current);
+    }
+    return next;
   }
-  if (!nextProfiles[defaultHarness]) {
-    nextProfiles[defaultHarness] = {
+  return normalizeLocalAgentLaunchArgs(launchArgs);
+}
+function buildLaunchArgsForRequestedModel(harness, model) {
+  if (harness === "codex") {
+    return normalizeCodexAppServerLaunchArgs(["--model", model]);
+  }
+  if (harness === "claude") {
+    return ["--model", model];
+  }
+  if (harness === "pi") {
+    return ["--model", model];
+  }
+  return [];
+}
+function normalizeRequestedReasoningEffort(reasoningEffort) {
+  const trimmed = reasoningEffort?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function stripLaunchReasoningEffortForHarness(harness, launchArgs) {
+  if (harness === "pi") {
+    const next2 = [];
+    const normalized2 = normalizeLocalAgentLaunchArgs(launchArgs);
+    for (let index = 0;index < normalized2.length; index += 1) {
+      const current = normalized2[index] ?? "";
+      if (current === "--thinking") {
+        index += 1;
+        continue;
+      }
+      if (current.startsWith("--thinking=")) {
+        continue;
+      }
+      next2.push(current);
+    }
+    return next2;
+  }
+  if (harness !== "codex") {
+    return normalizeLaunchArgsForHarness(harness, launchArgs);
+  }
+  const next = [];
+  const normalized = normalizeCodexAppServerLaunchArgs(launchArgs);
+  for (let index = 0;index < normalized.length; index += 1) {
+    const current = normalized[index] ?? "";
+    if (current === "-c" || current === "--config") {
+      const value = normalized[index + 1];
+      if (readCodexAppServerReasoningEffortFromLaunchArgs(value ? [current, value] : [current])) {
+        index += 1;
+        continue;
+      }
+      next.push(current);
+      if (value) {
+        next.push(value);
+        index += 1;
+      }
+      continue;
+    }
+    if (current.startsWith("--config=")) {
+      if (readCodexAppServerReasoningEffortFromLaunchArgs([current])) {
+        continue;
+      }
+    }
+    next.push(current);
+  }
+  return next;
+}
+function buildLaunchArgsForRequestedReasoningEffort(harness, reasoningEffort) {
+  if (harness === "codex") {
+    return normalizeCodexAppServerLaunchArgs(["--reasoning-effort", reasoningEffort]);
+  }
+  if (harness === "pi") {
+    return ["--thinking", reasoningEffort];
+  }
+  return [];
+}
+function applyRequestedModelToLaunchArgs(harness, launchArgs, model) {
+  const normalized = normalizeLaunchArgsForHarness(harness, launchArgs);
+  const requestedModel = normalizeRequestedModel(model);
+  if (!requestedModel) {
+    return normalized;
+  }
+  return [
+    ...stripLaunchModelForHarness(harness, normalized),
+    ...buildLaunchArgsForRequestedModel(harness, requestedModel)
+  ];
+}
+function applyRequestedRuntimeOptionsToLaunchArgs(harness, launchArgs, options) {
+  const withModel = applyRequestedModelToLaunchArgs(harness, launchArgs, options.model);
+  const requestedReasoningEffort = normalizeRequestedReasoningEffort(options.reasoningEffort);
+  if (!requestedReasoningEffort) {
+    return withModel;
+  }
+  return [
+    ...stripLaunchReasoningEffortForHarness(harness, withModel),
+    ...buildLaunchArgsForRequestedReasoningEffort(harness, requestedReasoningEffort)
+  ];
+}
+function defaultHarnessForOverride(override, fallback = "claude") {
+  return normalizeManagedHarness2(override.defaultHarness ?? override.runtime?.harness, fallback);
+}
+function launchArgsForOverrideHarness(override, harness) {
+  const profileLaunchArgs = override.harnessProfiles?.[harness]?.launchArgs;
+  if (profileLaunchArgs) {
+    return normalizeLaunchArgsForHarness(harness, profileLaunchArgs);
+  }
+  if (harness === defaultHarnessForOverride(override, harness)) {
+    return normalizeLaunchArgsForHarness(harness, override.launchArgs);
+  }
+  return [];
+}
+function overrideHarnessProfile(override, harness) {
+  const profile = override.harnessProfiles?.[harness];
+  return {
+    cwd: normalizeProjectPath2(profile?.cwd || override.runtime?.cwd || override.projectRoot || process.cwd()),
+    transport: normalizeLocalAgentTransport(profile?.transport ?? override.runtime?.transport, harness),
+    sessionId: normalizeTmuxSessionName2(profile?.sessionId, `${override.agentId}-${harness}`),
+    launchArgs: launchArgsForOverrideHarness(override, harness),
+    ...profile?.permissionProfile ? { permissionProfile: profile.permissionProfile } : {}
+  };
+}
+function normalizeManagedHarness2(value, fallback) {
+  return value === "codex" ? "codex" : value === "claude" ? "claude" : value === "cursor" ? "cursor" : value === "pi" ? "pi" : fallback;
+}
+function normalizeLocalHarnessProfiles(agentId, record2) {
+  const defaultHarness = normalizeManagedHarness2(typeof record2.defaultHarness === "string" ? record2.defaultHarness : record2.harness, "claude");
+  const nextProfiles = {};
+  for (const harness of ["claude", "codex", "cursor", "pi"]) {
+    const profile = record2.harnessProfiles?.[harness];
+    if (!profile) {
+      continue;
+    }
+    nextProfiles[harness] = {
+      cwd: normalizeProjectPath2(profile.cwd || record2.cwd || process.cwd()),
+      transport: normalizeLocalAgentTransport(profile.transport, harness),
+      sessionId: normalizeTmuxSessionName2(profile.sessionId, `${agentId}-${harness}`),
+      launchArgs: normalizeLaunchArgsForHarness(harness, profile.launchArgs),
+      ...profile.permissionProfile ? { permissionProfile: profile.permissionProfile } : {}
+    };
+  }
+  const runtimeHarness = normalizeManagedHarness2(record2.harness, defaultHarness);
+  if (!nextProfiles[runtimeHarness]) {
+    nextProfiles[runtimeHarness] = {
+      cwd: normalizeProjectPath2(record2.cwd || process.cwd()),
+      transport: normalizeLocalAgentTransport(record2.transport, runtimeHarness),
+      sessionId: normalizeTmuxSessionName2(record2.tmuxSession, `${agentId}-${runtimeHarness}`),
+      launchArgs: normalizeLaunchArgsForHarness(runtimeHarness, record2.launchArgs),
+      ...record2.permissionProfile ? { permissionProfile: record2.permissionProfile } : {}
+    };
+  }
+  if (!nextProfiles[defaultHarness]) {
+    nextProfiles[defaultHarness] = {
       cwd: normalizeProjectPath2(record2.cwd || process.cwd()),
       transport: normalizeLocalAgentTransport(record2.transport, defaultHarness),
       sessionId: normalizeTmuxSessionName2(record2.tmuxSession, `${agentId}-${defaultHarness}`),
@@ -32290,6 +33063,31 @@ function recordForHarness(record2, 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, record2) {
   const cwd = normalizeProjectPath2(record2.cwd || process.cwd());
   const projectRoot = normalizeProjectPath2(record2.projectRoot || cwd);
@@ -32319,9 +33117,28 @@ function normalizeLocalAgentRecord(agentId, record2) {
     capabilities: normalizeLocalAgentCapabilities(record2.capabilities),
     launchArgs: activeProfile?.launchArgs ?? normalizeLaunchArgsForHarness(harness, record2.launchArgs),
     permissionProfile: activeProfile?.permissionProfile ?? record2.permissionProfile,
-    registrationSource: record2.registrationSource
+    registrationSource: record2.registrationSource,
+    card: normalizeLocalAgentCardLifecycle(record2.card)
+  };
+}
+function localAgentStatusFromRecord(agentId, record2, source) {
+  const normalizedRecord = normalizeLocalAgentRecord(agentId, record2);
+  return {
+    agentId,
+    definitionId: normalizedRecord.definitionId ?? agentId,
+    projectName: normalizedRecord.project,
+    projectRoot: normalizedRecord.projectRoot ?? normalizedRecord.cwd,
+    sessionId: normalizedRecord.tmuxSession,
+    startedAt: normalizedRecord.startedAt,
+    harness: normalizeLocalAgentHarness(normalizedRecord.harness),
+    transport: normalizedRecord.transport,
+    isOnline: isLocalAgentRecordOnline(agentId, normalizedRecord),
+    source
   };
 }
+function localAgentStatusSource(agentId, overrides) {
+  return overrides[agentId]?.source === "manual" ? "manual" : "configured";
+}
 function localAgentRecordFromResolvedConfig(config2) {
   return normalizeLocalAgentRecord(config2.agentId, {
     definitionId: config2.definitionId,
@@ -32355,7 +33172,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, record2, existing) {
@@ -32376,6 +33194,7 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record2, existing) {
     capabilities: normalizeLocalAgentCapabilities(normalizedRecord.capabilities),
     defaultHarness: normalizeManagedHarness2(normalizedRecord.defaultHarness, "claude"),
     harnessProfiles: normalizedRecord.harnessProfiles,
+    ...normalizedRecord.card ? { card: normalizedRecord.card } : {},
     runtime: {
       cwd: normalizeProjectPath2(normalizedRecord.cwd),
       harness: normalizeLocalAgentHarness(normalizedRecord.harness),
@@ -32387,8 +33206,8 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record2, existing) {
 }
 async function ensureLocalSessionEndpointOnline(endpoint) {
   if (endpoint.transport === "codex_app_server") {
-    await ensureCodexAppServerAgentOnline(buildCodexEndpointSessionOptions(endpoint));
-    return {};
+    const result = await ensureCodexAppServerAgentOnline(buildCodexEndpointSessionOptions(endpoint));
+    return { externalSessionId: result.threadId };
   }
   if (endpoint.transport === "claude_stream_json") {
     const result = await ensureClaudeStreamJsonAgentOnline(buildClaudeEndpointSessionOptions(endpoint));
@@ -32405,6 +33224,118 @@ async function shutdownLocalSessionEndpoint(endpoint) {
     await shutdownClaudeStreamJsonAgent(buildClaudeEndpointSessionOptions(endpoint));
   }
 }
+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 = normalizeProjectPath2(input.projectRoot);
+    const cardRoot = normalizeProjectPath2(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 record2 = localAgentRecordFromRelayAgentOverride(agentId, override);
+    const status = localAgentStatusFromRecord(agentId, record2, 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 retireConsumedOneTimeLocalAgentCards(input) {
+  const conversationId = input.conversationId.trim();
+  const actorId = input.actorId.trim();
+  if (!conversationId || !actorId) {
+    return [];
+  }
+  const participants = new Set(input.participantIds.map((entry) => entry.trim()).filter(Boolean));
+  if (participants.size === 0) {
+    return [];
+  }
+  const overrides = await readRelayAgentOverrides();
+  const retireIds = new Set;
+  for (const [agentId, override] of Object.entries(overrides)) {
+    if (!participants.has(agentId)) {
+      continue;
+    }
+    const lifecycle2 = normalizeLocalAgentCardLifecycle(override.card);
+    if (lifecycle2?.kind !== "one_time") {
+      continue;
+    }
+    if (lifecycle2.createdById && lifecycle2.createdById === actorId) {
+      continue;
+    }
+    if (agentId === actorId) {
+      continue;
+    }
+    retireIds.add(agentId);
+  }
+  return retireLocalAgentOverrides({ ...overrides }, retireIds);
+}
 function buildCodexAgentSessionOptions(agentName, record2, systemPrompt) {
   const permissionPosture = compileCodexPermissionProfile(record2.permissionProfile);
   return {
@@ -32435,6 +33366,22 @@ function endpointMetadataString(endpoint, key) {
   const value = endpoint.metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+function endpointMetadataStringArray(endpoint, key) {
+  const value = endpoint.metadata?.[key];
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry).trim()).filter(Boolean);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  return [];
+}
+function attachedCodexEndpointLaunchArgs(endpoint) {
+  return applyRequestedRuntimeOptionsToLaunchArgs("codex", endpointMetadataStringArray(endpoint, "launchArgs"), {
+    model: endpointMetadataString(endpoint, "model"),
+    reasoningEffort: endpointMetadataString(endpoint, "reasoningEffort")
+  });
+}
 function endpointInvocationPrompt(endpoint, agentName, invocation) {
   const source = endpointMetadataString(endpoint, "source");
   const externalSource = endpointMetadataString(endpoint, "externalSource");
@@ -32472,7 +33419,8 @@ function attachedLocalSessionSystemPrompt(endpoint) {
 }
 function buildCodexEndpointSessionOptions(endpoint) {
   const agentName = endpointAgentName(endpoint);
-  const threadId = endpointMetadataString(endpoint, "threadId") ?? endpointMetadataString(endpoint, "externalSessionId") ?? endpoint.sessionId ?? undefined;
+  const ownsSessionThread = endpoint.metadata?.source === "scoutbot";
+  const threadId = ownsSessionThread ? undefined : endpointMetadataString(endpoint, "threadId") ?? endpointMetadataString(endpoint, "externalSessionId") ?? endpoint.sessionId ?? undefined;
   return {
     agentName,
     sessionId: endpointRuntimeInstanceId(endpoint),
@@ -32480,9 +33428,9 @@ function buildCodexEndpointSessionOptions(endpoint) {
     systemPrompt: attachedLocalSessionSystemPrompt(endpoint),
     runtimeDirectory: relayAgentRuntimeDirectory(agentName),
     logsDirectory: relayAgentLogsDirectory(agentName),
-    launchArgs: [],
+    launchArgs: attachedCodexEndpointLaunchArgs(endpoint),
     threadId,
-    requireExistingThread: Boolean(threadId)
+    requireExistingThread: Boolean(threadId) && !ownsSessionThread
   };
 }
 function buildClaudeEndpointSessionOptions(endpoint) {
@@ -32659,7 +33607,7 @@ function buildScoutReplyContextPrompt(context) {
   ] : [
     "> Do not publish a separate acknowledgement or progress update through Scout for this request.",
     "> Your final assistant message will be delivered back through the Scout broker.",
-    "> Do not call `messages_reply`, `scout_reply`, `scout send`, `messages_send`, or `invocations_ask` to answer this request."
+    "> Do not call `messages_reply`, `scout_reply`, `scout send`, `messages_send`, or `ask` to answer this request."
   ];
   const header = [
     "<!-- SCOUT BROKER REPLY MODE -->",
@@ -32770,35 +33718,228 @@ function stripLocalAgentReplyMetadata(body, flightId, asker) {
 async function sendLocalAgentPrompt(agentName, record2, prompt) {
   const harness = normalizeLocalAgentHarness(record2.harness);
   if (harness === "codex") {
-    const promptPipe = join18(relayAgentRuntimeDirectory(agentName), "prompt.pipe");
+    const promptPipe = join19(relayAgentRuntimeDirectory(agentName), "prompt.pipe");
     await writeFile7(promptPipe, prompt.trim() + "\x00");
     return;
   }
-  sendTmuxPrompt(record2.tmuxSession, prompt, buildTmuxPromptSubmitKeys(harness));
+  await sendTmuxPrompt(record2.tmuxSession, prompt, buildTmuxDispatchStrategy(harness, prompt));
+}
+var TMUX_PASTE_DRAIN_MS = 150;
+var TMUX_VERIFY_FIRST_SAMPLE_MS = 250;
+var TMUX_VERIFY_SECOND_SAMPLE_MS = 750;
+var TMUX_VERIFY_RETRY_SAMPLE_MS = 400;
+var TMUX_CAPTURE_TAIL_LINES = 20;
+var TMUX_READY_TIMEOUT_MS = 20000;
+var TMUX_READY_POLL_MS = 250;
+var TMUX_READY_TAIL_LINES = 80;
+function buildTmuxDispatchStrategy(harness, prompt) {
+  const promptAbsentFromTail = (paneTail) => !tmuxPaneTailContainsPromptFragment(paneTail, prompt);
+  if (harness === "pi") {
+    return { submit: ["Enter"], verify: promptAbsentFromTail };
+  }
+  return { submit: ["Enter"], verify: promptAbsentFromTail };
 }
-function sendTmuxPrompt(sessionName, prompt, submitKeys = buildTmuxPromptSubmitKeys()) {
+async function sendTmuxPrompt(sessionName, prompt, strategy) {
+  const effectiveStrategy = strategy ?? buildTmuxDispatchStrategy("claude", prompt);
   const bufferName = `openscout-prompt-${randomUUID2()}`;
+  let bufferOwned = true;
   try {
+    if (effectiveStrategy.pre && effectiveStrategy.pre.length > 0) {
+      execFileSync3("tmux", ["send-keys", "-t", sessionName, ...effectiveStrategy.pre], { stdio: "pipe" });
+    }
     execFileSync3("tmux", ["load-buffer", "-b", bufferName, "-"], {
       stdio: "pipe",
       input: prompt
     });
-    execFileSync3("tmux", ["paste-buffer", "-d", "-b", bufferName, "-t", sessionName], {
+    execFileSync3("tmux", buildTmuxPasteBufferArgs(bufferName, sessionName), {
       stdio: "pipe"
     });
-    execFileSync3("tmux", ["send-keys", "-t", sessionName, ...submitKeys], { stdio: "pipe" });
+    bufferOwned = false;
+    await tmuxDispatchSleep(TMUX_PASTE_DRAIN_MS);
+    execFileSync3("tmux", ["send-keys", "-t", sessionName, ...effectiveStrategy.submit], { stdio: "pipe" });
+    if (await dispatchVerifiedAfter(sessionName, effectiveStrategy, TMUX_VERIFY_FIRST_SAMPLE_MS)) {
+      return { submitted: true, retries: 0 };
+    }
+    if (await dispatchVerifiedAfter(sessionName, effectiveStrategy, TMUX_VERIFY_SECOND_SAMPLE_MS)) {
+      return { submitted: true, retries: 0 };
+    }
+    execFileSync3("tmux", ["send-keys", "-t", sessionName, "Enter"], { stdio: "pipe" });
+    if (await dispatchVerifiedAfter(sessionName, effectiveStrategy, TMUX_VERIFY_RETRY_SAMPLE_MS)) {
+      return { submitted: true, retries: 1 };
+    }
+    throw new DispatchStalledError({
+      sessionName,
+      paneTail: captureTmuxPaneTail(sessionName, TMUX_CAPTURE_TAIL_LINES).slice(0, 2000),
+      retries: 1
+    });
   } catch (error48) {
-    try {
-      execFileSync3("tmux", ["delete-buffer", "-b", bufferName], { stdio: "pipe" });
-    } catch {}
+    if (bufferOwned) {
+      try {
+        execFileSync3("tmux", ["delete-buffer", "-b", bufferName], { stdio: "pipe" });
+      } catch {}
+    }
     throw error48;
   }
 }
-function buildTmuxPromptSubmitKeys(harness = "claude") {
-  if (harness === "pi") {
-    return ["Enter"];
+function buildTmuxPasteBufferArgs(bufferName, sessionName) {
+  return ["paste-buffer", "-dpr", "-b", bufferName, "-t", sessionName];
+}
+function tmuxDispatchSleep(ms) {
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
+}
+async function dispatchVerifiedAfter(sessionName, strategy, delayMs) {
+  await tmuxDispatchSleep(delayMs);
+  const paneTail = captureTmuxPaneTail(sessionName, TMUX_CAPTURE_TAIL_LINES);
+  if (!paneTail) {
+    return true;
   }
-  return ["C-[", "Enter"];
+  return strategy.verify(paneTail);
+}
+function captureTmuxPaneTail(sessionName, lines) {
+  try {
+    return execFileSync3("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 tmuxPaneTailContainsPromptFragment(paneTail, prompt) {
+  const cleanedTail = stripTerminalControlSequences(paneTail);
+  const composerText = extractActiveTmuxComposerText(cleanedTail);
+  if (composerText !== null) {
+    return textContainsPromptFragment(composerText, prompt);
+  }
+  if (tmuxPaneTailShowsHarnessActivity(cleanedTail)) {
+    return false;
+  }
+  return textContainsPromptFragment(cleanedTail, prompt);
+}
+function textContainsPromptFragment(haystack, prompt) {
+  const normalizedTail = haystack.replace(/\s+/g, " ").trim();
+  if (!normalizedTail)
+    return false;
+  const normalizedPrompt = prompt.replace(/\s+/g, " ").trim();
+  if (normalizedPrompt.length < 24) {
+    return normalizedPrompt.length > 0 && normalizedTail.includes(normalizedPrompt);
+  }
+  const midpoint = Math.floor(normalizedPrompt.length / 2);
+  const windows = [
+    normalizedPrompt.slice(0, 40),
+    normalizedPrompt.slice(Math.max(0, midpoint - 20), midpoint + 20),
+    normalizedPrompt.slice(Math.max(0, normalizedPrompt.length - 40))
+  ];
+  return windows.some((w) => w.length >= 24 && normalizedTail.includes(w));
+}
+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 extractActiveTmuxComposerText(paneTail) {
+  const lines = paneTail.split(/\r?\n/);
+  const anchor = findActiveTmuxComposerAnchor(lines);
+  if (!anchor) {
+    return null;
+  }
+  return anchor.kind === "inline" ? collectInlineComposerText(lines, anchor.index) : collectBoxedComposerText(lines, anchor.index);
+}
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1;index >= 0; index -= 1) {
+    if (predicate(items[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function collectInlineComposerText(lines, startIndex) {
+  const collected = [lines[startIndex].replace(/^\s*[\u276F\u203A]\s*/, "")];
+  for (let index = startIndex + 1;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (isTmuxComposerBoundary(line)) {
+      break;
+    }
+    collected.push(line);
+  }
+  return collected.join(" ").trim();
+}
+function collectBoxedComposerText(lines, startIndex) {
+  const collected = [];
+  for (let index = startIndex;index < lines.length; index += 1) {
+    const line = lines[index];
+    if (index > startIndex && isTmuxComposerBoundary(line)) {
+      break;
+    }
+    if (!/^\s*[\u2502\u2503]/.test(line)) {
+      if (isTmuxComposerBoundary(line)) {
+        break;
+      }
+      collected.push(line);
+      continue;
+    }
+    const content = line.replace(/^\s*[\u2502\u2503]\s*/, "").replace(/\s*[\u2502\u2503]\s*$/, "").replace(index === startIndex ? /^[>\u276F]\s*/ : /^/, "");
+    collected.push(content);
+  }
+  return collected.join(" ").trim();
+}
+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(" ");
@@ -32810,10 +33951,10 @@ function buildLocalAgentLaunchCommand(agentName, record2, projectPath, promptFil
   const harness = normalizeLocalAgentHarness(record2.harness);
   const extraArgs = shellQuoteArguments(harness === "claude" ? normalizeClaudeRuntimeLaunchArgs(record2.launchArgs) : normalizeLaunchArgsForHarness(harness, record2.launchArgs));
   if (harness === "codex") {
-    return `exec bash ${JSON.stringify(workerScript ?? join18(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
+    return `exec bash ${JSON.stringify(workerScript ?? join19(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
   if (harness === "pi") {
-    const sessionDir = join18(relayAgentRuntimeDirectory(agentName), "pi-sessions");
+    const sessionDir = join19(relayAgentRuntimeDirectory(agentName), "pi-sessions");
     return [
       "pi",
       `--append-system-prompt "$(cat ${JSON.stringify(promptFile)})"`,
@@ -32833,6 +33974,11 @@ function buildLocalAgentLaunchCommand(agentName, record2, projectPath, promptFil
 function buildTmuxLaunchShellCommand(launchScript) {
   return `exec bash ${JSON.stringify(launchScript)}`;
 }
+function killAgentSession(sessionName) {
+  try {
+    execSync(`tmux kill-session -t ${JSON.stringify(sessionName)}`, { stdio: "pipe" });
+  } catch {}
+}
 function areHarnessBinariesAvailable(record2) {
   const harness = normalizeLocalAgentHarness(record2.harness);
   const binaries = new Set;
@@ -32878,7 +34024,7 @@ async function ensureLocalAgentOnline(agentName, record2) {
   await mkdir7(agentRuntimeDir, { recursive: true });
   await mkdir7(logsDir, { recursive: true });
   if (normalizedRecord.transport === "codex_app_server") {
-    await writeFile7(join18(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile7(join19(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureCodexAppServerAgentOnline(buildCodexAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry3 = await readLocalAgentRegistry();
     registry3[agentName] = {
@@ -32890,7 +34036,7 @@ async function ensureLocalAgentOnline(agentName, record2) {
     return registry3[agentName];
   }
   if (normalizedRecord.transport === "claude_stream_json") {
-    await writeFile7(join18(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile7(join19(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureClaudeStreamJsonAgentOnline(buildClaudeAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry3 = await readLocalAgentRegistry();
     registry3[agentName] = {
@@ -32903,17 +34049,17 @@ async function ensureLocalAgentOnline(agentName, record2) {
   }
   const initialMessage = buildLocalAgentInitialMessage(projectName, agentName);
   const bootstrapPrompt = buildLocalAgentBootstrapPrompt(normalizeLocalAgentHarness(normalizedRecord.harness), systemPrompt, initialMessage);
-  const queueDirectory = join18(agentRuntimeDir, "queue");
-  const processingDirectory = join18(queueDirectory, "processing");
-  const processedDirectory = join18(queueDirectory, "processed");
-  const promptFile = join18(agentRuntimeDir, "prompt.txt");
-  const initialFile = join18(agentRuntimeDir, "initial.txt");
-  const launchScript = join18(agentRuntimeDir, "launch.sh");
-  const workerScript = join18(agentRuntimeDir, "codex-worker.sh");
-  const codexSessionIdFile = join18(agentRuntimeDir, "codex-session-id.txt");
-  const stateFile = join18(agentRuntimeDir, "state.json");
-  const stdoutLogFile = join18(logsDir, "stdout.log");
-  const stderrLogFile = join18(logsDir, "stderr.log");
+  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");
   await writeFile7(promptFile, systemPrompt);
   await writeFile7(initialFile, bootstrapPrompt);
   await writeFile7(stderrLogFile, "");
@@ -32978,11 +34124,17 @@ async function ensureLocalAgentOnline(agentName, record2) {
     await new Promise((resolve8) => setTimeout(resolve8, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync13(stderrLogFile) ? readFileSync6(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync14(stderrLogFile) ? readFileSync7(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 (error48) {
+    killAgentSession(normalizedRecord.tmuxSession);
+    throw error48;
+  }
   const registry2 = await readLocalAgentRegistry();
   registry2[agentName] = {
     ...normalizedRecord,
@@ -32992,12 +34144,249 @@ ${stderrTail}` : `Relay agent ${agentName} failed to stay online.`);
   await writeLocalAgentRegistry(registry2);
   return registry2[agentName];
 }
+async function startLocalAgent(input) {
+  const projectPath = normalizeProjectPath2(input.projectPath);
+  const preferredHarness = input.harness ? normalizeLocalAgentHarness(input.harness) : undefined;
+  const currentDirectory = input.currentDirectory ?? projectPath;
+  const effectiveCwd = input.cwdOverride ? normalizeProjectPath2(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}".`);
+  }
+  const overrides = await readRelayAgentOverrides();
+  const findMatchForRoot = (root) => {
+    let fallback = null;
+    for (const [id, override] of Object.entries(overrides)) {
+      if (BUILT_IN_AGENT_DEFINITION_IDS.has(id))
+        continue;
+      if (!override.projectRoot)
+        continue;
+      if (normalizeProjectPath2(override.projectRoot) !== root)
+        continue;
+      if (requestedDefinitionId && override.definitionId === requestedDefinitionId) {
+        return { agentId: id, override };
+      }
+      if (!fallback)
+        fallback = { agentId: id, override };
+    }
+    return fallback;
+  };
+  let matched = findMatchForRoot(projectPath);
+  let projectRoot = projectPath;
+  if (!matched) {
+    const resolved = await findNearestProjectRoot(projectPath);
+    if (resolved && resolved !== projectPath) {
+      projectRoot = normalizeProjectPath2(resolved);
+      matched = findMatchForRoot(projectRoot);
+    }
+  }
+  let matchingAgentId = matched?.agentId;
+  let matchingOverride = matched?.override;
+  let coldProjectConfigPath = null;
+  let targetAgentId;
+  let coldProjectConfig = null;
+  if (!matchingOverride) {
+    const ensuredProject = await ensureProjectConfigForDirectory(projectPath);
+    projectRoot = ensuredProject.projectRoot ?? projectPath;
+    coldProjectConfigPath = ensuredProject.projectConfigPath ?? null;
+    coldProjectConfig = ensuredProject.config ?? null;
+    matched = findMatchForRoot(projectRoot);
+    matchingAgentId = matched?.agentId;
+    matchingOverride = matched?.override;
+  }
+  if (!matchingOverride) {
+    const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
+    const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename9(projectRoot)) || "agent";
+    const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
+    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");
+    const transport = normalizeLocalAgentTransport(undefined, effectiveHarness);
+    const sessionId = normalizeTmuxSessionName2(undefined, `${instance.id}-${effectiveHarness}`);
+    const launchArgs = applyRequestedRuntimeOptionsToLaunchArgs(effectiveHarness, [], {
+      model: input.model,
+      reasoningEffort: input.reasoningEffort
+    });
+    const existingForInstance = overrides[instance.id];
+    if (existingForInstance && normalizeProjectPath2(existingForInstance.projectRoot) !== projectRoot) {
+      throw new Error(`Another agent is already registered as ${instance.id} at ${existingForInstance.projectRoot}. ` + `Two clones of the same project on the same branch cannot both register here; ` + `rename one of the checkouts or switch its branch before running scout up.`);
+    }
+    overrides[instance.id] = {
+      agentId: instance.id,
+      definitionId,
+      displayName: effectiveDisplayName,
+      projectName: basename9(projectRoot),
+      projectRoot,
+      projectConfigPath: coldProjectConfigPath,
+      source: "manual",
+      startedAt: nowSeconds2(),
+      ...operatorAugmentDefaults ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
+      launchArgs,
+      defaultHarness: effectiveHarness,
+      ...cardLifecycle ? { card: cardLifecycle } : {},
+      harnessProfiles: {
+        [effectiveHarness]: {
+          cwd: effectiveCwd ?? projectRoot,
+          transport,
+          sessionId,
+          launchArgs,
+          ...requestedPermissionProfile ? { permissionProfile: requestedPermissionProfile } : {}
+        }
+      },
+      runtime: {
+        cwd: effectiveCwd ?? projectRoot,
+        harness: effectiveHarness,
+        transport,
+        sessionId,
+        wakePolicy: "on_demand"
+      }
+    };
+    await writeRelayAgentOverrides(overrides);
+    targetAgentId = instance.id;
+  } else if (requestedDefinitionId && requestedDefinitionId !== matchingOverride.definitionId) {
+    const matchingProjectRoot = normalizeProjectPath2(matchingOverride.projectRoot);
+    const instance = buildRelayAgentInstance(requestedDefinitionId, matchingProjectRoot);
+    const existingForInstance = overrides[instance.id];
+    if (existingForInstance && normalizeProjectPath2(existingForInstance.projectRoot) !== matchingProjectRoot) {
+      throw new Error(`Another agent is already registered as ${instance.id} at ${existingForInstance.projectRoot}. ` + `Two clones of the same project on the same branch cannot both register here; ` + `rename one of the checkouts or switch its branch before running scout up.`);
+    }
+    const resolvedHarness = preferredHarness ?? matchingOverride.runtime?.harness;
+    const nextHarness = normalizeManagedHarness2(resolvedHarness, "claude");
+    const nextDefaultHarness = preferredHarness ? normalizeManagedHarness2(preferredHarness, "claude") : defaultHarnessForOverride(matchingOverride, "claude");
+    const nextSessionId = normalizeTmuxSessionName2(undefined, `${instance.id}-${nextHarness}`);
+    const nextLaunchArgs = applyRequestedRuntimeOptionsToLaunchArgs(nextHarness, launchArgsForOverrideHarness(matchingOverride, nextHarness), {
+      model: input.model,
+      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 || operatorAugmentDefaults?.displayName || titleCaseLocalAgentName(requestedDefinitionId),
+      projectName: matchingOverride.projectName ?? basename9(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]: {
+          ...overrideHarnessProfile(matchingOverride, nextHarness),
+          transport: nextTransport,
+          sessionId: nextSessionId,
+          launchArgs: nextLaunchArgs,
+          ...requestedPermissionProfile ? { permissionProfile: requestedPermissionProfile } : {}
+        }
+      },
+      runtime: {
+        cwd: effectiveCwd ?? matchingOverride.runtime?.cwd ?? matchingProjectRoot,
+        harness: nextHarness,
+        transport: nextTransport,
+        sessionId: nextSessionId,
+        wakePolicy: "on_demand"
+      }
+    };
+    await writeRelayAgentOverrides(overrides);
+    targetAgentId = instance.id;
+  } else {
+    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,
+        reasoningEffort: input.reasoningEffort
+      });
+      overrides[matchingAgentId] = {
+        ...matchingOverride,
+        ...cardLifecycle ? { card: cardLifecycle } : {},
+        ...shouldApplyOperatorAugmentPrompt ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
+        launchArgs: existingHarness === defaultHarnessForOverride(matchingOverride, existingHarness) ? nextLaunchArgs : matchingOverride.launchArgs,
+        harnessProfiles: {
+          ...matchingOverride.harnessProfiles ?? {},
+          [existingHarness]: {
+            ...overrideHarnessProfile(matchingOverride, existingHarness),
+            launchArgs: nextLaunchArgs,
+            ...requestedPermissionProfile ? { permissionProfile: requestedPermissionProfile } : {}
+          }
+        }
+      };
+      await writeRelayAgentOverrides(overrides);
+    }
+    targetAgentId = matchingAgentId;
+  }
+  if (shouldEnsureOnline) {
+    await ensureLocalAgentBindingOnline(targetAgentId, process.env.OPENSCOUT_NODE_ID ?? "local", {
+      includeDiscovered: false,
+      currentDirectory,
+      ensureCurrentProjectConfig: false,
+      harness: preferredHarness
+    });
+  }
+  const finalOverrides = await readRelayAgentOverrides();
+  const finalOverride = finalOverrides[targetAgentId];
+  if (!finalOverride) {
+    throw new Error(`Agent ${targetAgentId} did not register successfully.`);
+  }
+  const record2 = localAgentRecordFromRelayAgentOverride(targetAgentId, finalOverride);
+  return localAgentStatusFromRecord(targetAgentId, record2, localAgentStatusSource(targetAgentId, finalOverrides));
+}
+async function stopLocalAgent(agentId) {
+  const [registry2, overrides] = await Promise.all([
+    readLocalAgentRegistry(),
+    readRelayAgentOverrides()
+  ]);
+  const record2 = registry2[agentId];
+  if (!record2) {
+    return null;
+  }
+  const normalizedRecord = normalizeLocalAgentRecord(agentId, record2);
+  const sessionsToStop = new Set([normalizedRecord.tmuxSession]);
+  if (normalizedRecord.transport === "codex_app_server") {
+    for (const sessionName of sessionsToStop) {
+      await shutdownCodexAppServerAgent({
+        ...buildCodexAgentSessionOptions(agentId, normalizedRecord),
+        sessionId: sessionName
+      }, {
+        resetThread: true
+      });
+    }
+  } else if (normalizedRecord.transport === "claude_stream_json") {
+    for (const sessionName of sessionsToStop) {
+      await shutdownClaudeStreamJsonAgent({
+        ...buildClaudeAgentSessionOptions(agentId, normalizedRecord),
+        sessionId: sessionName
+      }, {
+        resetSession: true
+      });
+    }
+  } else {
+    for (const sessionName of sessionsToStop) {
+      killAgentSession(sessionName);
+    }
+  }
+  return {
+    ...localAgentStatusFromRecord(agentId, normalizedRecord, localAgentStatusSource(agentId, overrides)),
+    isOnline: false
+  };
+}
 function readPersistedClaudeSessionId(agentName) {
   try {
     const runtimeDir = relayAgentRuntimeDirectory(agentName);
-    const catalogPath = join18(runtimeDir, "session-catalog.json");
-    if (existsSync13(catalogPath)) {
-      const raw = readFileSync6(catalogPath, "utf8").trim();
+    const catalogPath = join19(runtimeDir, "session-catalog.json");
+    if (existsSync14(catalogPath)) {
+      const raw = readFileSync7(catalogPath, "utf8").trim();
       if (raw) {
         const catalog = JSON.parse(raw);
         if (typeof catalog.activeSessionId === "string" && catalog.activeSessionId.trim()) {
@@ -33005,9 +34394,9 @@ function readPersistedClaudeSessionId(agentName) {
         }
       }
     }
-    const legacyPath = join18(runtimeDir, "claude-session-id.txt");
-    if (existsSync13(legacyPath)) {
-      const value = readFileSync6(legacyPath, "utf8").trim();
+    const legacyPath = join19(runtimeDir, "claude-session-id.txt");
+    if (existsSync14(legacyPath)) {
+      const value = readFileSync7(legacyPath, "utf8").trim();
       return value || null;
     }
     return null;
@@ -33019,6 +34408,7 @@ function buildLocalAgentBinding(agentId, record2, alive, nodeId, source) {
   const normalizedRecord = normalizeLocalAgentRecord(agentId, record2);
   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;
@@ -33046,6 +34436,7 @@ function buildLocalAgentBinding(agentId, record2, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -33081,6 +34472,7 @@ function buildLocalAgentBinding(agentId, record2, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -33121,6 +34513,7 @@ function buildLocalAgentBinding(agentId, record2, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -33212,7 +34605,8 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
       replyContext
     });
     return {
-      output: result.output
+      output: result.output,
+      externalSessionId: result.threadId
     };
   }
   if (!existing && endpoint.transport === "claude_stream_json") {
@@ -33223,7 +34617,8 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
       timeoutMs: invocation.timeoutMs
     });
     return {
-      output: result.output
+      output: result.output,
+      externalSessionId: result.sessionId
     };
   }
   const projectRoot = endpoint.projectRoot ?? endpoint.cwd;
@@ -33262,7 +34657,8 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
       replyContext
     });
     return {
-      output: result.output
+      output: result.output,
+      externalSessionId: result.threadId
     };
   }
   if (onlineRecord.transport === "claude_stream_json") {
@@ -33272,7 +34668,8 @@ async function invokeLocalAgentEndpoint(endpoint, invocation) {
       timeoutMs: invocation.timeoutMs
     });
     return {
-      output: result.output
+      output: result.output,
+      externalSessionId: result.sessionId
     };
   }
   const flightId = createLocalAgentFlightId();
@@ -33361,6 +34758,7 @@ function buildScoutAgentCard(binding, options = {}) {
   const supportedInterfaces = metadataRecordArray(binding.agent.metadata, "supportedInterfaces");
   const securitySchemes = metadataRecord3(binding.agent.metadata, "securitySchemes");
   const securityRequirements = metadataStringMatrix(binding.agent.metadata, "securityRequirements");
+  const lifecycle2 = options.lifecycle ?? metadataRecord3(binding.agent.metadata, "cardLifecycle");
   return {
     id: binding.agent.id,
     agentId: binding.agent.id,
@@ -33390,6 +34788,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,
@@ -33407,7 +34806,8 @@ function buildScoutAgentCard(binding, options = {}) {
       actorId: binding.actor.id,
       endpointId: binding.endpoint.id,
       wakePolicy: binding.agent.wakePolicy,
-      ...model ? { model } : {}
+      ...model ? { model } : {},
+      ...lifecycle2 ? { cardLifecycle: lifecycle2 } : {}
     }
   };
 }
@@ -33471,9 +34871,9 @@ function upsertScoutAgentCardFromInput(runtime, input) {
 }
 
 // packages/runtime/src/pairing-session-agents.ts
-import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
-import { basename as basename10, join as join19 } from "path";
-import { homedir as homedir14 } from "os";
+import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
+import { basename as basename10, join as join20 } from "path";
+import { homedir as homedir15 } from "os";
 var DEFAULT_PAIRING_PORT = 7888;
 var PAIRING_CONNECT_TIMEOUT_MS = 1500;
 var PAIRING_REQUEST_TIMEOUT_MS = 1e4;
@@ -33481,18 +34881,18 @@ var DEFAULT_PAIRING_POLL_INTERVAL_MS = 350;
 var DEFAULT_PAIRING_INVOCATION_TIMEOUT_MS = 45000;
 var MAX_SYNTHETIC_OUTPUT_CHARS = 1200;
 function pairingPaths() {
-  const rootDir = join19(homedir14(), ".scout", "pairing");
+  const rootDir = join20(homedir15(), ".scout", "pairing");
   return {
-    configPath: join19(rootDir, "config.json"),
-    runtimeStatePath: join19(rootDir, "runtime.json")
+    configPath: join20(rootDir, "config.json"),
+    runtimeStatePath: join20(rootDir, "runtime.json")
   };
 }
 function readJsonFile2(filePath) {
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync7(filePath, "utf8"));
+    return JSON.parse(readFileSync8(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -33502,7 +34902,7 @@ function resolvePairingBridgePort(options = {}) {
     return options.port;
   }
   const { configPath, runtimeStatePath } = pairingPaths();
-  const configExists = existsSync14(configPath);
+  const configExists = existsSync15(configPath);
   const runtimeSnapshot = readJsonFile2(runtimeStatePath);
   if (!configExists && !runtimeSnapshot) {
     return null;
@@ -34043,7 +35443,7 @@ import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname12 } from "path";
 import { Database as Database2 } from "bun:sqlite";
 
-// 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) {
@@ -34068,7 +35468,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;
@@ -34118,7 +35518,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;
@@ -34174,20 +35574,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) {
@@ -34236,7 +35636,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;
@@ -34266,7 +35666,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 = []) {
@@ -34285,10 +35685,10 @@ class WithSubquery extends Subquery {
   static [entityKind] = "WithSubquery";
 }
 
-// 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 = {
@@ -34315,10 +35715,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");
@@ -34362,7 +35762,7 @@ function getTableUniqueName(table) {
   return `${table[Schema] ?? "public"}.${table[TableName]}`;
 }
 
-// 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";
 }
@@ -34642,7 +36042,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   sql2.raw = raw;
-  function join20(chunks, separator) {
+  function join21(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== undefined) {
@@ -34652,7 +36052,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  sql2.join = join20;
+  sql2.join = join21;
   function identifier(value) {
     return new Name(value);
   }
@@ -34742,7 +36142,7 @@ Subquery.prototype.getSQL = function() {
   return new SQL([this]);
 };
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/alias.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/alias.js
 class ColumnAliasProxyHandler {
   constructor(table) {
     this.table = table;
@@ -34821,7 +36221,7 @@ function mapColumnsInSQLToAlias(query, alias) {
   }));
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/errors.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/errors.js
 class DrizzleError extends Error {
   static [entityKind] = "DrizzleError";
   constructor({ message, cause }) {
@@ -34851,7 +36251,7 @@ class TransactionRollbackError extends DrizzleError {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/logger.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/logger.js
 class ConsoleLogWriter {
   static [entityKind] = "ConsoleLogWriter";
   write(message) {
@@ -34883,7 +36283,7 @@ class NoopLogger {
   logQuery() {}
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/query-promise.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/query-promise.js
 class QueryPromise {
   static [entityKind] = "QueryPromise";
   [Symbol.toStringTag] = "QueryPromise";
@@ -34904,7 +36304,7 @@ class QueryPromise {
   }
 }
 
-// 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 mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce((result2, { path, field }, columnIndex) => {
@@ -35058,7 +36458,7 @@ function isConfig(data) {
 }
 var textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/table.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/pg-core/table.js
 var InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
 var EnableRLS = Symbol.for("drizzle:EnableRLS");
 
@@ -35074,7 +36474,7 @@ class PgTable extends Table {
   [Table.Symbol.ExtraConfigColumns] = {};
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/pg-core/primary-keys.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/pg-core/primary-keys.js
 class PrimaryKeyBuilder {
   static [entityKind] = "PgPrimaryKeyBuilder";
   columns;
@@ -35102,7 +36502,7 @@ class PrimaryKey {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/expressions/conditions.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/expressions/conditions.js
 function bindIfParam(value, column) {
   if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
     return new Param(value, column);
@@ -35207,7 +36607,7 @@ function notIlike(column, value) {
   return sql`${column} not ilike ${value}`;
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/expressions/select.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/expressions/select.js
 function asc(column) {
   return sql`${column} asc`;
 }
@@ -35215,7 +36615,7 @@ function desc(column) {
   return sql`${column} desc`;
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/relations.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/relations.js
 class Relation {
   constructor(sourceTable, referencedTable, relationName) {
     this.sourceTable = sourceTable;
@@ -35435,10 +36835,10 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
   return result;
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/bun-sqlite/driver.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/bun-sqlite/driver.js
 import { Database } from "bun:sqlite";
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/selection-proxy.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/selection-proxy.js
 class SelectionProxyHandler {
   static [entityKind] = "SelectionProxyHandler";
   config;
@@ -35490,7 +36890,7 @@ class SelectionProxyHandler {
   }
 }
 
-// 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;
@@ -35544,12 +36944,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 = [];
@@ -35600,7 +37000,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) {
@@ -35688,7 +37088,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) {
@@ -35729,7 +37129,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) {
@@ -35831,7 +37231,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) {
@@ -35901,7 +37301,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) {
@@ -35922,7 +37322,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) {
@@ -35977,7 +37377,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,
@@ -35989,7 +37389,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 InlineForeignKeys2 = Symbol.for("drizzle:SQLiteInlineForeignKeys");
 
 class SQLiteTable extends Table {
@@ -36023,7 +37423,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, unique4) {
     this.name = name;
@@ -36066,7 +37466,7 @@ function index(name) {
   return new IndexBuilderOn(name, false);
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/utils.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/utils.js
 function extractUsedTable(table) {
   if (is(table, SQLiteTable)) {
     return [`${table[Table.Symbol.BaseName]}`];
@@ -36080,7 +37480,7 @@ function extractUsedTable(table) {
   return [];
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/delete.js
 class SQLiteDeleteBase extends QueryPromise {
   constructor(table, session, dialect, withList) {
     super();
@@ -36150,7 +37550,7 @@ class SQLiteDeleteBase extends QueryPromise {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/casing.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/casing.js
 function toSnakeCase(input) {
   const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
   return words.map((word) => word.toLowerCase()).join("_");
@@ -36203,12 +37603,12 @@ class CasingCache {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/view-base.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/view-base.js
 class SQLiteViewBase extends View {
   static [entityKind] = "SQLiteViewBase";
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/dialect.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/dialect.js
 class SQLiteDialect {
   static [entityKind] = "SQLiteDialect";
   casing;
@@ -36791,7 +38191,7 @@ class SQLiteSyncDialect extends SQLiteDialect {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/query-builders/query-builder.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/query-builders/query-builder.js
 class TypedQueryBuilder {
   static [entityKind] = "TypedQueryBuilder";
   getSelectedFields() {
@@ -36799,7 +38199,7 @@ class TypedQueryBuilder {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/select.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/select.js
 class SQLiteSelectBuilder {
   static [entityKind] = "SQLiteSelectBuilder";
   fields;
@@ -36881,7 +38281,7 @@ class SQLiteSelectQueryBuilderBase extends TypedQueryBuilder {
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table))
         this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join20) => join20.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins?.some((join21) => join21.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (!this.isPartialSelect) {
@@ -37097,7 +38497,7 @@ var unionAll = createSetOperator("union", true);
 var intersect = createSetOperator("intersect", false);
 var except = createSetOperator("except", false);
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
 class QueryBuilder {
   static [entityKind] = "SQLiteQueryBuilder";
   dialect;
@@ -37156,7 +38556,7 @@ class QueryBuilder {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/insert.js
 class SQLiteInsertBuilder {
   constructor(table, session, dialect, withList) {
     this.table = table;
@@ -37265,7 +38665,7 @@ class SQLiteInsertBase extends QueryPromise {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/update.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/update.js
 class SQLiteUpdateBuilder {
   constructor(table, session, dialect, withList) {
     this.table = table;
@@ -37295,7 +38695,7 @@ class SQLiteUpdateBase extends QueryPromise {
   createJoin(joinType) {
     return (table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join20) => join20.alias === tableName)) {
+      if (typeof tableName === "string" && this.config.joins.some((join21) => join21.alias === tableName)) {
         throw new Error(`Alias "${tableName}" is already used in this query`);
       }
       if (typeof on === "function") {
@@ -37369,7 +38769,7 @@ class SQLiteUpdateBase extends QueryPromise {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/count.js
 class SQLiteCountBuilder extends SQL {
   constructor(params) {
     super(SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
@@ -37404,7 +38804,7 @@ class SQLiteCountBuilder extends SQL {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/query.js
 class RelationalQueryBuilder {
   constructor(mode, fullSchema, schema, tableNamesMap, table, tableConfig, dialect, session) {
     this.mode = mode;
@@ -37498,7 +38898,7 @@ class SQLiteSyncRelationalQuery extends SQLiteRelationalQuery {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/raw.js
 class SQLiteRaw extends QueryPromise {
   constructor(execute, getSQL, action, dialect, mapBatchResult) {
     super();
@@ -37524,7 +38924,7 @@ class SQLiteRaw extends QueryPromise {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/db.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/db.js
 class BaseSQLiteDatabase {
   constructor(resultKind, dialect, session, schema) {
     this.resultKind = resultKind;
@@ -37647,7 +39047,7 @@ class BaseSQLiteDatabase {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/cache/core/cache.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/cache/core/cache.js
 class Cache {
   static [entityKind] = "Cache";
 }
@@ -37673,7 +39073,7 @@ async function hashQuery(sql2, params) {
   return hashHex;
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/session.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/session.js
 class ExecuteResultSync extends QueryPromise {
   constructor(resultCb) {
     super();
@@ -37846,7 +39246,7 @@ class SQLiteTransaction extends BaseSQLiteDatabase {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/bun-sqlite/session.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/bun-sqlite/session.js
 class SQLiteBunSession extends SQLiteSession {
   constructor(client, dialect, schema, options = {}) {
     super(dialect);
@@ -37945,7 +39345,7 @@ class PreparedQuery extends SQLitePreparedQuery {
   }
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/bun-sqlite/driver.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/bun-sqlite/driver.js
 class BunSQLiteDatabase extends BaseSQLiteDatabase {
   static [entityKind] = "BunSQLiteDatabase";
 }
@@ -37999,6 +39399,7 @@ function drizzle(...params) {
 })(drizzle || (drizzle = {}));
 
 // packages/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"),
@@ -38014,7 +39415,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)
 ]);
@@ -38041,7 +39442,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)
@@ -38058,11 +39459,11 @@ function openControlPlaneDrizzle(client) {
 }
 
 // packages/runtime/src/drizzle-migrate.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join21 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/migrator.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/migrator.js
 import crypto2 from "crypto";
 import fs from "fs";
 function readMigrationFiles(config2) {
@@ -38094,7 +39495,7 @@ function readMigrationFiles(config2) {
   return migrationQueries;
 }
 
-// node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/bun-sqlite/migrator.js
+// node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/bun-sqlite/migrator.js
 function migrate(db, config2) {
   const migrations = readMigrationFiles(config2);
   db.dialect.migrate(migrations, db.session, config2);
@@ -38128,7 +39529,7 @@ CREATE TABLE IF NOT EXISTS actors (
   handle TEXT,
   labels_json TEXT,
   metadata_json TEXT,
-  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER) * 1000)
 );
 
 CREATE TABLE IF NOT EXISTS agents (
@@ -38161,7 +39562,7 @@ CREATE TABLE IF NOT EXISTS agent_endpoints (
   cwd TEXT,
   project_root TEXT,
   metadata_json TEXT,
-  updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+  updated_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER) * 1000)
 );
 
 CREATE TABLE IF NOT EXISTS conversations (
@@ -38175,7 +39576,7 @@ CREATE TABLE IF NOT EXISTS conversations (
   parent_conversation_id TEXT REFERENCES conversations(id) ON DELETE SET NULL,
   message_id TEXT,
   metadata_json TEXT,
-  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER) * 1000)
 );
 
 CREATE TABLE IF NOT EXISTS conversation_members (
@@ -38292,7 +39693,7 @@ CREATE TABLE IF NOT EXISTS deliveries (
   lease_owner TEXT,
   lease_expires_at INTEGER,
   metadata_json TEXT,
-  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER) * 1000)
 );
 
 CREATE TABLE IF NOT EXISTS delivery_attempts (
@@ -38498,9 +39899,9 @@ CREATE TABLE IF NOT EXISTS mobile_push_registrations (
   updated_at INTEGER NOT NULL
 );
 
--- Briefing Room: persistent archive of Ranger-generated briefs.
+-- Briefing Room: persistent archive of Scoutbot-generated briefs.
 -- Each row carries three layers \u2014 snapshot (Layer 1), observations (Layer 2),
--- brief + call (Layer 3) \u2014 so an operator can audit not just what Ranger said
+-- brief + call (Layer 3) \u2014 so an operator can audit not just what Scoutbot said
 -- but what it read and how it asked. Rolling 100-cap is enforced in code.
 CREATE TABLE IF NOT EXISTS briefings (
   id TEXT PRIMARY KEY,
@@ -38518,7 +39919,7 @@ CREATE TABLE IF NOT EXISTS briefings (
   -- markdown pipeline landed; rows persisted after step 3 of SCO-037 carry
   -- the full markdown document the analyst emitted.
   markdown TEXT,
-  created_at INTEGER NOT NULL DEFAULT (unixepoch())
+  created_at INTEGER NOT NULL DEFAULT (CAST(strftime('%s','now') AS INTEGER) * 1000)
 );
 
 CREATE INDEX IF NOT EXISTS idx_nodes_mesh_id
@@ -38629,8 +40030,8 @@ function resolveControlPlaneDrizzleMigrationsFolder() {
 }
 function applyControlPlaneDrizzleMigrations(database) {
   const migrationsFolder = resolveControlPlaneDrizzleMigrationsFolder();
-  const journalPath = join20(migrationsFolder, "meta", "_journal.json");
-  if (!existsSync15(journalPath)) {
+  const journalPath = join21(migrationsFolder, "meta", "_journal.json");
+  if (!existsSync16(journalPath)) {
     return false;
   }
   migrate(openControlPlaneDrizzle(database), { migrationsFolder });
@@ -38641,35 +40042,14 @@ function stampControlPlaneSchemaVersion(database) {
 }
 if (false) {}
 
-// packages/runtime/src/user-config.ts
-import { existsSync as existsSync16, readFileSync as readFileSync8, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { homedir as homedir15 } from "os";
-import { dirname as dirname11, join as join21 } from "path";
-function userConfigPath() {
-  return join21(process.env.OPENSCOUT_HOME ?? join21(homedir15(), ".openscout"), "user.json");
-}
-function loadUserConfig() {
-  const configPath = userConfigPath();
-  if (!existsSync16(configPath))
-    return {};
-  try {
-    return JSON.parse(readFileSync8(configPath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function resolveOperatorName() {
-  const config2 = loadUserConfig();
-  return config2.name?.trim() || process.env.OPENSCOUT_OPERATOR_NAME?.trim() || process.env.USER?.trim() || "operator";
-}
-
 // packages/runtime/src/conversations/legacy-ids.ts
 function conversationIdForAgent(agentId) {
   return buildDirectConversationId("operator", agentId);
 }
 function configuredOperatorActorIds() {
   const operatorName = resolveOperatorName().trim() || "operator";
-  return Array.from(new Set(["operator", operatorName]));
+  const operatorHandle = resolveOperatorHandle().trim() || operatorName;
+  return Array.from(new Set(["operator", operatorName, operatorHandle]));
 }
 function buildDirectConversationId(operatorId, agentId) {
   return `dm.${operatorId}.${agentId}`;
@@ -39984,6 +41364,11 @@ class SQLiteControlPlaneStore {
     const row = queryGet(this.readDb, "SELECT * FROM durable_actions WHERE id = ?1", actionId);
     return row ? durableActionFromRow(row) : null;
   }
+  getDurableActionByIdempotencyKey(input) {
+    const row = queryGet(this.readDb, `SELECT * FROM durable_actions
+       WHERE authority_cell_id = ?1 AND kind = ?2 AND idempotency_key = ?3`, input.authorityCellId, input.kind, input.idempotencyKey);
+    return row ? durableActionFromRow(row) : null;
+  }
   listDueDurableActions(input) {
     const limit = Math.max(1, Math.min(500, Math.floor(input.limit ?? 50)));
     const claimableAt = input.claimableAt ?? input.dueAtLte;
@@ -41431,6 +42816,52 @@ class ThreadEventPlane {
   }
 }
 
+// packages/runtime/src/invocation-lifecycle-read-model.ts
+function readInvocationLifecycle(input) {
+  const invocationId = input.invocationId.trim();
+  if (!invocationId) {
+    return null;
+  }
+  const invocation = input.snapshot.invocations[invocationId];
+  if (!invocation) {
+    return null;
+  }
+  const deliveries2 = input.journal.listDeliveries({ limit: input.deliveryLimit ?? 5000 }).filter((delivery) => deliveryMatchesInvocation(delivery, invocation));
+  const deliveryAttempts = Object.fromEntries(deliveries2.map((delivery) => [
+    delivery.id,
+    input.journal.listDeliveryAttempts(delivery.id)
+  ]));
+  return projectInvocationLifecycle({
+    invocation,
+    flight: latestFlightForInvocation(input.snapshot, invocationId),
+    deliveries: deliveries2,
+    deliveryAttempts,
+    now: input.now ?? Date.now()
+  });
+}
+function latestFlightForInvocation(snapshot, invocationId) {
+  let latest;
+  for (const flight of Object.values(snapshot.flights)) {
+    if (flight.invocationId !== invocationId) {
+      continue;
+    }
+    if (!latest || flightSortTimestamp(flight) > flightSortTimestamp(latest)) {
+      latest = flight;
+    }
+  }
+  return latest;
+}
+function flightSortTimestamp(flight) {
+  return flight.completedAt ?? flight.startedAt ?? 0;
+}
+function deliveryMatchesInvocation(delivery, invocation) {
+  return delivery.invocationId === invocation.id || Boolean(invocation.messageId && delivery.messageId === invocation.messageId) || metadataString3(delivery.metadata, "invocationId") === invocation.id;
+}
+function metadataString3(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
 // packages/runtime/src/broker-core-service.ts
 function normalizeLimit(limit) {
   return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.min(limit, 500) : 100;
@@ -41453,7 +42884,13 @@ function listBrokerMessages(runtime, input = {}) {
     }
     return authored || addressed || participantConversation;
   };
-  return Object.values(snapshot.messages).filter((message) => !input.conversationId || message.conversationId === input.conversationId).filter(matchesParticipant).filter((message) => input.since === null || input.since === undefined ? true : message.createdAt >= input.since).sort((lhs, rhs) => rhs.createdAt - lhs.createdAt).slice(0, limit).reverse();
+  return Object.values(snapshot.messages).filter((message) => !isBrokerRequesterWaitTimeoutStatusMessage(message)).filter((message) => !input.conversationId || message.conversationId === input.conversationId).filter(matchesParticipant).filter((message) => input.since === null || input.since === undefined ? true : message.createdAt >= input.since).sort((lhs, rhs) => rhs.createdAt - lhs.createdAt).slice(0, limit).reverse();
+}
+function isBrokerRequesterWaitTimeoutStatusMessage(message) {
+  if (message.class !== "status" || metadataString4(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");
 }
 async function listBrokerActivity(projection, isReconciledStaleFlightActivityItem, input) {
   const items = await projection.listActivityItems({
@@ -41506,7 +42943,7 @@ function compactText(value, fallback) {
   }
   return text2.length > 240 ? `${text2.slice(0, 237)}...` : text2;
 }
-function metadataString3(metadata, key) {
+function metadataString4(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -41514,6 +42951,82 @@ function metadataNumber(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+function metadataBoolean(metadata, key) {
+  return metadata?.[key] === true;
+}
+function metadataRecord4(metadata, key) {
+  const value = metadata?.[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function agentCardLifecycleKind(agent) {
+  const lifecycle2 = metadataRecord4(agent.metadata, "cardLifecycle");
+  const kind = metadataString4(lifecycle2, "kind");
+  return kind === "persistent" || kind === "one_time" ? kind : null;
+}
+function summarizeBrokerAgentCounts(snapshot, localNodeId) {
+  const counts = {
+    agents: 0,
+    agentRecords: 0,
+    rawAgentRecords: 0,
+    configuredAgents: 0,
+    scoutManagedAgents: 0,
+    currentAgentRegistrations: 0,
+    localAgentRegistrations: 0,
+    remoteAgentRegistrations: 0,
+    staleAgentRegistrations: 0,
+    retiredAgentRegistrations: 0,
+    oneTimeAgentCards: 0,
+    persistentAgentCards: 0
+  };
+  for (const agent of Object.values(snapshot.agents)) {
+    counts.agentRecords += 1;
+    counts.rawAgentRecords += 1;
+    const retired = metadataBoolean(agent.metadata, "retiredFromFleet");
+    const stale = metadataBoolean(agent.metadata, "staleLocalRegistration");
+    const current = !retired && !stale;
+    const local = agent.homeNodeId === localNodeId || agent.authorityNodeId === localNodeId;
+    const lifecycleKind = agentCardLifecycleKind(agent);
+    const oneTimeCard = lifecycleKind === "one_time";
+    const persistentCard = lifecycleKind === "persistent";
+    const source = metadataString4(agent.metadata, "source");
+    const externalSource = metadataString4(agent.metadata, "externalSource");
+    const registryBacked = source === undefined || source === "relay-agent-registry";
+    const durableScoutManaged = source === "scout-managed" && externalSource !== "pairing-session";
+    if (retired) {
+      counts.retiredAgentRegistrations += 1;
+    }
+    if (stale) {
+      counts.staleAgentRegistrations += 1;
+    }
+    if (!current) {
+      continue;
+    }
+    counts.currentAgentRegistrations += 1;
+    if (local) {
+      counts.localAgentRegistrations += 1;
+    } else {
+      counts.remoteAgentRegistrations += 1;
+    }
+    if (oneTimeCard) {
+      counts.oneTimeAgentCards += 1;
+    }
+    if (persistentCard) {
+      counts.persistentAgentCards += 1;
+    }
+    if (!local || oneTimeCard) {
+      continue;
+    }
+    if (registryBacked) {
+      counts.configuredAgents += 1;
+      continue;
+    }
+    if (durableScoutManaged) {
+      counts.scoutManagedAgents += 1;
+    }
+  }
+  counts.agents = counts.configuredAgents + counts.scoutManagedAgents;
+  return counts;
+}
 function messageMentionsAgent(message, agentId) {
   return message.actorId === agentId || Boolean(message.mentions?.some((mention) => mention.actorId === agentId)) || Boolean(message.audience?.notify?.includes(agentId)) || Boolean(message.audience?.invoke?.includes(agentId)) || Boolean(message.audience?.visibleTo?.includes(agentId));
 }
@@ -41683,7 +43196,7 @@ function deliveryToFeedItem(delivery, snapshot, attempts) {
     severity: deliverySeverity(delivery.status),
     at: deliveryAt(delivery, snapshot, attempts),
     title: `Delivery ${delivery.status}`,
-    summary: compactText(metadataString3(delivery.metadata, "failureReason") ?? metadataString3(delivery.metadata, "lastError") ?? `${delivery.reason} via ${delivery.transport}`, delivery.status),
+    summary: compactText(metadataString4(delivery.metadata, "failureReason") ?? metadataString4(delivery.metadata, "lastError") ?? `${delivery.reason} via ${delivery.transport}`, delivery.status),
     agentId: delivery.targetId,
     targetAgentId: delivery.targetId,
     conversationId: invocation?.conversationId,
@@ -41828,8 +43341,8 @@ function endpointStatus(endpoint) {
     sessionId: endpoint.sessionId,
     projectRoot: endpoint.projectRoot,
     cwd: endpoint.cwd,
-    lastError: metadataString3(endpoint.metadata, "lastError"),
-    lastFailureStage: metadataString3(endpoint.metadata, "lastFailureStage"),
+    lastError: metadataString4(endpoint.metadata, "lastError"),
+    lastFailureStage: metadataString4(endpoint.metadata, "lastFailureStage"),
     updatedAt: metadataNumber(endpoint.metadata, "lastFailedAt") ?? metadataNumber(endpoint.metadata, "lastSeenAt")
   };
 }
@@ -41933,6 +43446,7 @@ function createBrokerCoreService(deps) {
     baseUrl: deps.baseUrl,
     readHealth: async () => {
       const snapshot = deps.runtime.snapshot();
+      const agentCounts = summarizeBrokerAgentCounts(snapshot, deps.nodeId);
       return {
         ok: true,
         nodeId: deps.nodeId,
@@ -41940,7 +43454,18 @@ function createBrokerCoreService(deps) {
         counts: {
           nodes: Object.keys(snapshot.nodes).length,
           actors: Object.keys(snapshot.actors).length,
-          agents: Object.keys(snapshot.agents).length,
+          agents: agentCounts.agents,
+          agentRecords: agentCounts.agentRecords,
+          rawAgentRecords: agentCounts.rawAgentRecords,
+          configuredAgents: agentCounts.configuredAgents,
+          scoutManagedAgents: agentCounts.scoutManagedAgents,
+          currentAgentRegistrations: agentCounts.currentAgentRegistrations,
+          localAgentRegistrations: agentCounts.localAgentRegistrations,
+          remoteAgentRegistrations: agentCounts.remoteAgentRegistrations,
+          staleAgentRegistrations: agentCounts.staleAgentRegistrations,
+          retiredAgentRegistrations: agentCounts.retiredAgentRegistrations,
+          oneTimeAgentCards: agentCounts.oneTimeAgentCards,
+          persistentAgentCards: agentCounts.persistentAgentCards,
           conversations: Object.keys(snapshot.conversations).length,
           messages: Object.keys(snapshot.messages).length,
           flights: Object.keys(snapshot.flights).length,
@@ -41958,6 +43483,11 @@ function createBrokerCoreService(deps) {
     readUnblockRequests: async (query) => listBrokerUnblockRequests(deps.journal, query),
     readUnblockRequestEvents: async (query) => listBrokerUnblockRequestEvents(deps.journal, query),
     readAgentBrokerFeed: async (query) => await readAgentBrokerFeed(deps, query),
+    readInvocationLifecycle: async (query) => readInvocationLifecycle({
+      snapshot: deps.runtime.snapshot(),
+      journal: deps.journal,
+      invocationId: query.invocationId
+    }),
     readThreadEvents: async (query) => await deps.threadEvents.replay({
       conversationId: query.conversationId,
       afterSeq: query.afterSeq ?? 0,
@@ -42652,6 +44182,9 @@ async function broadcastApnsAlertToActiveMobileDevices(alert) {
 }
 
 // packages/runtime/src/broker-daemon.ts
+var PROCESS_NAME = "scout-broker";
+var WEB_PROCESS_NAME = "scout-web";
+process.title = PROCESS_NAME;
 function createRuntimeId2(prefix) {
   return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -42728,6 +44261,7 @@ var parentPid = Number.parseInt(process.env.OPENSCOUT_PARENT_PID ?? "0", 10);
 var localAgentSyncIntervalMs = Number.parseInt(process.env.OPENSCOUT_LOCAL_AGENT_SYNC_INTERVAL_MS ?? "5000", 10);
 var registeredLocalAgentsRegistrySignature = null;
 var registeredLocalAgentsSyncInFlight = null;
+var DEFAULT_IMPLICIT_PROJECT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
 ensureOpenScoutCleanSlateSync();
 var existingBroker = await probeExistingBroker();
 if (existingBroker) {
@@ -42824,6 +44358,7 @@ var DEFAULT_INBOX_STATUSES = new Set([
   "deferred",
   "leased"
 ]);
+var STALE_MESH_AUTHORITY_NODE_MS = 24 * 60 * 60 * 1000;
 async function listInboxItems(options) {
   const statuses = options.statuses ?? DEFAULT_INBOX_STATUSES;
   const limit = Math.min(Math.max(options.limit ?? 100, 1), 500);
@@ -43231,18 +44766,47 @@ function spawnWebServer(context = {}) {
     trustedHost: context.trustedHost
   });
   const child = spawn5(bun.path, entry.endsWith(".ts") ? ["run", "--hot", entry] : ["run", entry], {
+    argv0: WEB_PROCESS_NAME,
     detached: true,
     env,
     stdio: ["ignore", logFd, logFd]
   });
-  child.once("exit", () => {
-    if (webServerProcess === child) {
-      webServerProcess = null;
+  child.once("exit", (code, signal) => {
+    if (webServerProcess !== child) {
+      return;
+    }
+    webServerProcess = null;
+    if (shuttingDown) {
+      return;
+    }
+    const now = Date.now();
+    while (webRespawnFailures.length > 0 && now - webRespawnFailures[0] > WEB_RESPAWN_FAILURE_WINDOW_MS) {
+      webRespawnFailures.shift();
     }
+    webRespawnFailures.push(now);
+    if (webRespawnFailures.length > WEB_RESPAWN_MAX_FAILURES) {
+      console.error(`[openscout-runtime] Scout web server has exited ${webRespawnFailures.length} times within ${WEB_RESPAWN_FAILURE_WINDOW_MS / 1000}s \u2014 pausing auto-respawn. Use 'scout server start' to retry.`);
+      webRespawnFailures.length = 0;
+      return;
+    }
+    const delay = Math.min(WEB_RESPAWN_BASE_DELAY_MS * webRespawnFailures.length, WEB_RESPAWN_MAX_DELAY_MS);
+    console.warn(`[openscout-runtime] Scout web server exited unexpectedly (code=${code}, signal=${signal}) \u2014 respawning in ${delay}ms (failure ${webRespawnFailures.length}/${WEB_RESPAWN_MAX_FAILURES})`);
+    setTimeout(() => {
+      if (shuttingDown)
+        return;
+      startWebServerIfNeeded(context).catch((error48) => {
+        console.error("[openscout-runtime] web server respawn failed:", error48);
+      });
+    }, delay).unref?.();
   });
   child.unref();
   return child;
 }
+var WEB_RESPAWN_BASE_DELAY_MS = 1000;
+var WEB_RESPAWN_MAX_DELAY_MS = 30000;
+var WEB_RESPAWN_MAX_FAILURES = 5;
+var WEB_RESPAWN_FAILURE_WINDOW_MS = 60000;
+var webRespawnFailures = [];
 async function webSupervisorStatus(error48 = null) {
   const running = await isWebServerHealthy();
   return {
@@ -43468,12 +45032,21 @@ async function recordInvocationDurably(invocation, options = {}) {
   });
 }
 async function recordFlightDurably(flight) {
+  let recordedFlight = null;
   await runDurableWrite(async () => {
+    const previous = runtime.snapshot().flights[flight.id];
+    if (previous && shouldIgnoreFlightUpdate(previous, flight)) {
+      console.warn(`[openscout-runtime] ignored stale flight update ${flight.id}: ${previous.state} -> ${flight.state}`);
+      return;
+    }
     const entries = await commitDurableEntries({ kind: "flight.record", flight }, async () => {
       await runtime.upsertFlight(flight);
     }, { enqueueProjection: false });
     await applyProjectedEntries(entries);
+    recordedFlight = flight;
   });
+  if (!recordedFlight)
+    return;
   const invocation = knownInvocations.get(flight.invocationId) ?? runtime.snapshot().invocations[flight.invocationId];
   await reconcileMessageDeliveriesForFlight(flight, invocation);
   if (invocation && isTerminalFlightState(flight.state)) {
@@ -43489,7 +45062,18 @@ async function recordFlightDurably(flight) {
     console.warn(`[openscout-runtime] failed to forward flight ${flight.id} to conversation authority:`, error48 instanceof Error ? error48.message : String(error48));
   }
 }
+function shouldIgnoreFlightUpdate(previous, next) {
+  return isTerminalFlightState(previous.state) && !isTerminalFlightState(next.state);
+}
 var terminalDeliveryStatuses = new Set(["completed", "failed", "cancelled"]);
+var staleReconcileableDeliveryStatuses = new Set([
+  "accepted",
+  "deferred",
+  "leased",
+  "pending",
+  "running",
+  "sent"
+]);
 function deliveryStatusForFlight(flight) {
   if (flight.state === "running" || flight.state === "waiting") {
     return "running";
@@ -43528,6 +45112,46 @@ async function reconcileMessageDeliveriesForFlight(flight, invocation) {
     });
   }
 }
+function staleLocalDeliveryReason(snapshot, delivery) {
+  if (delivery.targetKind !== "agent" || !staleReconcileableDeliveryStatuses.has(delivery.status)) {
+    return null;
+  }
+  const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === delivery.targetId);
+  if (endpoints.length === 0) {
+    return null;
+  }
+  if (endpoints.some((endpoint) => staleLocalEndpointReason(endpoint) === null)) {
+    return null;
+  }
+  const staleEndpoints = endpoints.filter((endpoint) => staleLocalEndpointReason(endpoint) !== null).sort((left, right) => endpointStartedAt(right) - endpointStartedAt(left));
+  const transportMatch = staleEndpoints.find((endpoint) => endpoint.transport === delivery.transport);
+  return staleLocalEndpointReason(transportMatch ?? staleEndpoints[0] ?? null);
+}
+async function reconcileStaleLocalDeliveries() {
+  const snapshot = runtime.snapshot();
+  const now = Date.now();
+  for (const delivery of journal.listDeliveries({ limit: 5000 })) {
+    const reason = staleLocalDeliveryReason(snapshot, delivery);
+    if (!reason) {
+      continue;
+    }
+    await updateDeliveryStatusDurably({
+      deliveryId: delivery.id,
+      status: "failed",
+      metadata: {
+        failureReason: "agent_offline",
+        failureDetail: `Stale local delivery reconciled: ${reason}`,
+        staleLocalRegistration: true,
+        reconciledStaleDelivery: true,
+        reconciledReason: reason,
+        reconciledAt: now
+      },
+      leaseOwner: null,
+      leaseExpiresAt: null
+    });
+    console.warn(`[openscout-runtime] reconciled stale local delivery ${delivery.id}: ${reason}`);
+  }
+}
 async function recordDeliveryDurably(delivery) {
   await runDurableWrite(async () => {
     await commitDurableEntries({ kind: "deliveries.record", deliveries: [delivery] }, async () => {});
@@ -43913,17 +45537,61 @@ function latestEndpointForAgent(snapshot, agentId) {
   const candidates = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === agentId);
   return [...candidates].sort((left, right) => Math.max(endpointTerminalAt(right), endpointStartedAt(right)) - Math.max(endpointTerminalAt(left), endpointStartedAt(left)))[0] ?? null;
 }
+function staleLocalEndpointReason(endpoint) {
+  if (!endpoint || endpoint.metadata?.staleLocalRegistration !== true) {
+    return null;
+  }
+  const replacementAgentId = endpoint.metadata.replacedByAgentId;
+  const replacement = typeof replacementAgentId === "string" && replacementAgentId.trim().length > 0 ? `; replacement agent is ${replacementAgentId.trim()}` : "";
+  return `endpoint ${endpoint.id} is a stale local registration superseded by current setup${replacement}`;
+}
+function flightDispatchEndpointId(flight) {
+  const dispatchAck = flight.metadata?.dispatchAck;
+  if (!dispatchAck || typeof dispatchAck !== "object" || Array.isArray(dispatchAck)) {
+    return null;
+  }
+  const endpointId = dispatchAck.endpointId;
+  return typeof endpointId === "string" && endpointId.trim().length > 0 ? endpointId.trim() : null;
+}
+function endpointForFlight(snapshot, flight) {
+  const dispatchedEndpointId = flightDispatchEndpointId(flight);
+  if (dispatchedEndpointId) {
+    const endpoint = snapshot.endpoints[dispatchedEndpointId];
+    if (endpoint?.agentId === flight.targetAgentId) {
+      return endpoint;
+    }
+    return null;
+  }
+  return latestEndpointForAgent(snapshot, flight.targetAgentId);
+}
+function flightDispatchEndpointUnavailableReason(snapshot, flight) {
+  const dispatchedEndpointId = flightDispatchEndpointId(flight);
+  if (!dispatchedEndpointId) {
+    return null;
+  }
+  const endpoint = snapshot.endpoints[dispatchedEndpointId];
+  if (!endpoint) {
+    return `dispatched endpoint ${dispatchedEndpointId} is no longer registered`;
+  }
+  if (endpoint.agentId !== flight.targetAgentId) {
+    return `dispatched endpoint ${dispatchedEndpointId} no longer belongs to target agent ${flight.targetAgentId}`;
+  }
+  return null;
+}
 function isReconciledStaleFlightActivityItem(item) {
   return item.kind === "flight_updated" && typeof item.summary === "string" && item.summary.startsWith("Stale running flight reconciled:");
 }
-function isStaleLocalAgent(agent) {
-  return agent?.metadata?.staleLocalRegistration === true || agent?.metadata?.retiredFromFleet === true;
+function isRetiredLocalAgent(agent) {
+  return agent?.metadata?.retiredFromFleet === true;
+}
+function isInactiveLocalAgent(agent) {
+  return isRetiredLocalAgent(agent) || agent?.metadata?.staleLocalRegistration === true;
 }
 function isStaleLocalEndpoint(snapshot, endpoint) {
   if (!endpoint || endpoint.metadata?.staleLocalRegistration === true) {
     return true;
   }
-  return isStaleLocalAgent(snapshot.agents[endpoint.agentId]);
+  return isInactiveLocalAgent(snapshot.agents[endpoint.agentId]);
 }
 function homeEndpointForAgent(snapshot, agentId) {
   const candidates = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === agentId && !isStaleLocalEndpoint(snapshot, endpoint));
@@ -43977,6 +45645,20 @@ function metadataStringValue2(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function scoutbotReplyProvenanceMetadata(invocation) {
+  if (invocation.targetAgentId !== "scoutbot") {
+    return {};
+  }
+  return {
+    source: metadataStringValue2(invocation.metadata, "source") ?? "scoutbot",
+    requestedBy: metadataStringValue2(invocation.metadata, "requestedBy") ?? invocation.requesterId,
+    sourceMessageId: metadataStringValue2(invocation.metadata, "sourceMessageId") ?? invocation.messageId ?? null,
+    parentScoutbotTurnId: metadataStringValue2(invocation.metadata, "parentScoutbotTurnId"),
+    generatedBy: metadataStringValue2(invocation.metadata, "generatedBy") ?? "scoutbot",
+    scoutbotThreadId: metadataStringValue2(invocation.metadata, "scoutbotThreadId"),
+    targetSessionId: metadataStringValue2(invocation.metadata, "targetSessionId")
+  };
+}
 function brokerTargetProjectRoot(agent, endpoint) {
   return endpoint?.projectRoot ?? endpoint?.cwd ?? metadataStringValue2(agent.metadata, "projectRoot");
 }
@@ -44185,7 +45867,7 @@ function buildBrokerReturnAddressForActor(snapshot, actorId, options = {}) {
     replyToMessageId: options.replyToMessageId,
     nodeId: endpoint?.nodeId || agent?.authorityNodeId || agent?.homeNodeId,
     projectRoot: endpoint?.projectRoot ?? endpoint?.cwd ?? metadataStringValue2(agent?.metadata, "projectRoot") ?? undefined,
-    sessionId: endpoint?.sessionId
+    sessionId: options.sessionId ?? endpoint?.sessionId
   });
 }
 function describeUnavailableDeliveryTarget(snapshot, agent) {
@@ -44203,20 +45885,8 @@ function describeUnavailableDeliveryTarget(snapshot, agent) {
       projectRoot
     };
   }
-  if (agent.metadata?.staleLocalRegistration === true) {
-    return {
-      agentId: agent.id,
-      displayName: agent.displayName ?? agent.id,
-      reason: "stale_registration",
-      detail: `${agent.displayName ?? agent.id} has a stale registration and needs operator follow-up before the broker can route to it again.`,
-      wakePolicy: agent.wakePolicy,
-      endpointState: endpoint?.state === "offline" ? "offline" : "unknown",
-      transport: endpoint?.transport ?? null,
-      projectRoot
-    };
-  }
   if (agent.authorityNodeId && agent.authorityNodeId !== nodeId) {
-    return null;
+    return describeRemoteAuthorityIssue(agent, snapshot.nodes[agent.authorityNodeId]);
   }
   if (agent.wakePolicy !== "manual") {
     return null;
@@ -44298,7 +45968,7 @@ function summarizeHomeAgent(endpoint) {
 }
 async function brokerHomePayload() {
   const snapshot = runtime.snapshot();
-  const agents = Object.values(snapshot.agents).filter((agent) => !isStaleLocalAgent(agent)).map((agent) => {
+  const agents = Object.values(snapshot.agents).filter((agent) => !isInactiveLocalAgent(agent)).map((agent) => {
     const endpoint = homeEndpointForAgent(snapshot, agent.id);
     const status = summarizeHomeAgent(endpoint);
     return {
@@ -44352,20 +46022,33 @@ function staleWorkingFlightReason(snapshot, flight) {
   if (!isWorkingFlightState(flight.state)) {
     return null;
   }
+  if (activeInvocationTasks.has(flight.invocationId)) {
+    return null;
+  }
   const startedAt = flightTimestamp(flight);
   const newerTerminalFlight = Object.values(snapshot.flights).filter((candidate) => candidate.targetAgentId === flight.targetAgentId && candidate.id !== flight.id && !isWorkingFlightState(candidate.state) && flightTimestamp(candidate) > startedAt).sort((left, right) => flightTimestamp(right) - flightTimestamp(left))[0] ?? null;
   if (newerTerminalFlight) {
     return `superseded by newer ${newerTerminalFlight.state} flight ${newerTerminalFlight.id}`;
   }
   const agent = snapshot.agents[flight.targetAgentId];
-  if (isStaleLocalAgent(agent)) {
-    const replacementAgentId = metadataStringValue2(agent?.metadata, "replacedByAgentId");
-    return replacementAgentId ? `target agent ${flight.targetAgentId} was marked stale and replaced by ${replacementAgentId}` : `target agent ${flight.targetAgentId} was marked stale`;
+  if (isRetiredLocalAgent(agent)) {
+    return `target agent ${flight.targetAgentId} was retired from the fleet`;
+  }
+  if (agent?.metadata?.staleLocalRegistration === true) {
+    return staleLocalEndpointReason(latestEndpointForAgent(snapshot, flight.targetAgentId)) ?? `target agent ${flight.targetAgentId} is a stale local registration superseded by current setup`;
   }
-  const endpoint = latestEndpointForAgent(snapshot, flight.targetAgentId);
+  const dispatchEndpointReason = flightDispatchEndpointUnavailableReason(snapshot, flight);
+  if (dispatchEndpointReason) {
+    return dispatchEndpointReason;
+  }
+  const endpoint = endpointForFlight(snapshot, flight);
   if (!endpoint) {
     return null;
   }
+  const staleEndpointReason = staleLocalEndpointReason(endpoint);
+  if (staleEndpointReason) {
+    return staleEndpointReason;
+  }
   const terminalAt = endpointTerminalAt(endpoint);
   if (endpoint.state !== "active" && terminalAt > startedAt) {
     return `endpoint ${endpoint.id} moved to ${endpoint.state} at ${terminalAt}`;
@@ -44457,7 +46140,7 @@ function uniqueManagedAgentSelector(snapshot, requestedSelector, currentAgentId)
   for (let counter = 2;counter <= 101; counter += 1) {
     const resolution = resolveAgentLabel(snapshot, candidate, {
       preferLocalNodeId: nodeId,
-      helpers: { isStale: isStaleLocalAgent }
+      helpers: { isStale: isInactiveLocalAgent }
     });
     if (resolution.kind === "unknown") {
       return candidate;
@@ -44610,7 +46293,7 @@ function resolveManagedSessionAttachTarget(snapshot, input) {
   const directAgentId = input.agentId?.trim();
   if (directAgentId) {
     const agent = snapshot.agents[directAgentId];
-    if (!agent || isStaleLocalAgent(agent)) {
+    if (!agent || isInactiveLocalAgent(agent)) {
       throw new Error(`unknown Scout agent ${directAgentId}`);
     }
     if (agent.authorityNodeId !== nodeId) {
@@ -44624,7 +46307,7 @@ function resolveManagedSessionAttachTarget(snapshot, input) {
   }
   const resolution = resolveAgentLabel(snapshot, selector, {
     preferLocalNodeId: nodeId,
-    helpers: { isStale: isStaleLocalAgent }
+    helpers: { isStale: isInactiveLocalAgent }
   });
   switch (resolution.kind) {
     case "resolved":
@@ -44663,6 +46346,41 @@ function staleLocalAgentReplacementId(definitionId, activeAgentIdsByDefinition)
   }
   return null;
 }
+function staleRegistrationMetadataMatches(metadata, replacementAgentId) {
+  if (metadata?.staleLocalRegistration !== true) {
+    return false;
+  }
+  if (!replacementAgentId) {
+    return true;
+  }
+  const existingReplacement = typeof metadata.replacedByAgentId === "string" ? metadata.replacedByAgentId.trim() : "";
+  return existingReplacement === replacementAgentId;
+}
+function staleLocalRegistrationMetadata(metadata, staleAt, replacementAgentId) {
+  const existingReplacement = typeof metadata?.replacedByAgentId === "string" ? metadata.replacedByAgentId.trim() : "";
+  const next = {
+    ...metadata ?? {},
+    staleLocalRegistration: true,
+    staleAt
+  };
+  if (replacementAgentId) {
+    next.replacedByAgentId = replacementAgentId;
+  } else if (existingReplacement) {
+    next.replacedByAgentId = existingReplacement;
+  } else {
+    delete next.replacedByAgentId;
+  }
+  return next;
+}
+function clearStaleLocalEndpointMetadata(metadata) {
+  const {
+    staleLocalRegistration,
+    staleAt,
+    replacedByAgentId,
+    ...rest
+  } = metadata ?? {};
+  return rest;
+}
 async function archiveStaleRegisteredLocalAgents(bindings) {
   const activeAgentIds = new Set(bindings.map((binding) => binding.agent.id));
   const activeAgentIdsByDefinition = bindings.reduce((map2, binding) => {
@@ -44685,48 +46403,36 @@ async function archiveStaleRegisteredLocalAgents(bindings) {
     if (agent?.authorityNodeId && agent.authorityNodeId !== nodeId) {
       continue;
     }
+    if (isLocalAgentEndpointAlive(endpoint)) {
+      if (endpoint.metadata?.staleLocalRegistration === true) {
+        await persistEndpoint({
+          ...endpoint,
+          metadata: clearStaleLocalEndpointMetadata(endpoint.metadata)
+        });
+      }
+      continue;
+    }
     const replacementAgentId = staleLocalAgentReplacementId(typeof agent?.definitionId === "string" ? agent.definitionId : null, activeAgentIdsByDefinition);
-    if (endpoint.state === "offline" && endpoint.metadata?.staleLocalRegistration === true && replacementAgentId && endpoint.metadata?.replacedByAgentId === replacementAgentId) {
+    if (agent && !staleRegistrationMetadataMatches(agent.metadata, replacementAgentId)) {
+      await upsertAgentDurably({
+        ...agent,
+        metadata: staleLocalRegistrationMetadata(agent.metadata, staleAt, replacementAgentId)
+      });
+    }
+    if (endpoint.state === "offline" && staleRegistrationMetadataMatches(endpoint.metadata, replacementAgentId)) {
       continue;
     }
     await persistEndpoint({
       ...endpoint,
       state: "offline",
       metadata: {
-        ...endpoint.metadata ?? {},
-        staleLocalRegistration: true,
-        staleAt,
-        replacedByAgentId: replacementAgentId ?? endpoint.metadata?.replacedByAgentId,
+        ...staleLocalRegistrationMetadata(endpoint.metadata, staleAt, replacementAgentId),
         lastError: "stale local agent registration superseded by current setup",
         lastFailedAt: staleAt
       }
     });
     console.log(`[openscout-runtime] archived stale local endpoint ${endpoint.id}`);
   }
-  for (const agent of Object.values(snapshot.agents)) {
-    if (activeAgentIds.has(agent.id) || !isGeneratedLocalAgentMetadata(agent.metadata)) {
-      continue;
-    }
-    if (agent.authorityNodeId && agent.authorityNodeId !== nodeId) {
-      continue;
-    }
-    const replacementAgentId = staleLocalAgentReplacementId(agent.definitionId, activeAgentIdsByDefinition);
-    const nextMetadata = {
-      ...agent.metadata ?? {},
-      staleLocalRegistration: true,
-      staleAt,
-      replacedByAgentId: replacementAgentId ?? agent.metadata?.replacedByAgentId
-    };
-    if (agent.metadata?.staleLocalRegistration === true && nextMetadata.replacedByAgentId === agent.metadata?.replacedByAgentId) {
-      continue;
-    }
-    const nextAgent = {
-      ...agent,
-      metadata: nextMetadata
-    };
-    await upsertAgentDurably(nextAgent);
-    console.log(`[openscout-runtime] archived stale local agent ${agent.id}`);
-  }
 }
 async function syncRegisteredLocalAgents() {
   const bindings = await loadRegisteredLocalAgentBindings(nodeId);
@@ -44741,6 +46447,7 @@ async function syncRegisteredLocalAgents() {
   }
   await archiveStaleRegisteredLocalAgents(bindings);
   await reconcileStaleWorkingFlights();
+  await reconcileStaleLocalDeliveries();
   const snapshot = runtime.snapshot();
   for (const endpoint of Object.values(snapshot.endpoints)) {
     if (endpoint.transport === "tmux") {
@@ -45115,6 +46822,49 @@ function hasReachableMeshEntrypoint(node) {
 function isReachableMeshNode(node) {
   return Boolean(node?.brokerUrl || hasReachableMeshEntrypoint(node));
 }
+function meshNodeLastSeenAt(node) {
+  return typeof node?.lastSeenAt === "number" && Number.isFinite(node.lastSeenAt) ? node.lastSeenAt : typeof node?.registeredAt === "number" && Number.isFinite(node.registeredAt) ? node.registeredAt : 0;
+}
+function isStaleMeshAuthorityNode(node) {
+  if (!node) {
+    return false;
+  }
+  const lastSeenAt = meshNodeLastSeenAt(node);
+  return lastSeenAt > 0 && Date.now() - lastSeenAt > STALE_MESH_AUTHORITY_NODE_MS;
+}
+function formatMeshNodeLastSeen(node) {
+  const lastSeenAt = meshNodeLastSeenAt(node);
+  if (!lastSeenAt) {
+    return "with no recent heartbeat";
+  }
+  return `last seen ${new Date(lastSeenAt).toISOString()}`;
+}
+function describeRemoteAuthorityIssue(agent, authorityNode) {
+  const displayName = agent.displayName ?? agent.id;
+  const authorityNodeId = agent.authorityNodeId;
+  if (!authorityNodeId || authorityNodeId === nodeId) {
+    return null;
+  }
+  const nodeLabel = authorityNode?.name ? `${authorityNode.name} (${authorityNodeId})` : authorityNodeId;
+  const unavailable = !authorityNode || !isReachableMeshNode(authorityNode);
+  const stale = isStaleMeshAuthorityNode(authorityNode);
+  if (!unavailable && !stale) {
+    return null;
+  }
+  const endpoint = homeEndpointForAgent(runtime.snapshot(), agent.id);
+  const projectRoot = brokerTargetProjectRoot(agent, endpoint);
+  const detail = unavailable ? `${displayName} belongs to peer node ${nodeLabel}, but that peer has no reachable broker URL or mesh entrypoint.` : `${displayName} belongs to peer node ${nodeLabel}, but that peer is stale (${formatMeshNodeLastSeen(authorityNode)}).`;
+  return {
+    agentId: agent.id,
+    displayName,
+    reason: "unknown",
+    detail,
+    wakePolicy: agent.wakePolicy,
+    endpointState: endpoint?.state === "active" || endpoint?.state === "idle" || endpoint?.state === "waiting" ? "online" : endpoint?.state === "offline" ? "offline" : "unknown",
+    transport: endpoint?.transport ?? null,
+    projectRoot
+  };
+}
 function authorityNodeForConversation(conversationId) {
   const conversation = runtime.conversation(conversationId);
   if (!conversation || conversation.authorityNodeId === nodeId) {
@@ -45189,6 +46939,30 @@ async function maybeForwardFlightToAuthority(flight) {
   }
   await brokerPostJson(authority.authorityNode.brokerUrl, "/v1/flights", flight);
 }
+async function retireConsumedOneTimeCardsForMessage(message) {
+  if (message.class !== "agent" || message.actorId === systemActor.id) {
+    return;
+  }
+  const conversation = runtime.conversation(message.conversationId);
+  if (!conversation || conversation.kind !== "direct") {
+    return;
+  }
+  const retired = await retireConsumedOneTimeLocalAgentCards({
+    conversationId: conversation.id,
+    actorId: message.actorId,
+    participantIds: conversation.participantIds
+  }).catch((error48) => {
+    console.warn(`[openscout-runtime] one-time card cleanup failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    return [];
+  });
+  if (retired.length === 0) {
+    return;
+  }
+  console.log(`[openscout-runtime] retired ${retired.length} consumed one-time card${retired.length === 1 ? "" : "s"}`);
+  await syncRegisteredLocalAgentsIfChanged("one-time card consumed").catch((error48) => {
+    console.warn(`[openscout-runtime] one-time card broker sync failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+  });
+}
 async function postConversationMessage(message) {
   const authority = authorityNodeForConversation(message.conversationId);
   if (authority) {
@@ -45205,6 +46979,9 @@ async function postConversationMessage(message) {
   });
   await forwardPeerBrokerDeliveries(message, deliveries2);
   await applyProjectedEntries(entries);
+  await reconcileStaleLocalDeliveries();
+  await retireConsumedOneTimeCardsForMessage(message);
+  await completeInvocationsForBrokerReply(message);
   return { ok: true, message, deliveries: deliveries2 };
 }
 async function postInvocationStatusMessage(invocation, flight) {
@@ -45250,10 +47027,69 @@ function existingBrokerReplyForInvocation(invocation, agentId, sinceMs) {
   const replies = Object.values(runtime.peek().messages).filter((message) => message.conversationId === invocation.conversationId && message.replyToMessageId === invocation.messageId && message.actorId === agentId && message.class === "agent" && message.createdAt >= since).sort((lhs, rhs) => rhs.createdAt - lhs.createdAt);
   return replies[0] ?? null;
 }
-function activeLocalEndpointForAgent(agentId, harness) {
+function messageAnswersInvocation(message, invocation) {
+  if (invocation.action === "wake") {
+    return false;
+  }
+  if (!invocation.conversationId || !invocation.messageId) {
+    return false;
+  }
+  return message.class === "agent" && message.actorId === invocation.targetAgentId && message.conversationId === invocation.conversationId && message.replyToMessageId === invocation.messageId && message.body.trim().length > 0;
+}
+function completedFlightFromBrokerReply(invocation, flight, reply) {
+  const agent = runtime.agent(invocation.targetAgentId);
+  const replySource = metadataStringValue2(reply.metadata, "source");
+  return {
+    ...flight,
+    state: "completed",
+    summary: `${agent?.displayName ?? invocation.targetAgentId} replied.`,
+    output: reply.body,
+    error: undefined,
+    completedAt: reply.createdAt,
+    metadata: {
+      ...flight.metadata ?? {},
+      completedByBrokerReply: true,
+      replyMessageId: reply.id,
+      ...replySource ? { replySource } : {}
+    }
+  };
+}
+async function completeInvocationForBrokerReply(invocation, reply) {
+  const flight = runtime.flightForInvocation(invocation.id);
+  if (!flight || !isWorkingFlightState(flight.state)) {
+    return false;
+  }
+  const startedAt = flight.startedAt ?? invocation.createdAt;
+  if (reply.createdAt < Math.max(0, startedAt - 5000)) {
+    return false;
+  }
+  await persistFlight(completedFlightFromBrokerReply(invocation, flight, reply));
+  return true;
+}
+async function completeInvocationsForBrokerReply(message) {
+  if (message.class !== "agent" || !message.replyToMessageId || !message.body.trim()) {
+    return;
+  }
+  const invocations2 = Object.values(runtime.snapshot().invocations).filter((invocation) => messageAnswersInvocation(message, invocation));
+  for (const invocation of invocations2) {
+    await completeInvocationForBrokerReply(invocation, message);
+  }
+}
+function endpointMatchesTargetSession(endpoint, sessionId) {
+  return endpoint.sessionId?.trim() === sessionId || endpoint.id === sessionId;
+}
+function invocationTargetSessionId(invocation) {
+  return invocation.execution?.targetSessionId?.trim() || metadataStringValue2(invocation.metadata, "targetSessionId") || undefined;
+}
+function activeLocalEndpointForAgent(agentId, harness, targetSessionId) {
   const candidates = runtime.endpointsForAgent(agentId, {
     nodeId,
     harness
+  }).filter((endpoint) => {
+    if (endpoint.metadata?.staleLocalRegistration === true) {
+      return false;
+    }
+    return targetSessionId ? endpointMatchesTargetSession(endpoint, targetSessionId) : true;
   });
   return candidates.find((endpoint) => endpoint.transport === "pairing_bridge" ? endpoint.state !== "offline" : isLocalAgentEndpointAlive(endpoint));
 }
@@ -45284,17 +47120,64 @@ function onlineConversationNotifyTargets(conversation, requesterId) {
     return Boolean(activeLocalEndpointForAgent(participantId));
   });
 }
+async function reviveManagedLocalSessionEndpoint(endpoint) {
+  if (!isManagedLocalSessionMetadata(endpoint.metadata)) {
+    return null;
+  }
+  const sessionResult = await ensureLocalSessionEndpointOnline(endpoint);
+  const externalSessionId = sessionResult.externalSessionId?.trim();
+  const { lastError: _lastError, lastFailedAt: _lastFailedAt, ...baseMetadata } = endpoint.metadata ?? {};
+  const revivedEndpoint = {
+    ...endpoint,
+    state: "idle",
+    ...externalSessionId ? { sessionId: externalSessionId } : {},
+    metadata: {
+      ...baseMetadata,
+      lastResumedAt: Date.now(),
+      ...externalSessionId ? {
+        externalSessionId,
+        ...endpoint.transport === "codex_app_server" ? { threadId: externalSessionId } : {}
+      } : {}
+    }
+  };
+  await persistEndpoint(revivedEndpoint);
+  return revivedEndpoint;
+}
 async function resolveLocalEndpointForInvocation(invocation) {
   const requestedHarness = invocation.execution?.harness;
+  const targetSessionId = invocationTargetSessionId(invocation);
   const sessionPreference = invocation.execution?.session ?? "new";
-  const existing = activeLocalEndpointForAgent(invocation.targetAgentId, requestedHarness);
+  const existing = activeLocalEndpointForAgent(invocation.targetAgentId, requestedHarness, targetSessionId);
   if (existing && (sessionPreference !== "new" || existing.transport === "pairing_bridge")) {
     return existing;
   }
   const staleEndpoints = runtime.endpointsForAgent(invocation.targetAgentId, {
     nodeId,
     harness: requestedHarness
-  }).filter((endpoint) => endpoint.id !== existing?.id);
+  }).filter((endpoint) => endpoint.id !== existing?.id && (targetSessionId ? endpointMatchesTargetSession(endpoint, targetSessionId) : true));
+  const staleLocalReason = staleEndpoints.map((endpoint) => staleLocalEndpointReason(endpoint)).find((reason) => Boolean(reason));
+  if (staleLocalReason) {
+    throw new Error(staleLocalReason);
+  }
+  if (invocation.ensureAwake) {
+    for (const endpoint of staleEndpoints) {
+      try {
+        const revived = await reviveManagedLocalSessionEndpoint(endpoint);
+        if (revived)
+          return revived;
+      } catch (error48) {
+        await persistEndpoint({
+          ...endpoint,
+          state: "offline",
+          metadata: {
+            ...endpoint.metadata ?? {},
+            lastError: error48 instanceof Error ? error48.message : String(error48),
+            lastFailedAt: Date.now()
+          }
+        });
+      }
+    }
+  }
   for (const endpoint of staleEndpoints) {
     await persistEndpoint({
       ...endpoint,
@@ -45312,34 +47195,8 @@ async function resolveLocalEndpointForInvocation(invocation) {
   if (sessionPreference === "existing") {
     return;
   }
-  for (const endpoint of staleEndpoints) {
-    if (!isManagedLocalSessionMetadata(endpoint.metadata)) {
-      continue;
-    }
-    try {
-      const sessionResult = await ensureLocalSessionEndpointOnline(endpoint);
-      const revivedEndpoint = {
-        ...endpoint,
-        state: "idle",
-        metadata: {
-          ...endpoint.metadata ?? {},
-          lastResumedAt: Date.now(),
-          ...sessionResult.externalSessionId ? { externalSessionId: sessionResult.externalSessionId } : {}
-        }
-      };
-      await persistEndpoint(revivedEndpoint);
-      return revivedEndpoint;
-    } catch (error48) {
-      await persistEndpoint({
-        ...endpoint,
-        state: "offline",
-        metadata: {
-          ...endpoint.metadata ?? {},
-          lastError: error48 instanceof Error ? error48.message : String(error48),
-          lastFailedAt: Date.now()
-        }
-      });
-    }
+  if (targetSessionId) {
+    return;
   }
   const binding = await ensureLocalAgentBindingOnline(invocation.targetAgentId, nodeId, {
     includeDiscovered: true,
@@ -45358,7 +47215,7 @@ async function resolveLocalEndpointForInvocation(invocation) {
 async function executeLocalInvocation(invocation, initialFlight) {
   const agent = runtime.agent(invocation.targetAgentId);
   let endpoint;
-  const previousEndpoint = activeLocalEndpointForAgent(invocation.targetAgentId, invocation.execution?.harness);
+  const previousEndpoint = activeLocalEndpointForAgent(invocation.targetAgentId, invocation.execution?.harness, invocationTargetSessionId(invocation));
   try {
     endpoint = await resolveLocalEndpointForInvocation(invocation);
   } catch (error48) {
@@ -45379,6 +47236,24 @@ async function executeLocalInvocation(invocation, initialFlight) {
     return;
   }
   if (!agent || !endpoint) {
+    const staleEndpointReason = staleLocalEndpointReason(latestEndpointForAgent(runtime.snapshot(), invocation.targetAgentId));
+    if (staleEndpointReason) {
+      const failedFlight = {
+        ...initialFlight,
+        state: "failed",
+        summary: `${agent?.displayName ?? invocation.targetAgentId} could not be prepared.`,
+        error: `Endpoint resolution failed before execution: ${staleEndpointReason}`,
+        completedAt: Date.now(),
+        metadata: {
+          ...initialFlight.metadata ?? {},
+          failureStage: "endpoint_resolution",
+          staleLocalRegistration: true
+        }
+      };
+      await persistFlight(failedFlight);
+      await postInvocationStatusMessage(invocation, failedFlight);
+      return;
+    }
     const queuedFlight = {
       ...initialFlight,
       state: "queued",
@@ -45436,6 +47311,20 @@ async function executeLocalInvocation(invocation, initialFlight) {
   await persistFlight(runningFlight);
   try {
     const result = endpoint.transport === "pairing_bridge" ? await invokePairingSessionEndpoint(runningEndpoint, invocation) : await invokeLocalAgentEndpoint(runningEndpoint, invocation);
+    const rawResultExternalSessionId = "externalSessionId" in result ? result.externalSessionId : undefined;
+    const resultExternalSessionId = typeof rawResultExternalSessionId === "string" && rawResultExternalSessionId.trim() ? rawResultExternalSessionId.trim() : undefined;
+    const completedEndpoint = {
+      ...runningEndpoint,
+      ...resultExternalSessionId ? { sessionId: resultExternalSessionId } : {},
+      metadata: {
+        ...runningEndpoint.metadata ?? {},
+        lastCompletedAt: Date.now(),
+        ...resultExternalSessionId ? {
+          externalSessionId: resultExternalSessionId,
+          ...runningEndpoint.transport === "codex_app_server" ? { threadId: resultExternalSessionId } : {}
+        } : {}
+      }
+    };
     if (invocation.action === "wake") {
       const completedFlight2 = {
         ...runningFlight,
@@ -45446,12 +47335,16 @@ async function executeLocalInvocation(invocation, initialFlight) {
       };
       await persistFlight(completedFlight2);
       await persistEndpoint({
-        ...runningEndpoint,
-        state: "idle",
-        metadata: {
-          ...runningEndpoint.metadata ?? {},
-          lastCompletedAt: Date.now()
-        }
+        ...completedEndpoint,
+        state: "idle"
+      });
+      return;
+    }
+    const currentFlight = runtime.flightForInvocation(invocation.id);
+    if (currentFlight && isTerminalFlightState(currentFlight.state)) {
+      await persistEndpoint({
+        ...completedEndpoint,
+        state: "idle"
       });
       return;
     }
@@ -45491,12 +47384,8 @@ async function executeLocalInvocation(invocation, initialFlight) {
     };
     await persistFlight(completedFlight);
     await persistEndpoint({
-      ...runningEndpoint,
-      state: "idle",
-      metadata: {
-        ...runningEndpoint.metadata ?? {},
-        lastCompletedAt: Date.now()
-      }
+      ...completedEndpoint,
+      state: "idle"
     });
     if (invocation.conversationId && !postedReply) {
       const conversation = runtime.conversation(invocation.conversationId);
@@ -45519,6 +47408,7 @@ async function executeLocalInvocation(invocation, initialFlight) {
             invocationId: invocation.id,
             flightId: completedFlight.id,
             source: "broker",
+            ...scoutbotReplyProvenanceMetadata(invocation),
             returnAddress: buildScoutReturnAddress({
               actorId: agent.id,
               handle: agent.handle?.trim() || agent.definitionId,
@@ -45527,19 +47417,19 @@ async function executeLocalInvocation(invocation, initialFlight) {
               defaultSelector: agent.defaultSelector,
               conversationId: invocation.conversationId,
               replyToMessageId: invocation.messageId,
-              nodeId: runningEndpoint.nodeId,
-              projectRoot: runningEndpoint.projectRoot ?? runningEndpoint.cwd,
-              sessionId: runningEndpoint.sessionId
+              nodeId: completedEndpoint.nodeId,
+              projectRoot: completedEndpoint.projectRoot ?? completedEndpoint.cwd,
+              sessionId: completedEndpoint.sessionId
             }),
             requestedReturnAddress: invocation.metadata?.["returnAddress"],
-            responderHarness: runningEndpoint.harness,
-            responderTransport: runningEndpoint.transport,
-            responderSessionId: runningEndpoint.sessionId ?? "",
-            responderCwd: runningEndpoint.cwd ?? "",
-            responderProjectRoot: runningEndpoint.projectRoot ?? "",
-            responderAgentName: String(runningEndpoint.metadata?.agentName ?? agent.id),
-            responderStartedAt: String(runningEndpoint.metadata?.startedAt ?? ""),
-            responderNodeId: runningEndpoint.nodeId
+            responderHarness: completedEndpoint.harness,
+            responderTransport: completedEndpoint.transport,
+            responderSessionId: completedEndpoint.sessionId ?? "",
+            responderCwd: completedEndpoint.cwd ?? "",
+            responderProjectRoot: completedEndpoint.projectRoot ?? "",
+            responderAgentName: String(completedEndpoint.metadata?.agentName ?? agent.id),
+            responderStartedAt: String(completedEndpoint.metadata?.startedAt ?? ""),
+            responderNodeId: completedEndpoint.nodeId
           }
         });
       }
@@ -45547,10 +47437,18 @@ async function executeLocalInvocation(invocation, initialFlight) {
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     if (isRequesterWaitTimeoutError(error48)) {
+      const currentFlight = runtime.flightForInvocation(invocation.id);
+      if (currentFlight && isTerminalFlightState(currentFlight.state)) {
+        return;
+      }
+      const postedReply = existingBrokerReplyForInvocation(invocation, agent.id, runningFlight.startedAt ?? Date.now());
+      if (postedReply && await completeInvocationForBrokerReply(invocation, postedReply)) {
+        return;
+      }
       const waitingFlight = {
         ...runningFlight,
         state: "waiting",
-        summary: `${agent.displayName} is still working; the requester stopped waiting after ${error48.timeoutMs}ms.`,
+        summary: `${agent.displayName} is still working; Scout stopped waiting for a synchronous result after ${error48.timeoutMs}ms.`,
         error: undefined,
         completedAt: undefined,
         metadata: {
@@ -45561,7 +47459,71 @@ async function executeLocalInvocation(invocation, initialFlight) {
         }
       };
       await persistFlight(waitingFlight);
-      await postInvocationStatusMessage(invocation, waitingFlight);
+      console.warn(`[openscout-runtime] ${waitingFlight.summary}`);
+      return;
+    }
+    if (isDispatchStalledError(error48)) {
+      const stalledFlight = {
+        ...runningFlight,
+        state: "failed",
+        summary: `${agent.displayName} dispatch stalled \u2014 prompt left in composer after submit + retry.`,
+        error: message,
+        completedAt: Date.now(),
+        metadata: {
+          ...runningFlight.metadata ?? {},
+          failureStage: "dispatch_stalled",
+          dispatchStalledSession: error48.sessionName,
+          dispatchStalledRetries: error48.retries,
+          dispatchStalledPaneTail: error48.paneTail.slice(0, 1000)
+        }
+      };
+      await persistFlight(stalledFlight);
+      await persistEndpoint({
+        ...runningEndpoint,
+        state: "offline",
+        metadata: {
+          ...runningEndpoint.metadata ?? {},
+          lastError: message,
+          lastFailedAt: Date.now(),
+          lastFailureStage: "dispatch_stalled"
+        }
+      });
+      await postInvocationStatusMessage(invocation, stalledFlight);
+      return;
+    }
+    if (isCodexAppServerExitError(error48) && error48.noteworthy) {
+      const interruptedAt = Date.now();
+      const failureStage = error48.exitKind === "proactive_shutdown" ? "codex_app_server_proactive_shutdown" : "codex_app_server_sigterm";
+      const summary = error48.exitKind === "proactive_shutdown" ? `${agent.displayName} was stopped by OpenScout before it could reply.` : `${agent.displayName} was interrupted by a local Codex app-server SIGTERM.`;
+      const interruptedFlight = {
+        ...runningFlight,
+        state: "failed",
+        summary,
+        error: undefined,
+        completedAt: interruptedAt,
+        metadata: {
+          ...runningFlight.metadata ?? {},
+          failureStage,
+          failureSeverity: "noteworthy",
+          noteworthy: true,
+          exitKind: error48.exitKind,
+          exitSignal: error48.signal,
+          exitCode: error48.exitCode,
+          ...error48.reason ? { shutdownReason: error48.reason } : {}
+        }
+      };
+      await persistFlight(interruptedFlight);
+      await persistEndpoint({
+        ...runningEndpoint,
+        state: "offline",
+        metadata: {
+          ...runningEndpoint.metadata ?? {},
+          lastNotice: message,
+          lastInterruptedAt: interruptedAt,
+          lastInterruptionStage: failureStage
+        }
+      });
+      await postInvocationStatusMessage(invocation, interruptedFlight);
       return;
     }
     const failedFlight = {
@@ -45861,6 +47823,7 @@ async function handleCommand(command) {
       });
       const mesh2 = await forwardPeerBrokerDeliveries(command.message, deliveries2);
       await applyProjectedEntries(entries);
+      await reconcileStaleLocalDeliveries();
       console.log(`[openscout-runtime] message ${command.message.id} posted by ${command.message.actorId} to ${command.message.conversationId} with ${deliveries2.length} deliveries`);
       return { ok: true, message: command.message, deliveries: deliveries2, mesh: mesh2 };
     }
@@ -45893,7 +47856,7 @@ async function handleCommand(command) {
 }
 async function handleInvocationRequest(payload) {
   await syncRegisteredLocalAgentsIfChanged("invocation");
-  const resolved = resolveInvocationTarget(payload);
+  const resolved = await resolveInvocationTarget(payload);
   if (resolved.kind !== "resolved") {
     const envelope = buildDispatchEnvelope(resolved, askedLabelForRouteTarget(payload), nodeId, runtime.snapshot(), { homeEndpointFor: homeEndpointForAgent });
     const { record: record2 } = await recordScoutDispatchDurably(envelope, {
@@ -45944,8 +47907,9 @@ async function dispatchAcceptedInvocation(invocation) {
   }
   if (targetAgent.authorityNodeId && targetAgent.authorityNodeId !== nodeId) {
     const authorityNode = runtime.node(targetAgent.authorityNodeId);
-    if (!authorityNode) {
-      await failAcceptedInvocation(invocation, `authority node ${targetAgent.authorityNodeId} is not reachable`);
+    const authorityIssue = describeRemoteAuthorityIssue(targetAgent, authorityNode);
+    if (authorityIssue) {
+      await failAcceptedInvocation(invocation, authorityIssue.detail);
       return;
     }
     await peerDelivery.enqueue(invocation, authorityNode);
@@ -46361,6 +48325,17 @@ async function routeRequest(request, response) {
     json2(response, 200, journal.listDeliveryAttempts(deliveryId));
     return;
   }
+  const invocationLifecycleMatch = method === "GET" ? url2.pathname.match(/^\/v1\/invocations\/([^/]+)\/lifecycle$/) : null;
+  if (invocationLifecycleMatch) {
+    const invocationId = decodeURIComponent(invocationLifecycleMatch[1] ?? "");
+    const lifecycle2 = await brokerService.readInvocationLifecycle?.({ invocationId });
+    if (!lifecycle2) {
+      notFound(response);
+      return;
+    }
+    json2(response, 200, lifecycle2);
+    return;
+  }
   if (method === "GET" && url2.pathname === "/v1/mesh/nodes") {
     json2(response, 200, runtime.snapshot().nodes);
     return;
@@ -46713,6 +48688,39 @@ data: ${JSON.stringify({ nodeId, meshId })}
     }
     return;
   }
+  if (method === "POST" && url2.pathname === "/v1/local-sessions/ensure") {
+    try {
+      const input = await readRequestBody(request);
+      const snapshot = runtime.snapshot();
+      const endpoint = input.endpointId?.trim() ? snapshot.endpoints[input.endpointId.trim()] : Object.values(snapshot.endpoints).find((candidate) => candidate.agentId === input.agentId?.trim() && candidate.nodeId === nodeId && (candidate.transport === "codex_app_server" || candidate.transport === "claude_stream_json") && candidate.state !== "offline");
+      if (!endpoint) {
+        throw new Error("local session endpoint not found");
+      }
+      if (endpoint.transport !== "codex_app_server" && endpoint.transport !== "claude_stream_json") {
+        throw new Error(`endpoint ${endpoint.id} does not use a local session transport`);
+      }
+      const sessionResult = await ensureLocalSessionEndpointOnline(endpoint);
+      const externalSessionId = sessionResult.externalSessionId?.trim();
+      const nextEndpoint = {
+        ...endpoint,
+        state: endpoint.state === "offline" ? "waiting" : endpoint.state,
+        ...externalSessionId ? { sessionId: externalSessionId } : {},
+        metadata: {
+          ...endpoint.metadata ?? {},
+          ...externalSessionId ? {
+            externalSessionId,
+            threadId: endpoint.transport === "codex_app_server" ? externalSessionId : endpoint.metadata?.threadId
+          } : {},
+          lastEnsuredAt: Date.now()
+        }
+      };
+      await persistEndpoint(nextEndpoint);
+      json2(response, 200, { ok: true, endpoint: nextEndpoint, externalSessionId: externalSessionId ?? null });
+    } catch (error48) {
+      badRequest(response, error48);
+    }
+    return;
+  }
   if (method === "POST" && url2.pathname === "/v1/local-sessions/detach") {
     try {
       const input = await readRequestBody(request);
@@ -47042,18 +49050,99 @@ function callerContextForDelivery(payload) {
     requesterNodeId: payload.caller?.nodeId?.trim() || payload.requesterNodeId?.trim() || nodeId
   };
 }
+function agentLabelForRouteParams(payload) {
+  if (payload.target?.kind === "agent_label") {
+    return payload.target.label;
+  }
+  if (!payload.target && payload.targetLabel?.trim()) {
+    return payload.targetLabel;
+  }
+  return;
+}
+function supportedRouteHarness(value) {
+  const normalized = value?.trim();
+  if (normalized && SUPPORTED_SCOUT_HARNESSES.includes(normalized)) {
+    return normalized;
+  }
+  return;
+}
+function executionWithRouteParams(payload) {
+  const label = agentLabelForRouteParams(payload);
+  const identity2 = label ? parseAgentIdentity(label.startsWith("@") ? label : `@${label}`) : null;
+  const harness = supportedRouteHarness(identity2?.harness);
+  if (!harness || payload.execution?.harness) {
+    return payload.execution;
+  }
+  return {
+    ...payload.execution ?? {},
+    harness
+  };
+}
 function resolveBrokerDeliveryTarget(input) {
   return resolveBrokerRouteTarget(runtime.snapshot(), input, {
     preferLocalNodeId: nodeId,
-    helpers: { isStale: isStaleLocalAgent }
+    helpers: { isStale: isInactiveLocalAgent }
   });
 }
-function resolveInvocationTarget(payload) {
-  return resolveBrokerDeliveryTarget({
+function projectPathRouteTarget(input) {
+  return input.target?.kind === "project_path" ? input.target.projectPath.trim() || undefined : undefined;
+}
+function implicitProjectAgentName(projectPath) {
+  const base = normalizeAgentSelectorSegment(basename11(projectPath)) || "agent";
+  return `${base}-card-${createRuntimeId2("one").slice(-8)}`;
+}
+async function resolveBrokerDeliveryTargetWithImplicitProjectCard(input, options) {
+  const resolved = resolveBrokerDeliveryTarget(input);
+  const projectPath = projectPathRouteTarget(input);
+  const shouldCreateImplicitProjectCard = projectPath && (resolved.kind === "unknown" || resolved.kind === "ambiguous" && (input.execution?.session ?? "new") === "new");
+  if (!shouldCreateImplicitProjectCard) {
+    return resolved;
+  }
+  const createdAt = Date.now();
+  const requesterId = options.requesterId?.trim();
+  const status = await startLocalAgent({
+    projectPath,
+    agentName: implicitProjectAgentName(projectPath),
+    currentDirectory: options.currentDirectory ?? projectPath,
+    harness: input.execution?.harness,
+    ensureOnline: false,
+    card: {
+      kind: "one_time",
+      createdAt,
+      ...requesterId ? { createdById: requesterId } : {},
+      expiresAt: createdAt + DEFAULT_IMPLICIT_PROJECT_CARD_TTL_MS,
+      maxUses: 1
+    }
+  }).catch((error48) => {
+    const detail = error48 instanceof Error ? error48.message : String(error48);
+    throw new Error(`could not create an agent card for project ${projectPath}: ${detail}`);
+  });
+  await pruneOneTimeLocalAgentCards({
+    ...requesterId ? { createdById: requesterId } : {},
+    projectRoot: status.projectRoot,
+    excludeAgentIds: [status.agentId]
+  }).catch((error48) => {
+    console.warn(`[openscout-runtime] implicit project card cleanup failed: ${error48 instanceof Error ? error48.message : String(error48)}`);
+  });
+  await syncRegisteredLocalAgentsIfChanged(options.reason);
+  const agent = runtime.snapshot().agents[status.agentId];
+  if (agent && !isInactiveLocalAgent(agent)) {
+    return { kind: "resolved", agent };
+  }
+  return resolveBrokerDeliveryTarget(input);
+}
+async function resolveInvocationTarget(payload) {
+  return resolveBrokerDeliveryTargetWithImplicitProjectCard({
     target: payload.target,
     targetAgentId: payload.targetAgentId,
+    targetSessionId: payload.targetSessionId,
     targetLabel: payload.targetLabel,
-    routePolicy: payload.routePolicy
+    routePolicy: payload.routePolicy,
+    execution: payload.execution
+  }, {
+    requesterId: payload.requesterId,
+    currentDirectory: projectPathRouteTarget(payload),
+    reason: "implicit project invocation card"
   });
 }
 function remediationForDispatch(dispatch) {
@@ -47088,6 +49177,7 @@ function buildDeliveryReceipt(input) {
     requesterId: input.requesterId,
     requesterNodeId: input.requesterNodeId,
     targetAgentId: input.targetAgentId,
+    targetSessionId: input.targetSessionId,
     targetLabel: input.targetLabel,
     ...input.bindingRef ? { bindingRef: input.bindingRef } : {},
     conversationId: input.conversationId,
@@ -47402,10 +49492,13 @@ async function acceptBrokerDelivery(payload) {
   const createdAt = typeof payload.createdAt === "number" && Number.isFinite(payload.createdAt) ? payload.createdAt : Date.now();
   const { requesterId, requesterNodeId } = callerContextForDelivery(payload);
   const askedLabel = askedLabelForRouteTarget(payload);
+  const execution = executionWithRouteParams(payload);
   const deliveryChannel = routeChannelForTarget(payload) ?? payload.channel?.trim();
+  const targetSessionId = payload.target?.kind === "session_id" ? payload.target.sessionId.trim() : payload.targetSessionId?.trim() || metadataStringValue2(payload.invocationMetadata, "targetSessionId") || metadataStringValue2(payload.messageMetadata, "targetSessionId") || undefined;
+  const replyToSessionId = payload.replyToSessionId?.trim() || metadataStringValue2(payload.invocationMetadata, "replyToSessionId") || metadataStringValue2(payload.messageMetadata, "replyToSessionId") || undefined;
   const labels = normalizeScoutLabels(payload.labels);
   const typedChannelTarget = payload.target?.kind === "channel" || payload.target?.kind === "broadcast";
-  const hasAgentTarget = Boolean(payload.target?.kind === "agent_id" || payload.target?.kind === "agent_label" || payload.target?.kind === "project_path") || !payload.target && Boolean(payload.targetAgentId?.trim() || payload.targetLabel?.trim());
+  const hasAgentTarget = Boolean(payload.target?.kind === "agent_id" || payload.target?.kind === "agent_label" || payload.target?.kind === "session_id" || payload.target?.kind === "project_path") || !payload.target && Boolean(payload.targetSessionId?.trim() || payload.targetAgentId?.trim() || payload.targetLabel?.trim());
   const messageRef = messageRefCandidateForRouteTarget(payload);
   const replyTarget = messageRef ? resolveBrokerMessageRef(runtime.snapshot(), messageRef) : null;
   if (replyTarget) {
@@ -47442,7 +49535,8 @@ async function acceptBrokerDelivery(payload) {
           relayTargetIds: notifyTargets,
           returnAddress: buildBrokerReturnAddressForActor(snapshot2, requesterId, {
             conversationId: conversation2.id,
-            replyToMessageId: messageId2
+            replyToMessageId: messageId2,
+            sessionId: replyToSessionId
           })
         }
       };
@@ -47503,7 +49597,8 @@ async function acceptBrokerDelivery(payload) {
         relayMessageId: messageId2,
         returnAddress: buildBrokerReturnAddressForActor(snapshot2, requesterId, {
           conversationId: conversation2.id,
-          replyToMessageId: messageId2
+          replyToMessageId: messageId2,
+          sessionId: replyToSessionId
         })
       }
     };
@@ -47564,7 +49659,8 @@ async function acceptBrokerDelivery(payload) {
         relayMessageId: messageId2,
         returnAddress: buildBrokerReturnAddressForActor(snapshot2, requesterId, {
           conversationId: conversation2.id,
-          replyToMessageId: messageId2
+          replyToMessageId: messageId2,
+          sessionId: replyToSessionId
         })
       }
     };
@@ -47629,7 +49725,8 @@ async function acceptBrokerDelivery(payload) {
         relayMessageId: messageId2,
         returnAddress: buildBrokerReturnAddressForActor(snapshot2, requesterId, {
           conversationId: conversation2.id,
-          replyToMessageId: messageId2
+          replyToMessageId: messageId2,
+          sessionId: replyToSessionId
         })
       }
     };
@@ -47651,7 +49748,14 @@ async function acceptBrokerDelivery(payload) {
       message: message2
     };
   }
-  const resolved = resolveBrokerDeliveryTarget(payload);
+  const resolved = await resolveBrokerDeliveryTargetWithImplicitProjectCard({
+    ...payload,
+    execution
+  }, {
+    requesterId,
+    currentDirectory: projectPathRouteTarget(payload),
+    reason: "implicit project delivery card"
+  });
   if (resolved.kind !== "resolved") {
     const { record: record2 } = await recordScoutDispatchDurably(buildDispatchEnvelope(resolved, askedLabel, nodeId, runtime.snapshot(), { homeEndpointFor: homeEndpointForAgent }), {
       requesterId
@@ -47732,6 +49836,7 @@ async function acceptBrokerDelivery(payload) {
     metadata: {
       ...payload.messageMetadata ?? {},
       ...labels.length ? { labels } : {},
+      ...targetSessionId ? { targetSessionId } : {},
       relayChannel: deliveryChannel || (conversation.kind === "direct" ? "dm" : "shared"),
       relayTarget: resolved.agent.id,
       relayTargetIds: [resolved.agent.id],
@@ -47739,7 +49844,8 @@ async function acceptBrokerDelivery(payload) {
       ...collaborationRecordId ? { collaborationRecordId, workId: collaborationRecordId } : {},
       returnAddress: buildBrokerReturnAddressForActor(snapshot, requesterId, {
         conversationId: conversation.id,
-        replyToMessageId: messageId
+        replyToMessageId: messageId,
+        sessionId: replyToSessionId
       })
     }
   };
@@ -47752,6 +49858,7 @@ async function acceptBrokerDelivery(payload) {
       requesterId,
       requesterNodeId,
       targetAgentId: resolved.agent.id,
+      targetSessionId,
       targetLabel,
       conversationId: conversation.id,
       messageId
@@ -47764,14 +49871,20 @@ async function acceptBrokerDelivery(payload) {
       conversation,
       message,
       targetAgentId: resolved.agent.id,
+      ...targetSessionId ? { targetSessionId } : {},
       ...workRecord?.kind === "work_item" ? { workItem: workRecord } : {}
     };
   }
   const invocationMetadata = {
     ...typeof payload.messageMetadata?.source === "string" && payload.invocationMetadata?.source === undefined ? { source: payload.messageMetadata.source } : {},
     ...payload.invocationMetadata ?? {},
+    ...targetSessionId ? { targetSessionId } : {},
     ...payload.intent === "tell" && payload.invocationMetadata?.sourceIntent === undefined ? { sourceIntent: "direct_message" } : {}
   };
+  const invocationExecution = {
+    ...execution ?? (payload.intent === "tell" ? { session: "any" } : {}),
+    ...targetSessionId ? { session: "existing", targetSessionId } : {}
+  };
   const invocation = {
     id: createRuntimeId2("inv"),
     requesterId,
@@ -47782,7 +49895,7 @@ async function acceptBrokerDelivery(payload) {
     ...collaborationRecordId ? { collaborationRecordId } : {},
     conversationId: conversation.id,
     messageId,
-    execution: payload.execution ?? (payload.intent === "tell" ? { session: "any" } : undefined),
+    ...Object.keys(invocationExecution).length > 0 ? { execution: invocationExecution } : {},
     ensureAwake: payload.ensureAwake ?? true,
     stream: false,
     createdAt,
@@ -47790,12 +49903,14 @@ async function acceptBrokerDelivery(payload) {
     metadata: {
       ...invocationMetadata,
       ...labels.length ? { labels } : {},
+      ...targetSessionId ? { targetSessionId } : {},
       relayChannel: deliveryChannel || (conversation.kind === "direct" ? "dm" : "shared"),
       relayTarget: resolved.agent.id,
       ...collaborationRecordId ? { collaborationRecordId, workId: collaborationRecordId } : {},
       returnAddress: buildBrokerReturnAddressForActor(snapshot, requesterId, {
         conversationId: conversation.id,
-        replyToMessageId: messageId
+        replyToMessageId: messageId,
+        sessionId: replyToSessionId
       })
     }
   };
@@ -47814,6 +49929,7 @@ async function acceptBrokerDelivery(payload) {
       requesterId,
       requesterNodeId,
       targetAgentId: resolved.agent.id,
+      targetSessionId,
       targetLabel,
       bindingRef,
       conversationId: conversation.id,
@@ -47823,6 +49939,7 @@ async function acceptBrokerDelivery(payload) {
     conversation,
     message,
     targetAgentId: resolved.agent.id,
+    ...targetSessionId ? { targetSessionId } : {},
     bindingRef,
     flight,
     ...workRecord?.kind === "work_item" ? { workItem: workRecord } : {}
@@ -47906,6 +50023,9 @@ setTimeout(() => {
   reconcileStaleWorkingFlights().catch((error48) => {
     console.error("[openscout-runtime] stale flight reconciliation failed:", error48);
   });
+  reconcileStaleLocalDeliveries().catch((error48) => {
+    console.error("[openscout-runtime] stale delivery reconciliation failed:", error48);
+  });
 }, 0).unref();
 discoverPeers().catch((error48) => {
   console.error("[openscout-runtime] initial mesh discovery failed:", error48);